伊人久久免费视频,久久久久国产一区二区,亚洲色欲久久久综合网

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

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

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

跟踪句柄saying用于讉K��String�c�d��象。该对象的字�W��ؓ宽字�W�，因�ؓ采用了前�~� “L”�Q�如果省�?#8220;L”�Q�该字符串由8位的字符�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�串

利用 “+”可以�q�接字符�Ԍ��形成新的字符丌Ӏ�执行下面的例子之后�Q�name3��包含字�W�串 “Beth and Betty”�?/p>

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

“+”�q�可以用来连接字�W�串与数倹{��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�可以用来连接字�W�串与字�W�，但要注意�Q?strong>�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>

例子�Q�处理字�W�串

��整数数�l�内的元素按列整齐地输出�?/p>
// 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(); } }

输出�?/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“�Q�则字符为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>
例子�Q�搜索字�W�串中的标点�W�号

// 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; } 输出�?/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�后�?#8221;^”�W�号�Q�用于声明一个该�c�d��的句柄�?/p>
声明了一个String�c�d��的跟�t�句柄proverb�?

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

proverb = nullptr;

       注意不能�?来表�C�空倹{��如果用0来初始化某个句柄�Q�则0��自动�{换�ؓ被引用类型的对象�Q�而句柄则指向该对象�?

可以在声明句柄时昄��的将其初始化�Q?/p>
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��Ҏ(gu��)��使得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属性是数组的一个重要属性，记录着数组元素的数量�?/p>
for(int i=0; iLength; i++) data[i] = 2*(i+1);

   属性LongLength则保存了64位的数组长度�?

      可以用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()�Ҏ(gu��)��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�则�Ҏ(gu��)��个数�l�排序。如果要�Ҏ(gu��)��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>
/////////////////////////////////////////////////////////////////////////// // 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; } /////////////////////////////////////////////////////////////////////////////

输出为：

Al Bill Eve Jill Mary Ted

176 180 115 103 128 168

例子说明

Sort()函数�?个数�l�排序时�Q�用�W�一个数�l�参数来��定两个数组的顺序，以此保持2个数�l�元素对应关�p�M��变�?

(�?数组搜烦

Array�c�还提供了函数BinarySearch()以��用对分法搜烦��法�Q�对一�l�数�l�或�l�定范围内搜索特定元素的索引位置。��用该函数要求数组必须是顺序排列的�Q�因此在搜烦之前必须�Ҏ(gu��)��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个是要搜索的内容�?/p>
array<int>^ value = { 23, 45, 68, 94, 123, 150, 203, 299 }; int toBeFound = 127; int position = Array::BinarySearch(value, 3, 6, toBeFound);

上面的代码从�W?个元素开始，一直搜索到�l�束位置�?/pre>
例子�Q�搜索数�l?/em>

/////////////////////////////////////////////////////////////////////////////////////// // 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; } ///////////////////////////////////////////////////////////////////////////////////////

例子说明

        当搜索不到目标时�Q�Array::BinarySearch()函数输出的�ƈ非�Q意负敎ͼ�而是�W�一个大于该目标的元素烦引值的按位补码。利用该�Ҏ(gu��)��Q�可以不打�ؕ��序在数�l�中插入新倹{��如�Q�我们希望插�?#8221;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;

最后一句用于删除names数组�?/p>

(�?多维数组

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

上面的代码创��Z��一个二�l�数�l�，四行五列�Q�共20个元素。访问的�Ҏ(gu��)��是利用多个用逗号分隔的烦引值来讉K��每一个元素，而不能用一个烦引��D��问一�?/p>
int nrows = 4; int ncols = 5; array<int, 2>^ value = gcnew array<int, 2>(nrows, ncols); for(int i=0; ifor(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�，�Ҏ(gu��)��见下�?/p>
例子�Q��用多�l�数�l?/p>
/////////////////////////////////////////////////////////////////////////// // 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; } /////////////////////////////////////////////////////////////////////////////////////////////

例子说明

上面的例子创��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�即所谓的“锯��形数�l?#8221;。例如，用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"}, };

元素的初值必��d��在花括号里�?/p>
例子�Q��用数�l�的数组

//////////////////////////////////////////////////////////////////////// // 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; } ///////////////////////////////////////////////////////////////////////////

例子说明

输出�?/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

一、基本控制结�?/font>

ISO/ANSI C++中的控制与��@环全部适用于C++/CLI。下例展�C�Z��C++/CLI控制台程序中的控制��@环：

// 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;

}

       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.");

例子�Q�下面看一个新的例子，试一试��用Console::ReadKey()函数�Q��ƈ初步了解ConsoleKeyInfo�c�R�?/em>

// 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(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;

}

该程序的输入�C�Z��如下�Q?/em>

Press a key combination – press Escape to quit.

You pressed Shift A which is the A character.

You pressed Control �Q?which is the character.

You pressed Alt A which is the a character.

You pressed Escape which is the ← character.

��h��L��键��l? . .

例子说明

        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�?/em>

        应该注意的是�Q�在C++/CLI中枚丑ָ�量在用作数��g��前必��被昄��的强制�{换�ؓ值类型（整数�c�d��Q��?/em>

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

二、for each循环

例子�Q�从例子开始：

// 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;

}

输出如下�Q?/em>

A nod is as good as a wink to a blind horse.

The proverb contains 14 volwels and 18 consanants.

例子说明

        该程序计��字�W�串中的元音与辅韛_��母的个数。下面的语句定义了要分析的字�W�串�Q?/em>

String^ proverb = L”A nod is as good as a wink to a blinds horse”;

        proverb变量为String句柄的String^�c�d��Q�句柄被用来存储CLR��理的无用单元堆上的某个对象的位�|�。重复处理proverb所引用字符串中各个字符的for each循环形式如下�Q?/em>

for each(wchar_t ch in proverb)

{

    // Process the current character stored in ch …

}

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

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

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

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

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

      相比于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?

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

一、基本数据类�?/font>

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

�?

�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��?/font>

�?

基本�c�d��

字节

CLI值类�c�d��

bool

1

System::Boolean

char

1

System::SByte

singed char

1

System::SByte

unsigned char

1

System::Byte

short

2

System:Int16

unsigned short

2

System::UInt16

int

4

System::Int32

unsigned int

4

System::UInt32

long

4

System::Int32

unsigned long

4

System::UInt32

long long

8

System::Int64

unsigned long long

8

System::UInt64

float

4

System::Single

double

8

System::Double

long double

8

System::Double

wchar_t

2

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��?

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�?

      ��基本类型�{换�ؓ值类�c�d��是C++/CLI的一个重要特征。在ISO/ANSI C++中基本类型与�cȝ��型完全不同，而在C++/CLI中，所有数据都以类�c�d��的�Ş式存储，包括值类型（存储在堆栈上�Q�和引用�c�d��Q�存储在堆上�Q?�U��?

例子�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函数后的参数为命令行参数。然后按如下方式改写代码

// 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;

}

       新加行用�_�体字显�C�，�~�译后执行得到如下输出：

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�果��没有变化�?/em>

      WriteLine()函数为C++/CLI函数�Q�定义在System命名�I�间的Console�c�M��。Console表示标准输入输出��。Write()函数��cȝ��另一个输出函敎ͼ�不会自动换行。下面专门讨论C++/CLI的控制台输入输出�?/em>

二、控制台输出

      C++/CLI中特有控制台格式化输出功能，例如可用下面的代码来输出字符串与变量混合文本�?

Console::WriteLine(L"There are {0} fruit.", fruit);

      Console::WriteLine()的第一个参数是L”There are {0} fruit.”�Q�其中{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�成�?位小数的��点敎ͼ�冒号后的为格式规�?

Console::WriteLine(L"There are {0} packages weighting {1�Q�F2} pounds ", packageCount, packageWeight);

     输出�?

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�Q�F2} pounds ", packageCount, packageWeight);

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

Packages: _25 Weight: __7.50 pounds

      可选的格式说明�W�如�?所�C?/font>

�?

格式说明�W?/strong>

�?/strong> �?/strong>

C或c

把��g��币量输出

D或d

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

E或e

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

F或f

把��Q�Ҏ(gu��)��作�ؓ±####.##的定�Ҏ(gu��)��输出

G或g

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

N或n

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

X或x

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

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

// 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;

}

例子说明�Q?/em>�Q�略�Q?/em>

三、控制台输入

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

String^ line = Console::ReadLine();

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

char ch = Console::Read();

      用于逐字�W�的��d��输入数据�Q��ƈ��其转换成对应的数字倹{��ReadKey的例子如下：

ConsoleKeyInfo keyPressed = Console::ReadKey(true);

      用于��d��按键��|��q�返回ConsoleKeyInfo对象�Q�该为对象定义在System命名�I�间中的值类型。参数true表示按键不在命��o行上昄��出来�Q�false则表�C�显�C�按键回显。按键对应的字符可用ConsoleKeyInfo对象的KeyChar得到�?

Console::WriteLine(L”The key press corresponds to the character: {0}”, keyPress.KeyChar);

      按键对应的键值由ConsoleKeyInfo对象的Key得到�?

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

四、强制类型�{换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(value1) + safe_cast(value2);

五、枚�?/font>

      C++/CLI的枚举与ISO/ANSI C++有较大的区别。下例�ؓC++/CLI中的一个枚丄��型：

enum class Suit {Clubs, Diamonds, Hearts, Spades};

     该语句定义了一个枚丄��型Suit�Q�该�c�d��的变量只能被赋值枚丑֮�义中的��|��且必��ȝ��枚�D�c�d��名称限定枚�D常数�?

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��的对象�?

      �׃��C++/CLI枚�D定义中的变量都是�c�d��象，因此不能在函数内部定义�?/font>

例子

// 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(suit);

    Console::WriteLine(L"Suit is {0} and the value is {1}", suit, value);

    suit = Suit::Diamonds;

    value = safe_cast(suit);

    Console::WriteLine(L"Suit is {0} and the value is {1}", suit, value);

    suit = Suit::Hearts;

    value = safe_cast(suit);

    Console::WriteLine(L"Suit is {0} and the value is {1}", suit, value);

    suit = Suit::Spades;

    value = safe_cast(suit);

    Console::WriteLine(L"Suit is {0} and the value is {1}", suit, value);

    return 0;

}

该例子的输出�?/em>

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

例子说明

1�Q?Suit为枚丄��型，不能在函数main()内部定义�Q�因此只能定义�ؓ全局作用域内�?/em>

2�Q?必须用类型名�U�Suit限定枚�D帔R��Q�如Suit::Clubs�Q�否则编译器��无法识别�?/em>

3�Q?变量suit的��gؓ�c�d��象，要获取其值必��L��C�的��其转换成int�c�d��?/em>

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

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

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�，如下例所�C�：

enum class Face:char { Ace,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten,Jack,Queen,King};

      此枚丄��型中的常量�ؓChar�c�d��Q�对应的基本�c�d��为char。其中第一个常量默认情况下对应于代码�?�Q�后面的依次递增�?

(�?指定枚�D帔R��的�?/font>

      可以赋予枚�D�c�d��定义中的一个或全部常数对应的��|��?

enum class Face:char { Ace=1,Two,Three,Four,Five,Six,Seven,Eight,Nine,Ten,Jack,Queen,King};

�q��得Ace获得1�Q�Two获得2�Q�其余依此类推，直到King=13。如果想让Ace获得最大��|��则可以如下定义：

enum class Face:Char { Ace=14,Two=2,Three,Four,Five,Six,Seven,Eight,Nine,Ten,Jack,Queen,King};

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

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

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

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

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

伊人久久免费视频,久久久久国产一区二区,亚洲色欲久久久综合网

一、连接字�W�串

二、修改字�W�串

三、搜索字�W�串

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

二、数�l?/h1>

(一)数组句柄

(�?数组排序

(�?数组搜烦

(�?多维数组

一、基本控制结�?/font>

二、for each循环

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

二、控制台输出

三、控制台输入

四、强制类型�{换safe_cast

五、枚�?/font>

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