香蕉久久永久视频,亚洲AV无码久久寂寞少妇,久久精品国产99国产精品澳门

C++/CLI学习入门(�?:跟踪句柄、跟�t�引用及内部指针

英勇的近卫军 — Thu, 09 Jul 2009 13:47:00 GMT

与本地C++自己�l�护堆不同，C++/CLI中动态分配的内存是由CLR来维护的。当不需要堆�Ӟ��CLR自动��其删除回收�Q�同时CLR�q�能自动地压�~�内存堆以避免��生不必要的内存碎片。这�U�机制能够避�?strong>内存泄露�?strong>内存��片�Q�被�U�Cؓ垃圾回收�Q�而由CLR��理的这�U�堆被称为CLR堆。它由操作符gcnew创徏�?/p>

�׃��垃圾回收机制会改变堆中对象的地址�Q�因此不能在CLR堆中使用普通C++指针�Q�因为如果指针指向的对象地址发生了变化，则指针将不再有效。�ؓ了能够安全地讉K��堆对象，CLR提供了跟�t�句柄（�c�M��于C++指针�Q�和跟踪引用�Q�类��g��C++�Q�引用�?/p>

一、跟�t�句�?/h1>

跟踪句柄�c�M��于本地C++指针�Q�但能够被CLR垃圾回收器自动更��C��反映被跟�t�对象的新地址。同时不允许对跟�t�句柄进行地址的算术运��，也不能够�q�行强制�c�d��转换�?/p>

凡是在CLR堆上创徏的对象必��被跟踪句柄引用�Q�这些对象包括：(1)用gcnew操作�W�显�C�创建在堆上的对象；(2)所有的引用数据�c�d��Q�数值类型默认分配在堆栈上）�?strong>注意�Q�所有分配在堆上的对象都不能在全局范围内被创徏�?/font>

关于跟踪句柄的相关��用方法参见�?a href="http://www.shnenglu.com/golq/archive/2009/06/29/88733.html">C++/CLI学习入门(�?:数组�?/p>

二、跟�t�引�?/h1>

跟踪引用�c�M��于本地C++引用�Q�表�C�某对象的别名。可以给堆栈上的值对象、CLR堆上的跟�t�句柄创��t�引用。跟�t�引用本�w��L��在堆栈上创徏的。如果垃圑֛�收移动了被引用的对象�Q�则跟踪引用��被自动更新�?/p>

跟踪引用�?来定义，下面的例子创��Z��一个对堆栈上值对象的跟踪引用�Q?/p>

int value = 10;
int% trackValue = value;

stackValue为value变量的引用，可以用stackValue来访问value�Q?/p>

trackValue *= 5;
Console::WriteLine(value);	// Result is 50

三、内部指�?/h1>

C++/CLI�q�提供一�U�用关键字interior_ptr定义的内部指针，它允许进行地址的算术操作。必要时�Q�该指针内存储的地址会由CLR垃圾回收自动更新。注意，内部指针��L��函数的局部自动变量�?/p>

下面的代码定义了一个内部指针，它含有某数组中第一个元素的地址�Q?/p>

array<double>^ data = {1.5, 3.5, 6.7, 4.2, 2.1};
interior_ptr<double> pstart = %data[0];

必须�l�interio_ptr指定内部指针指向的对象类型。此外还应该�l�指针进行初始化�Q�如果不提供初始��|��pȝ��其默认初始化�ؓnullptr�?/p>

内部指针在指定类型时应注意：可以包含堆栈上值类型对象的地址�Q�也可以包含指向CLR堆上某对象句柄的地址�Q�还可以是本地类对象或本地指针，�?strong>不能是CLR堆上整个对象的地址。也��是��_��可以使用内部指针存储作�ؓCLR堆上对象�l�成部分的数值类对象�Q�如CLR数组元素�Q�的地址�Q�也可以存储System::String对象跟踪句柄的地址�Q�但不能存储String对象本��n的地址�?/p>

interior_ptr pstr1;	// OK -- pointer to a handle
interior_ptr  pstr2;	// ERROR -- pointer to a String object

与本地C++指针一��P��内部指针可以�q�行��术计算。可以通过递增或递减来改变其包含的地址�Q�从而引用后面或前面的数据项�Q�还可在内部指针上加上或减去某个整数�Q�可以比较内部指针。下面的例子展示了内部指针的用法�Q?/p>

- - - - - - - - - - - - - - - - <<== 华丽的分割线 ::开�?=>> [Ex4_19.cpp] - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

// Ex4_19.cpp : main project file.
#include "stdafx.h"
using namespace System;

int main(array ^args)
{
	array<double>^ data = {1.5, 3.5, 6.7, 4.2, 2.1};
	interior_ptr<double> pstart = &data[0];
	interior_ptr<double> pend = &data[data->Length - 1];
	double sum = 0;

	while(pstart<=pend)
		sum += *pstart++;

	Console::WriteLine(L"Total of data array elements = {0}\n", sum);

	array^ strings = { L"Land ahoy!",
		L"Splice the mainbrace!",
		L"Shiver me timbers!",
		L"Never throw into the wind!"
	};

	for(interior_ptr pstrings = &strings[0]; pstrings-&strings[0] < strings->Length; ++pstrings)
		Console::WriteLine(*pstrings);

    return 0;
}

- - - - - - - - - - - - - - - - <<== 华丽的分割线 ::�l�束==>> [Ex4_19.cpp] - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

输出�?/p>

Total of data array elements = 18

Land ahoy!
Splice the mainbrace!
Shiver me timbers!
Never throw into the wind!

英勇的近卫军 2009-07-09 21:47 发表评论

英勇的近卫军 — Tue, 07 Jul 2009 15:39:00 GMT

C++/CLI字符�Ԍ��Unicode字符�l�成的字�W�串�Q�是指在System命名�I�间中定义的String�c�，即由System:Char�c�d��的字�W�序列组成的字符丌Ӏ�它包含大量强大的功能，使得字符串的处理非常�Ҏ��。创��Z��个String对象的方法如下例所�C�：

System::String^ saying = L"Many hands make light work.";

跟踪句柄saying用于讉K��String�c�d��象。该对象的字�W��ؓ宽字�W�，因�ؓ采用了前�~� “L”，如果省略“L”，该字�W�串�?位的字符�l�成�Q�编译器��确保将其�{换成宽字�W��?/p>

讉K��字符串内字符可以像访问数�l�元素一��P��使用索引来访问，首字�W�的索引�?。这�U�方法只能用于读取字�W�串内字�W�，但不能用于修改字�W�串的内宏V�?/p>

Console::WriteLine("The third character in the string is {0}", saying[2]);

利用Length属性，可以获取字符串内字符的数量（长度�Q��?/p>

Console::WriteLine("The saying has {0} charactors.", saying->Length);

一、连接字�W�串

利用 �?”可以连接字�W�串�Q��Ş成新的字�W�串。执行下面的例子之后�Q�name3��包含字�W�串 “Beth and Betty”�?/p>

String^ name1 = L"Beth";
String^ name2 = L"Betty";
String^ name3 = name1+L" and "+name2;

�?”还可以用来�q�接字符串与数倹{��bool值等非字�W�串变量�Q�在�q�接之前�Q�这些变量将自动的�{换成字符丌Ӏ?/p>

String^ str = L"Value: ";
String^ str1 = str + 2.5;	// str1 is "Value: 2.5"
String^ str2 = str + 25;	// str2 is "Value: 25"
String^ str3 = str + true;	// str3 is "Value: True"

�?”还可以用来�q�接字符串与字符�Q�但要注意，�l�果字符串的形式取决于字�W�的�c�d��?/strong>�q�是因�ؓchar�c�d��的字�W�被视�ؓ数��|��wchar_t与String对象的字�W�具有相同的�c�d��Q�Char�c�d��Q��?/p>

char ch = 'Z';
wchar_t wch = 'Z';
String^ str4 = str + ch;	// str4 is "Value: 90"
String^ str5 = str + wch;	// str5 is "Value: Z"

String�c�d��定义了Join()函数�Q�用于将数组中的多个字符串连接成一个字�W�串�Q�数�l�元素之间用分隔�W�隔开�Q�如
array^ names = {"Jill", "Ted", "Mary", "Eve", "Bill"}; String^ seperator = " and "; String^ joined = String::Join(seperator, names); // joined is "Jill and Ted and Mary and Eve and Bill"

特别注意�Q�String对象是固定不变的�Q�一旦创建完毕后��׃��能再被修改了。这意味着所有的字符串操作都是在创徏新的字符丌Ӏ?/strong>

下面的例子将整数数组内的元素按列整齐地输出�?/p>
- - - - - - - - - - - - - - - - <<== 华丽的分割线 ::开�?=>> [Ex4_17.cpp] - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Ex4_17.cpp : main project file. #include "stdafx.h" using namespace System; int main(array ^args) { array<int>^ values = { 2, 456, 23, -46, 34211, 456, 5609, 112098, 234, -76504, 341, 6788, -909121, 99, 10 }; String^ formatStr1 = "{0, "; String^ formatStr2 = "}"; String^ number; int maxLength = 0; for each(int value in values) { number = ""+value; if(maxLengthLength) maxLength = number->Length; } String^ format = formatStr1+(maxLength+1)+formatStr2; int numberPerLine = 3; for(int i=0; iLength; i++) { Console::Write(format, values[i]); if((i+1)%numberPerLine == 0) Console::WriteLine(); } }

- - - - - - - - - - - - - - - - <<== 华丽的分割线 ::�l�束==>> [Ex4_17.cpp] - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

输出�?/p>
2 456 23 -46 34211 456 5609 112098 234 -76504 341 6788 -909121 99 10

二、修改字�W�串

Trim()函数用于删除字符串头部和��N��的空根{��不带参数调用该函数��删除字�W�串头、尾部的全部�I�格�q�返回一新字�W�串�?/p>
String^ str = {" Handsome is as handsome does... "}; String^ newStr = str->Trim();

也可传递给Trim()函数字符数组作�ؓ参数�Q�字�W�串��?strong>从头部和��N��开�?/strong>删除数组中的字符。如果字�W�出现在字符串中��_��则不会被删除�?/p>
String^ toBeTrimed = L"wool wool sheep sheep wool wool wool"; array^ notWanted = {L'w', L'o', L'l', L' ' }; Console::WriteLine(toBeTrimed->Trim(notWanted));

上面的语句将输出
sheep sheep

如果在上面的语句中没有加前缀”L“，则字�W��ؓchar�c�d��Q�对应于System::SByte�c�d��。不�q�编译器��自动地��其转换成wchar_t�c�d��Q�即System::Char�c�d��Q��?/p>
Trim()函数也支持直接输入要删除的字�W�列表，下面的语句将产生同样的输�?/p>
Console::WriteLine(toBeTrimed->Trim(L'w', L'o', L'l', L' '));

如果仅仅惌��删除头部或者尾部中的一端，可以使用TrimStart或者TrimEnd函数�?/p>
如果要在字符串的一端填充空格或其它字符�Q�这一般用于以固定宽度靠左或靠叛_��齐输出文本）�Q�可使用PadLeft()和PadRight()函数。如果字�W�串长度大于指定的长度参敎ͼ�则返回字�W�串为长度等于原来字�W�串的新字符丌Ӏ?/p>
String^ value = L"3.142"; String^ leftPadded = value->PadLeft(10); // Result is " 3.142" String^ rightPadded = value->PadRight(10); // Result is "3.142 " String^ leftPadded2 = value->PadLeft(10, L'*'); // Result is "*****3.142" String^ rightPadded2= value->PadRight(10,L'#'); // Result is "3.142#####"

如果需要将字符串�{换成大写或小写，可��用ToUpper()或ToLower函数�?/p>
String^ proverb = L"Many hands make light work." String^ upper = proverb->ToUpper(); // Result is "MANY HANDS MAKE LIGHT WORK."

如果需要在字符串中间插入一个字�W�串�Q�可使用Insert()函数�Q�第一个参数指定�v始位�|�的索引�Q�第二个参数指定要插入的字符丌Ӏ?/p>
String^ proverb = L"Many hands light work."; String^ newProverb = proverb->Insert(5, "deck ");

�l�果�?/p>
Many deck hands make light work.

如果要用另一个字�W�替换字�W�串中指定的字符�Q�或者用另一个子串替换字�W�串中给定的子串�Q�可使用Replace()函数�?/p>
String^ proverb = L"Many hands make light work." Console::WriteLine(proverb->Replace(L' ', L'*'); Console::WriteLine(proverb->Replace(L"Many hands", L"Press switch");

输出�?/p>
Many*hands*make*light*work. Pressing switch make light work.

三、搜索字�W�串

如果需要测试字�W�串是否以给定的子串开始或�l�束�Q�可使用StartWith()或EndWith()函数。要��L��的子串句柄作为参��C��递给函数�Q�返回bool倹{�?/p>
String^ snetence = L"Hide, the cow's outside."; if(sentence->StartWith(L"Hide")) Console::WriteLine("The sentence starts with 'Hide'.");

IndexOf()函数用于�q�回�l�定字符或子串在字符串中扑ֈ�的第一个实例烦引，如果未找刎ͼ�则返�?1�?/p>
String^ sentence = L"Hide, the cow's outside."; int ePosition = sentence->IndexOf(L'e'); // Return 3 int thePosition = sentence->IndexOf(L"the"); // Retuen 6

也可以指定IndexOf搜烦的�v始烦引，�q�一般用于遍历整个字�W�串扑և�所有的实例�Q�如下面的例子：
int index = 0; int count = 0; while((index=words->IndexOf(word, index))>=0) { index += word->Length; count++; } Console::WriteLine(L"'{0}' was found {1} times in: {2}", word, count, words);

LastIndexOf()函数�c�M��于IndexOf()函数�Q�不�q�它用于从字�W�串��N��或指定烦引位�|�开始，倒着向头部搜索。注意：如果从尾部开始的索引值是words->Lenght-1�?/p>
如果要搜索一个字�W�串数组中�Q意元素出现在字符串中的位�|�，可以使用IndexOfAny()函数。同��P��它也有倒序搜烦的版本�?下面的例子说明了IndexOfAny()的用法。下面的例子用于搜烦字符串中的标点符�?/p>
- - - - - - - - - - - - - - - - <<== 华丽的分割线 ::开�?=>> [Ex4_18.CPP] - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Ex4_18.cpp : main project file. #include "stdafx.h" using namespace System; int main(array ^args) { array^ punctuation = {L'"', L'\'', L'.', L',', L':',L'!', L'?'}; String^ sentence = L"\"It's chilly in here\", the boy 's mother said coldly."; array^ indicators = gcnew array(sentence->Length){L' '}; int index = 0; int count = 0; while((index=sentence->IndexOfAny(punctuation, index))>=0) { indicators[index] = L'^'; ++index; ++count; } Console::WriteLine(L"There are {0} punctuation charactors in the string:", count); Console::WriteLine(L"\n{0}\n{1}", sentence, gcnew String(indicators)); return 0; }

- - - - - - - - - - - - - - - - <<== 华丽的分割线 ::�l�束==>> [Ex4_18.cpp] - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
输出�?/em>
There are 6 punctuation charactors in the string: "It's chilly in here", the boy 's mother said coldly. ^ ^ ^^ ^ ^

英勇的近卫军 2009-07-07 23:39 发表评论

C++/CLI学习入门(�?:数组

英勇的近卫军 — Sun, 28 Jun 2009 17:34:00 GMT

要学习数�l�，必须先了解跟�t�句柄�?/p>
一、跟�t�句�?/h1>
跟踪句柄�c�M��于本地C++指针�Q�但也有很大区别。跟�t�句柄确实存储着某个对象的地址�Q�但当CLR压羃堆过�E�中改变了该对象的地址�Q�则垃圾回收器自动更新句柄所包含的地址。我们不能像本地指针那样用跟�t�句柄来执行地址的算术运��，也不允许对跟�t�句柄进行强制类型�{换�?

在CLR堆中创徏的对象必��被跟踪句柄引用。所有属于引用类型的对象都存储在堆中�Q�因此�ؓ引用�q�些对象所创徏的变量都必须是跟�t�句柄。例如，String�c�d��是引用类型，因此引用String对象的变量必��L��跟踪句柄。值类型默认分配在堆栈上，但也可以用gcnew操作�W�将其存储在堆上。此外必��L��意，在堆上分配的变量——其中包括所有CLR引用�c�d��——都不能在全局作用域内声明�?

通过在类型名�U�后加”^”符��P��用于声明一个该�c�d��的句柄。下面的例子声明了一个String�c�d��的跟�t�句柄proverb�?
String^ proverb;

在声明时句柄�Ӟ��pȝ��自动为其分配一个空��|��该句柄不引用��M��对象。也可显�C�地��某个句柄置为空�?
proverb = nullptr;

注意不能�?来表�C�空倹{��如果用0来初始化某个句柄�Q�则0��自动�{换�ؓ被引用类型的对象�Q�而句柄则指向该对象。可以在声明句柄时显�C�的��其初始化：
String^ saying = L"I used to think I was indecisive but now I??¡�^¡؈m not so sure.";

该语句首先在堆上创徏一个包含等号右边字�W�串的String对象�Q�然后将该对象的地址存入saying中。注意字�W�串字面值的�c�d��为const wchar_t*而非String。类String提供了这��L��Ҏ��使得const wchar_t*�c�d��的字�W�串可以用来创徏String�c�d��的对象�?

下面�q�条语句创徏了值类型的句柄�Q?/p>
int^ value = 99;

      该语句在堆上创徏一个Int32型的值类型变量，然后��该变量的地址存入句柄value中。由于value是一�U�指针，因此不能直接参与��术�q�算�Q�可使用*�q�算�W�对地址求��|��c�M��于本地C++指针那样�Q?
int result = 2*(*value)+15;

      �׃��*value表示value所指向地址存储的数��|��因此result的��gؓ2*99+15=213。注意，当value作�ؓ�q�算式左值时�Q�不需�?卛_��对value指向的变量赋倹{�?
int^ result = 0; result = 2*(*value)+15;

      首先创徏了一个指向数�?的句柄result。（该语句会触发一条编译器警告�Q�提�C�Z��能利�?来将句柄初始化�ؓ�I�倹{��）

      �W?条语�?号右边�ؓ数��|��而左边�ؓ句柄�Q�编译器��自动将叛_��D��予句柄所指向的对象，卛_��其�{换�ؓ如下语句
*result = 2*(*value)+15;

       注意�Q�要采用上面的语句，result句柄必须实际定义�q�。如果仅仅声明了result�Q�则会��生运行时错误
int^ result; *result = 2*(*value)+15;

       �q�是因�ؓ�W�二句要对地址result求��|��x��味着result指向的对象已�l�存在，但实际�ƈ非如此，因�ؓ声明该对象时�pȝ��默认赋予其空�?nullptr)。在�q�种情况下，采用下面的方法就可以正常工作�?
int^ result; result = 2*(*value)+15;

二、数�l?/h1>
(一)数组句柄

       CLR数组是分配在可回收垃圑֠�上的。必��ȝ��array<typename>指出要创建的数组�Q�同其它CLR堆上的对象一��P��需要用句柄来访问它�Q�例子如下：
array<int>^ data;

      数组句柄data可用于存储对元素�c�d��为int的一�l�数�l�的引用。下面的例子声明了一个句柄，�q�新��Z��个CLR数组来对此句柄初始化�?/p>
array<int>^ data = gcnew array<int>(100);

       和本地C++数组一��P��CLR数组中元素的索引��g��是从0开始的�Q�可以通过[ ]讉K��数组元素。数�l�元素都是CLR对象�Q�在上面的例子中数组元素为Int32型对象，它们在算术表辑ּ�中就像普通的整数�c�d��一栗��?

       Length属性是数组的一个重要属性，记录着数组元素的数量。保存了64位的数组长度�?
for(int i=0; iLength; i++) data[i] = 2*(i+1);

可以用for each循环遍历数组元素�?/p>
array<int>^ value = {3, 5, 6, 8, 6}; for each(int item in value) { item = 2*item + 1; Console::WriteLine("{0, 5}", item); }

该��@环输�?字符宽度的字�D�，以右寚w��的方式输出当前元素的计算�l�果�Q�输出如下：
7 11 13 17 13

       数组句柄可以被重新赋��|��只要保持数组元素�c�d��和维敎ͼ��{��Q�不变即可，在前面例子中的数�l�句柄data指向一个int�c�d��的一�l�数�l�，可以重新�l�它赋��|��使其指向另外的int�c�d��1�l�数�l�：
data = gcnew array<int>(45);

       数组可以在创建时通过元素列表初始化，下例在CLR堆上创徏了一个double�c�d��的数�l�，�q�将引用赋值给了数�l�句柄：
array<double>^ sample = {3.4, 2.3, 6.8, 1.2, 5.5, 4.9, 7.4, 1.6};

       如果在声明数�l�句柄时不进行初始化�Q�那么在�l�句柄赋值时不能采用上面的方法直接用元素列表用作叛_��|��而必��采用显�C�创建的方式。即不能
array<double>^ sample; sample = {3.4, 2.3, 6.8, 1.2, 5.5, 4.9, 7.4, 1.6}

       而必��采用如下方�?
array<double>^ sample; sample = gcnew array<double>{3.4, 2.3, 6.8, 1.2, 5.5, 4.9, 7.4, 1.6}

       对于字符串数�l�，注意每一个元素也是引用类型，�q�是因�ؓ每一个元素String也是在CLR堆上创徏的，因此也要用String^来访问它�?
array^ names = {"Jack", "John", "Joe", "Jessica", "Jim", "Joanna"};

       可以用Array�c�静态函数Clear()�Ҏ��l�中的连�l�数�l�元素清零�?
Array::Clear(samples, 0, samples->Length);

       Clear()函数的第一个参数是被清零的数组�Q�第二个参数是要清除地第一个元素的索引�Q�第三个参数��清除地元素数量。因此上�q�语句将samples数组的所有元素都�|��ؓ0。如果Clear()清除的是某个跟踪句柄�Q�则句柄所对应的元素都被应用Clear()函数。如果元素�ؓbool型，则被�|��ؓfalse�?

(�?数组排序

Array�c�还定义了一个Sort()静态函敎ͼ�可用于对数组�q�行排序。如果以数组句柄作�ؓ参数�Q�则�Ҏ��个数�l�排序。如果要�Ҏ��l�部分排序，则还需要增加元素�v始烦引及数量�Q�如下例
array<int>^ samples = {27, 3, 54, 11, 18, 2, 16}; Array::Sort(samples, 2, 3);

排序后数�l�元素变为{27, 3, 11, 18, 54, 2, 16}

Sort函数�q�有很多其它版本�Q�下面的例子展示了如何排序两个相关的数组�Q�即�W�一个数�l�中的元素是�W�二个数�l�对应元素的键。对�W�一个数�l�排序后�Q�可对第二个数组�q�行相应的调��_��使得键与值相互对应�?/p>
Sort()函数�?个数�l�排序时�Q�用�W�一个数�l�参数来��定两个数组的顺序，以此保持2个数�l�元素对应关�p�M��变�?/p>
- - - - - - - - - - - - - - - - <<== 华丽的分割线 ::开�?=>> [Ex4_13.cpp] - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Ex4_13.cpp : main project file. #include "stdafx.h" using namespace System; int main(array ^args) { array^ names = { "Jill", "Ted", "Mary", "Eve", "Bill", "Al" }; array<int>^ weights = {103, 168, 128, 115, 180, 176}; Array::Sort(names, weights); for each( String^ name in names ) Console::Write(L"{0, 10}", name); Console::WriteLine(); for each(int weight in weights) Console::Write(L"{0, 10}", weight); Console::WriteLine(); return 0; }

- - - - - - - - - - - - - - - - <<== 华丽的分割线 ::�l�束==>> [Ex4_13.cpp] - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
输出为：
Al Bill Eve Jill Mary Ted 176 180 115 103 128 168

(�?数组搜烦

Array�c�还提供了函数BinarySearch()以��用对分法搜烦��法�Q�对一�l�数�l�或�l�定范围内搜索特定元素的索引位置。��用该函数要求数组必须是顺序排列的�Q�因此在搜烦之前必须�Ҏ��l�进行排序�?/p>
array<int>^ value = { 23, 45, 68, 94, 123, 150, 203, 299 }; int toBeFound = 127; int position = Array::BinarySearch(value, toBeFound); if(position<0) Console::WriteLine(L"{0} was not found.", toBeFound); else Console::WriteLine(L"{0} was found at index position {1}", toBeFound, position);

Array::BinarySearch()的第一个参数是被搜索数�l�的句柄�Q�第二个参数是要查找的内容，�q�回��gؓint�c�d��的数倹{��如果返回值小�?则说明未扑ֈ�。如果要指定搜烦范围�Q�则需要传�?个参敎ͼ�其中�W?参数为搜索�v始烦引，�W?参数为搜索的元素数量�Q�第4个是要搜索的内容。下面的代码从第4个元素开始，一直搜索到�l�束位置�?/p>
array<int>^ value = { 23, 45, 68, 94, 123, 150, 203, 299 }; int toBeFound = 127; int position = Array::BinarySearch(value, 3, 6, toBeFound);

- - - - - - - - - - - - - - - - <<== 华丽的分割线 ::开�?=>> [Ex4_14.cpp] - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Ex4_14.cpp : main project file. #include "stdafx.h" using namespace System; int main(array ^args) { array^ names = { "Jill", "Ted", "Mary", "Eve", "Bill", "Al", "Ned", "Zoe", "Dan", "Jean" }; array<int>^ weights = {103, 168, 128, 115, 180, 176, 209, 98, 190, 130}; array^ toBeFound = {"Bill", "Eve", "Al", "Fred"}; int result = 0; Array::Sort(names, weights); for each( String^ name in toBeFound ) { result = Array::BinarySearch(names, name); if(result<0) Console::WriteLine(L"{0} was not found.", name); else Console::WriteLine(L"{0} weights {1} lbs.", name, weights[result]); } return 0; }

- - - - - - - - - - - - - - - - <<== 华丽的分割线 ::开�?=>> [Ex4_14.cpp] - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

        当搜索不到目标时�Q�Array::BinarySearch()函数输出的�ƈ非�Q意负敎ͼ�而是�W�一个大于该目标的元素烦引值的按位补码。利用该�Ҏ��Q�可以不打�ؕ��序在数�l�中插入新倹{��如�Q�我们希望插入”Fred”到names数组�?/p>
array^ names = { "Jill", "Ted", "Mary", "Eve", "Bill", "Al", "Ned", "Zoe", "Dan", "Jean" } Array::Sort(names); String^ name = L"Fred"; int position = Array::BinarySearch(names, name); if(position<0) position = ~position;

此时�Q�position保存的是大于Fred的第一个元素的位置�Q�该数值可用于插入新倹{�?/p>
array^ newNames = gcnew array(names->Length+1); for(int i=0;iif(positionLength) for(int i=position; iLength; i++) newNames[i+1] = names[i]; names = nullptr;

注意�Q�最后一句用于删除names数组�?

(�?多维数组

C++/CLI中可以创建多�l�数�l�，最大维�?2�l�。与ISO/ANSI C++不同的是�Q�C++/CLI中的多维数组�q��数组的数�l�，而是真正的多�l�数�l�，创徏整数多维数组�Ҏ��如下�Q?/p>
array<int 2>^ value = gcnew array<int, 2>(4, 5);

上面的代码创��Z��一个二�l�数�l�，四行五列�Q�共20个元素。访问的�Ҏ��是利用多个用逗号分隔的烦引值来讉K��每一个元素，而不能用一个烦引��D��问一�?/p>
int nrows = 4; int ncols = 5; array<int, 2>^ value = gcnew array<int, 2>(nrows, ncols); for(int i=0; i for(int j=0; j
上面的代码利用��@环给二维数组value赋倹{��这里访问二�l�数�l�元素的�W�号与本地C++不同�Q�后者实际上是数�l�的数组�Q�而C++/CLI是真正的二维数组�Q�不能用一个烦引值来讉K��二维数组�Q�那��h��没有意义的。数�l�的�l�数被称为等�U�，上面value数组的等�U��ؓ2。而本地C++数组的等�U�始�l��ؓ1。当�Ӟ��在C++/CLI中也可以定义数组的数�l�，�Ҏ��见下�?/p>
- - - - - - - - - - - - - - - - <<== 华丽的分割线 ::开�?=>> [Ex4_15.cpp] - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Ex4_15.cpp : main project file. #include "stdafx.h" using namespace System; int main(array ^args) { const int SIZE = 12; array<int, 2>^ products = gcnew array<int, 2>(SIZE, SIZE); for(int i=0; ifor(int j=0; jHere is the {0} times table:", SIZE); // Write horizontal divider line for(int i=0; i<=SIZE; i++) Console::Write(L"_____"); Console::WriteLine(); // Write top line of table Console::Write(L" |"); for(int i=1; i<=SIZE; i++) Console::Write("{0, 3} |", i); Console::WriteLine(); // Write horizontal divider line with verticals for(int i=0; i<=SIZE; i++) Console::Write("____|", i); Console::WriteLine(); // Write remaining lines for(int i=0; i{0, 3} |", i+1); for(int j=0; j{0, 3} |", products[i, j]); Console::WriteLine(); } // Write horizontal divider line for(int i=0; i<=SIZE; i++) Console::Write("_____", i); Console::WriteLine(); return 0; }

- - - - - - - - - - - - - - - - <<== 华丽的分割线 ::�l�束==>> [Ex4_15.cpp] - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

上面的例子创��Z��一�?2x12的乘法表�Q�输出如下：
Here is the 12 times table: _________________________________________________________________ | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | ____|____|____|____|____|____|____|____|____|____|____|____|____| 1 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 2 | 2 | 4 | 6 | 8 | 10 | 12 | 14 | 16 | 18 | 20 | 22 | 24 | 3 | 3 | 6 | 9 | 12 | 15 | 18 | 21 | 24 | 27 | 30 | 33 | 36 | 4 | 4 | 8 | 12 | 16 | 20 | 24 | 28 | 32 | 36 | 40 | 44 | 48 | 5 | 5 | 10 | 15 | 20 | 25 | 30 | 35 | 40 | 45 | 50 | 55 | 60 | 6 | 6 | 12 | 18 | 24 | 30 | 36 | 42 | 48 | 54 | 60 | 66 | 72 | 7 | 7 | 14 | 21 | 28 | 35 | 42 | 49 | 56 | 63 | 70 | 77 | 84 | 8 | 8 | 16 | 24 | 32 | 40 | 48 | 56 | 64 | 72 | 80 | 88 | 96 | 9 | 9 | 18 | 27 | 36 | 45 | 54 | 63 | 72 | 81 | 90 | 99 |108 | 10 | 10 | 20 | 30 | 40 | 50 | 60 | 70 | 80 | 90 |100 |110 |120 | 11 | 11 | 22 | 33 | 44 | 55 | 66 | 77 | 88 | 99 |110 |121 |132 | 12 | 12 | 24 | 36 | 48 | 60 | 72 | 84 | 96 |108 |120 |132 |144 | _________________________________________________________________

其中创徏二维数组的代码如下：
const int SIZE = 12; array<int, 2>^ products = gcnew array<int, 2>(SIZE, SIZE);

�W�一行定义了一个整型常量SIZE�Q�用于指定每一�l�数�l�的元素数量�Q�第二行代码定义了一个等�U?的数�l�，�?2x12大小�Q�该数组用于存储12x12的乘法表乘积。然后在嵌套循环中给数组赋��|��大部分代码用于格式化输出以��其更加美观，�q�里��׃��再说明�?/p>
(�?数组的数�l?/h2>
如果数组的元素是引用数组的跟�t�句柄，那么��可以创建数�l�的数组。同�Ӟ��每一�l�数�l�的长度可以不同�Q�即所谓的“锯齿�Ş数组”。例如，用ABCDE来表�C�学生的成�W�{��Q�根据等�U�分�l�存储班内学生的姓名�Q�则可以创徏一个包�?个元素的数组�Q�每个元素�ؓ一个姓名数�l�（卛_��W�串数组�Q?/p>
array^>^ grades = gcnew array^>(5)

利用上面创徏的数�l�，然后可以创徏5个姓名数�l�了
grades[0] = gcnew array{"Louise", "Jack"}; grades[1] = gcnew array{"Bill", "Mary", "Ben", "Joan"}; grades[2] = gcnew array{"Jill", "Will", "Phil"}; grades[3] = gcnew array{"Ned", "Fred", "Ted", "Jed", "Ed"}; grades[4] = gcnew array{"Dan", "Ann"};

grades[n]讉K��grades数组的第n个元素，而各元素为指向String^�c�d��数组的句柄，因此上面的语句用于创��Z��String对象句柄的数�l�，�q�将创徏数组的地址赋值给了grades数组元素。同�Ӟ��q�些字符串数�l�的长度是不同的�?/p>
上面的语句也可以用一个初始化语句来实�?/p>
array^>^ grades = gcnew array^> { gcnew array{"Louise", "Jack"}, gcnew array{"Bill", "Maray", "Ben", "Joan"}, gcnew array{"Jill", "Will", "Phil"}, gcnew array{"Ned", "Fred", "Ted", "Jed", "Ed"}, gcnew array{"Dan", "Ann"}, };

注意�Q�元素的初值必��d��在花括号里�?/p>
- - - - - - - - - - - - - - - - <<== 华丽的分割线 ::开�?=>> [Ex4_16.cpp] - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Ex4_16.cpp : main project file. #include "stdafx.h" using namespace System; int main(array ^args) { array^>^ grades = gcnew array^> { gcnew array{"Louise", "Jack"}, gcnew array{"Bill", "Maray", "Ben", "Joan"}, gcnew array{"Jill", "Will", "Phil"}, gcnew array{"Ned", "Fred", "Ted", "Jed", "Ed"}, gcnew array{"Dan", "Ann"} }; wchar_t gradeLetter = 'A'; for each(array^ grade in grades) { Console::WriteLine(L"Students with Grade {0}:", gradeLetter++); for each(String^ student in grade) Console::Write("{0, 12}", student); Console::WriteLine(); } return 0; }

- - - - - - - - - - - - - - - - <<== 华丽的分割线 ::�l�束==>> [Ex4_16.cpp] - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

输出�?/p>
Students with Grade A: Louise Jack Students with Grade B: Bill Maray Ben Joan Students with Grade C: Jill Will Phil Students with Grade D: Ned Fred Ted Jed Ed Students with Grade E: Dan Ann

英勇的近卫军 2009-06-29 01:34 发表评论

英勇的近卫军 — Sat, 27 Jun 2009 08:46:00 GMT

一、基本控制结�?/h1>
ISO/ANSI C++中的控制与��@环全部适用于C++/CLI。下例展�C�Z��C++/CLI控制台程序中的控制��@环：

例子�Q�基本��@环控�?/u>

- - - - - - - - - - - - - - - - <<== 华丽的分割线 ::开�?=>> [Ex3_15.cpp] - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Ex3_15.cpp : main project file. #include "stdafx.h" using namespace System; int main(array ^args) { wchar_t letter; Console::Write(L"Enter a letter:"); letter = Console::Read(); if(letter>='A') if(letter<='Z') { Console::WriteLine(L"You entered a captial letter."); return 0; } if(letter>='a') if(letter<='z') { Console::WriteLine(L"You entered a small letter."); return 0; } Console::WriteLine(L"You did not enter a letter."); return 0; }

- - - - - - - - - - - - - - - - <<== 华丽的分割线 ::�l�束==>> [Ex3_15.cpp] - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

letter被声明�ؓwchar_t�c�d��Q�映��ؓC++/CLI中的System::Char�c�d��Q�它��h��一些特�D�的功能�Q�其中包括将字符代码转换为大写和��写的函敎ͼ�Char::ToUpper�Q�）和Char::ToLower()�Q�被转换的函��C��为参数被传递给�?
wchar_t uppercaseLetter = Char::ToUpper(letter);

此外�q�包括检��字母是否大写或��写的函�?IsUpper()和IsLower()�Q�因此上例可改�ؓ
wchar_t letter; wchar_t upper; Console::Write(L"Enter a letter:"); letter = Console::Read(); upper = Char::ToUpper(letter); if(upper>='A' && upper<='Z') Console::WriteLine(L"You entered a {0} letter.", Char::IsUpper(letter) ? "Capital":"Small"); else Console::WriteLine(L"You entered a small letter.");

Console::ReadKey()函数用于��试按键�Q��ƈ��结果存储在ConsoleKeyInfo�c�d��象里。该�c�L��3个可讉K��属性用于帮助确定被按下的键是哪个或哪些键。属性Key识别被按下的键是哪个�Q�属性KeyChar是被按键的Unicode字符码，属性Modifiers表示Shift,Alt,Ctrl键的按位�l�合�Q�它是定义在System命名�I�间中的枚�D�c�d��ConsoleModifiers的常量，包括Shift\Alt\Control�?/p>
应该注意的是�Q�在C++/CLI中枚丑ָ�量在用作数��g��前必��被昄��的强制�{换�ؓ值类型（整数�c�d��Q?/p>

例子�Q��用Console::ReadKey()函数

- - - - - - - - - - - - - - - - <<== 华丽的分割线 ::开�?=>> [Ex3_16.cpp] - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Ex3_16.cpp : main project file. #include "stdafx.h" using namespace System; int main(array ^args) { ConsoleKeyInfo keyPress; Console::WriteLine(L"Press a key combination - press Escape to quit."); do{ keyPress = Console::ReadKey(true); Console::Write(L"You pressed"); if(safe_cast<int>(keyPress.Modifiers)>0) Console::Write(L" {0}", keyPress.Modifiers); Console::WriteLine(L" {0} which is the {1} character", keyPress.Key, keyPress.KeyChar); }while(keyPress.Key != ConsoleKey::Escape); return 0; }

- - - - - - - - - - - - - - - - <<== 华丽的分割线 ::�l�束==>> [Ex3_16.cpp] - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

该程序的输入�C�Z��如下�Q?
Press a key combination - press Escape to quit. You pressed Enter which is the character You pressed Spacebar which is the character You pressed Spacebar which is the character

从输��Z��可以看出�Q�当不只一个键被按下时�Q�用一条语句就可以得到所有的键。这是因为Modifiers枚�D�c�d��是用FlagsAttribute属性定义的�Q�该属性表明这�U�枚丄��型是一�l�唯一的位标志。这使得该枚丄��型的变量可以��p��q�与在一��L��标志位组成，而Write()或WriteLine()函数可以识别�q�输出各标志位�?

二、for each循环

以例子开�?/p>
- - - - - - - - - - - - - - - - <<== 华丽的分割线 ::开�?=>> [Ex3_17.cpp] - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Ex3_17.cpp : main project file. #include "stdafx.h" using namespace System; int main(array ^args) { int volwels = 0; int consonants = 0; String^ proverb = L"A nod is as good as a wink to a blind horse."; for each(wchar_t ch in proverb) { if(Char::IsLetter(ch)) { ch = Char::ToLower(ch); switch(ch) { case 'a': case 'e': case 'i': case 'o': case 'u': ++volwels; break; default: ++consonants; break; } } } Console::WriteLine(proverb); Console::WriteLine(L"The proverb contains {0} volwels and {1} consonants.", volwels, consonants); return 0; }

- - - - - - - - - - - - - - - - <<== 华丽的分割线 ::�l�束==>> [Ex3_17.cpp] - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

输出为：
A nod is as good as a wink to a blind horse. The proverb contains 14 volwels and 18 consanants.

注意�Q�由于proverb字符串中的字�W�都是Unicode字符�Q�因此用wchar_t�Q�映��ؓChar�c�d��Q�类型的变量来存储这些字�W�。变量ch为��@环内的局部变量�?/p>

英勇的近卫军 2009-06-27 16:46 发表评论

C++/CLI学习入门(一)�Q�基��

英勇的近卫军 — Sat, 27 Jun 2009 08:27:00 GMT

从今日开始，��前期学习《Visual C++ 2005入门�l�典》（Ivor Horton�?清华大学出版�C�և�版）的相关笔记整理到随笔中，希望能和C++/CLI爱好者分享学习过�E�中的心得。文中主要内容和例子摘自原书相关章节�Q�如有��R权，��L��a�或来信告知�?/font>

相比于ISO/ANSI C++而言�Q�C++/CLI�q�行了大量的扩充�Q��ƈ且提供了大量的附加功能。主要包�?

在C++/CLI�E�序中，所有ISO/ANSI基本数据�c�d��都可以��用，但在一些特�D�的上下文环境中�Q�它们具有一些额外属性；

在控制台�E�序中，C++/CLI寚w��盘和命��o行输出提供了自己的机�Ӟ��

C++/CLI中引入了safe_cast�q�算�W�，��保强制�c�d��转换操作能够生成可检验的代码�Q?/div>

C++/CLI提供了另外一�U�基于类的枚丑֊�能，其灵�z�L��超�q�了ISO/ANSI C++中的enum声明�?/div>

一、基本数据类�?/h1>
C++/CLI中包括了所有ISO/ASNI C++中的基本数据�c�d��Q�算术运��也和本地C++完全一栗��除此之外，C++/CLI中还定义�?�U�整数类型，如表1所�C�：

�?:C++/CLI新增基本数据�c�d��

�c�d��

字节

值域

long long

8

�?9223372036854775808�?223372036854775807

Unsigned long long

8

�?�?8446744073709551615

指定long long数据�c�d��Ӟ��需要在整数数值后面加LL或小写字母ll�Q�如
longlong big = 123456789LL;

指定unsinged long long�c�d��Ӟ��需要在整数数值后面加ULL或小写字母ull�Q�如
unsigned long long huge = 123456789LL;

在C++/CLI中，每一个ISO/ANSI C++基本�c�d��名称都映��到System命名�I�间中定义的值类�c�d��。在C++/CLI�E�序中，ISO/ANSI C++基本�c�d��名称都是CLI中对应值类�c�d��的简略�Ş式。表2�l�出了基本类型、占用内存以及对应的值类�c�d��?/p>
�?�Q�基本类型与CLI值类�?/p>

基本�c�d��

字节

CLI值类�c�d��

bool
char
singed char
unsigned char
short
unsigned short
int
unsigned int
long
unsigned long
long long
unsigned long long
float
double
long double
wchar_t

1
1
1
1
2
2
4
4
4
4
8
8
4
8
8
2

System::Boolean
System::SByte
System::SByte
System::Byte
System::Int16
System::UInt16
System::Int32
System::UInt32
System::Int32
System::UInt32
System::Int64
System::UInt64
System::Single
System::Double
System::Double
System::Char

默认情况下，char�c�d��被视为singed char�Q�因此其兌��的值类�c�d��为System::SByte。如果编译选项/J�Q�则char 默认为unsigned char�Q�此时关联�ؓSystem::Byte。System为根命名�I�间名，C++/CLI的值类�c�d��在这个空间中定义。此外System�I�间中还定义了许多其他类型，如表�C�字�W�串的String�c�d��、精��存储的十进制小数类型Decimal�{�等�?

在C++/CLI中，兌��的值类�c�d��为基本类型添加了重要的附加功能。编译器在需要时�Q�将安排原��g��兌��c�d��之间的自动�{换，其中从原��D�{换�ؓ兌��c�d��成�ؓ装箱(boxing)�Q�反之称为拆��?unboxing)。根据上下文环境�Q�这些变量将表现为简单的值或者对象�?

�׃��ISO/ANSI C++基本�c�d��的名�U�是C++/CLI�E�序中值类�c�d��名称的别名，所以原则上C++/CLI代码中可用�Q何一�U�名�U��?/p>
int count = 10; double value = 2.5;

与下面的代码是等��L��
System::Int32 count = 10; System::Double value = 2.5;

上面2�U�代码是完全合法的，但应��量使用基本�c�d��名称�Q�如int和double�Q�而不是System::Int32和System::Double。这是因��Z��面描�q�的�q�种映射关系仅适用于Visual C++ 2005及以上版本的�~�译器，其他版本�~�译器未必实现这�U�映��关�p�R�?/p>
��基本类型�{换�ؓ值类�c�d��是C++/CLI的一个重要特征。在ISO/ANSI C++中基本类型与�cȝ��型完全不同，而在C++/CLI中，所有数据都以类�c�d��的�Ş式存储，包括值类型（存储在堆栈上�Q�和引用�c�d��Q�存储在堆上�Q?�U��?/p>
例子�Q�Fruit CLR控制台项�?/u>

在Visual Studio 2005中创建CLR Console Application��目�Q�输入名�U�Ex2_12�Q�将生成如下文�g
// Ex2_12.cpp : main project file. #include "stdafx.h" using namespace System; int main(array ^args) { Console::WriteLine(L"Hello World"); return 0; }

main函数后的参数为命令行参数。然后按如下方式改写代码

- - - - - - - - - - - - - - - - <<== 华丽的分割线 ::开�?=>> [Ex_12.cpp] - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Ex2_12.cpp : main project file. #include "stdafx.h" using namespace System; int main(array ^args) { int apples, oranges; int fruit; apples = 5; oranges = 6; fruit = apples + oranges; Console::WriteLine(L"\nOranges are not the only fruit ..."); Console::Write(L"- and we have "); Console::Write(fruit); Console::Write(L" fruit in all.\n"); return 0; }

- - - - - - - - - - - - - - - - <<== 华丽的分割线 ::�l�束==>> [Ex_12.cpp] - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

�~�译后执行得到如下输出：
Oranges are not the only fruit?- - and we have 11 fuit in all.

与ISO/ANSI C++版本比较�Q�变量的�c�d��int��成为C++/CLI�c�d��System::Int32。如果用System::Int32替换代码中的int�Q�然后重新编译运行，�l�果��没有变化�?/p>
WriteLine()函数为C++/CLI函数�Q�定义在System命名�I�间的Console�c�M��。Console表示标准输入输出��。Write()函数��cȝ��另一个输出函敎ͼ�不会自动换行。下面专门讨论C++/CLI的控制台输入输出�?

二、控制台输出

C++/CLI中特有控制台格式化输出功能，例如可用下面的代码来输出字符串与变量混合文本�?/p>
Console::WriteLine(L"There are {0} fruit.", fruit);

Console::WriteLine()的第一个参数是L”There are {0} fruit.”，其中{0}为格式化占位�W�，表示在此处插入第二个参数的��|��如果有更多需要插入的参数�Q�则该参数对应的占位�W�编��L��l�增加：{1}、{2}、{3}…。在�W�一个字�W�串参数中，�~�号的顺序可以颠倒，�?
Console::WriteLine(L"There are {1} packages weighting {0} pounds", packageWeight, packageCount);

格式化占位符�q�可以控制显�C�的格式�Q�如{1:F2}表示�W?个参数显�C�成�?位小数的��点敎ͼ�冒号后的为格式规�?/p>
Console::WriteLine(L"There are {0} packages weighting {1:F2} pounds ", packageCount, packageWeight);

输出�?/p>
There are 25 packages weighting 7.50 pounds.

一般说来，可以�~�写格式为{n,w:Axx}的格式规范，其中n为烦引��|��用于选择逗号后的�W�几个参敎ͼ� A为单个字母，表示如何对变量格式化�Q�xx�?个或2个数字，指定参数的精度；w为有�W�号整数�Q�表�C�可选的字段宽度范围�Q�如果w�?�Q�则字段叛_��齐，如果w�?�Q�则左对齐。如果数值的位置数小于w指定的位�|�数�Q�则多出来的用空格填充，如果数值的位置数大于w指定的位�|�数�Q�则忽略w的限定：
Console::WriteLine(L"Packages: {0,3} Weight: {1,5�nºF2} pounds ", packageCount, packageWeight);

输出为（下划�U�表�C�空格填充位�Q�：

Packages: _25 Weight: __7.50 pounds

可选的格式说明�W�如�?所�C?/p>
�?�Q�格式说明符

格式说明�W?/strong>

说明

C或c

把��g��币量输出

D或d

把整��C��为十�q�制��D��出。如果指定的�_�ֺ�大于位数�Q�则在数值的坐标填充0

E或e

按照�U�学技术法输出��点�?/p>

F或f

把��Q�Ҏ��作�ؓ�u####.##的定�Ҏ��输出

G或g

以最紧凑的�Ş式输出，取决于是否指定了�_�ֺ��|��如果没有则适用默认�_�ֺ�

N或n

把��g��为定点十�q�制��D��出，必要时以3位一�l�用逗号分隔

X或x
把整��C��为十六进制��D��出。根据X或x�Q�以大写或小写输出�?/td>

例子�Q�计��地毯�h��|��演示CLR控制台程序的格式化输�?/em>

- - - - - - - - - - - - - - - - <<== 华丽的分割线 ::开�?=>> [Ex_13.cpp] - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Ex2_13.cpp : main project file. #include "stdafx.h" using namespace System; int main(array ^args) { double carpetPriceSqYd = 27.95; double roomWidth = 13.5; // in feet double roomLength = 24.75; // in feet const int feetPerYard = 3; double roomWidthYard = roomWidth/feetPerYard; double roomLengthYard = roomLength/feetPerYard; double carpetPrice = roomWidthYard*roomLengthYard*carpetPriceSqYd; Console::WriteLine(L"Room is {0:F2} yards by {1:F2} yards", roomWidthYard, roomLengthYard); Console::WriteLine(L"Room area is {0:F2} square yards", roomWidthYard*roomLengthYard); Console::WriteLine(L"Carpet price is ${0:F2}", carpetPrice); return 0; }

- - - - - - - - - - - - - - - - <<== 华丽的分割线 ::�l�束==>> [Ex_13.cpp] - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

三、控制台输入

.Net Framework的控制台键盘输入功能有限�Q�可以适用Console::ReadLine()函数把整行输入作为字�W�串��d��Q�或者��用Console::Read()��d��单个字符�Q�还可以适用Console::ReadKey()��d��按键。ReadLine()的例子如下：

ReadLine()用于��整行文本存入字�W�串中，按下Enter键时�Q�文本结束。变量line为String^型，表示String数据�c�d��的引用，line为Console::ReadLine()函数��d��字符串的引用�?/p>
String^ line = Console::ReadLine();

Read()用于逐字�W�的��d��输入数据�Q��ƈ��其转换成对应的数字倹{��ReadKey的例子如下：
char ch = Console::Read();

ReadKey()用于��d��按键��|��q�返回ConsoleKeyInfo对象�Q�该为对象定义在System命名�I�间中的值类型。参数true表示按键不在命��o行上昄��出来�Q�false则表�C�显�C�按键回显。按键对应的字符可用ConsoleKeyInfo对象的KeyChar得到�?/p>
ConsoleKeyInfo keyPressed = Console::ReadKey(true); Console::WriteLine(L"The key press corresponds to the character: {0}", keyPress.KeyChar);

��管C++/CLI控制台程序中不能格式化输入，但输入一般都通过�H�口�l��g得到�Q�因此这仅仅是一个小�~�陷�?/p>

四、强制类型�{换safe_cast

在CLR环境中safe_cast用于昄��的强制类型�{换。safe_cast用于��一�U�类型�{换�ؓ另一�U�类型，在不成功时能够抛出异常，因此在C++/CLI中��用safe_cast是比较好的选择。其用法和static_cast一��P��
double value1 = 10.5; double value2 = 15.5; int whole_number = safe_cast<int>(value1) + safe_cast<int>(value2);

五、枚�?/h1>
C++/CLI的枚举与ISO/ANSI C++有较大的区别。下例�ؓC++/CLI中的一个枚丄��型：该语句定义了一个枚丄��型Suit�Q�该�c�d��的变量只能被赋值枚丑֮�义中的��|��且必��ȝ��枚�D�c�d��名称限定枚�D常数�?/p>
enum class Suit {Clubs, Diamonds, Hearts, Spades}; Suit suit = Suit::Diamonds;

注意class关键字跟在enum之后。说明该枚�D�c�d��为C++/CLI�Q�该关键字还表明在定义中规定的常�? Clubs\Diamonds\Hearts\Spades都是�c�d��象而非ISO/ANSI C++中的基本�c�d��Q�整型）倹{��实际上�Q�默认情况下�q�些都是Int32�c�d��的对象�?/p>
�׃��C++/CLI枚�D定义中的变量都是�c�d��象，因此不能在函数内部定义�?/p>
(一�Q�指定枚丑ָ�量的�c�d��

枚�D中常量的�c�d��可以是下表中��M��基本�c�d��Q?/p>

short

int

long

long long

signed char

char

unsigned short

unsigned int

unsigned long

unsigned long long

unsigned char

bool

要指定一个枚丑ָ�量的�c�d��Q�可以在枚�D�c�d��名称之后写入帔R��c�d��名称�Q�要用冒号隔开�Q�，下例枚�D�c�d��中的帔R��为Char�c�d��Q�对应的基本�c�d��为char。其中第一个常量默认情况下对应于代码�?�Q�后面的依次递增�?/p>
enum class Face:char { Ace,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten,Jack,Queen,King};

(�?指定枚�D帔R��的�?/h2>
可以赋予枚�D�c�d��定义中的一个或全部常数对应的��|��下例使得Ace获得1�Q�Two获得2�Q�其余依此类推，直到King=13�?
enum class Face:char { Ace=1,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten,Jack,Queen,King};

如果惌��Ace获得最大��|��则可以如下定义：
enum class Face:Char { Ace=14,Two=2,Three,Four,Five,Six,Seven,Eight,Nine,Ten,Jack,Queen,King};

例子�Q��用枚丄��?/u>

- - - - - - - - - - - - - - - - <<== 华丽的分割线 ::开�?=>> [Ex_14.cpp] - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Ex2_14.cpp : main project file. #include "stdafx.h" using namespace System; enum class Suit {Clubs, Diamonds, Hearts, Spades}; int main(array ^args) { Suit suit = Suit::Clubs; int value = safe_cast<int>(suit); Console::WriteLine(L"Suit is {0} and the value is {1}", suit, value); suit = Suit::Diamonds; value = safe_cast<int>(suit); Console::WriteLine(L"Suit is {0} and the value is {1}", suit, value); suit = Suit::Hearts; value = safe_cast<int>(suit); Console::WriteLine(L"Suit is {0} and the value is {1}", suit, value); suit = Suit::Spades; value = safe_cast<int>(suit); Console::WriteLine(L"Suit is {0} and the value is {1}", suit, value); return 0; }

- - - - - - - - - - - - - - - - <<== 华丽的分割线 ::�l�束==>> [Ex_14.cpp] - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

该例子的输出�?/p>
Suit is Clubs and the value is 0 Suit is Diamonds and the value is 1 Suit is Hearts and the value is 2 Suit is Spades and the value is 3

例子说明

Suit为枚丄��型，不能在函数main()内部定义�Q�因此只能定义�ؓ全局作用域内�?
必须用类型名�U�Suit限定枚�D帔R��Q�如Suit::Clubs�Q�否则编译器��无法识别�?
变量suit的��gؓ�c�d��象，要获取其值必��L��C�的��其转换成int�c�d��?

英勇的近卫军 2009-06-27 16:27 发表评论

�c�d��	字节	值域
long long	8	�?9223372036854775808�?223372036854775807
Unsigned long long	8	�?�?8446744073709551615

基本�c�d��	字节	CLI值类�c�d��
bool char singed char unsigned char short unsigned short int unsigned int long unsigned long long long unsigned long long float double long double wchar_t	1 1 1 1 2 2 4 4 4 4 8 8 4 8 8 2	System::Boolean System::SByte System::SByte System::Byte System::Int16 System::UInt16 System::Int32 System::UInt32 System::Int32 System::UInt32 System::Int64 System::UInt64 System::Single System::Double System::Double System::Char

格式说明�W?/strong>	说明
C或c	把��g��币量输出
D或d	把整��C��为十�q�制��D��出。如果指定的�_�ֺ�大于位数�Q�则在数值的坐标填充0
E或e	按照�U�学技术法输出��点�?/p>
F或f	把��Q�Ҏ��作�ؓ�u####.##的定�Ҏ��输出
G或g	以最紧凑的�Ş式输出，取决于是否指定了�_�ֺ��\|��如果没有则适用默认�_�ֺ�
N或n	把��g��为定点十�q�制��D��出，必要时以3位一�l�用逗号分隔
X或x	把整��C��为十六进制��D��出。根据X或x�Q�以大写或小写输出�?/td>

short	int	long	long long	signed char	char
unsigned short	unsigned int	unsigned long	unsigned long long	unsigned char	bool

香蕉久久永久视频,亚洲AV无码久久寂寞少妇,久久精品国产99国产精品澳门

C++/CLI学习入门(�?:跟踪句柄、跟�t�引用及内部指针

一、连接字�W�串

二、修改字�W�串

三、搜索字�W�串

C++/CLI学习入门(�?:数组

二、数�l?/h1>

(一)数组句柄

(�?数组排序

(�?数组搜烦

(�?多维数组

一、基本控制结�?/h1> ISO/ANSI C++中的控制与��@环全部适用于C++/CLI。下例展�C�Z��C++/CLI控制台程序中的控制��@环：

例子�Q�基本��@环控�?/u>

例子�Q���用Console::ReadKey()函数

二、for each循环

C++/CLI学习入门(一)�Q�基���

例子�Q�Fruit CLR控制台项�?/u>

二、控制台输出

例子�Q�计���地毯�h��|��演示CLR控制台程序的格式化输�?/em>

三、控制台输入

四、强制类型�{换safe_cast

(一�Q�指定枚丑ָ�量的�c�d��

例子�Q���用枚丄����?/u>

一、基本控制结�?/h1>
ISO/ANSI C++中的控制与��@环全部适用于C++/CLI。下例展�C�Z��C++/CLI控制台程序中的控制��@环：

例子�Q��用Console::ReadKey()函数

C++/CLI学习入门(一)�Q�基��

例子�Q�计��地毯�h��|��演示CLR控制台程序的格式化输�?/em>

例子�Q��用枚丄��?/u>