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

跟踪句柄saying用于访问String类对象。该对象的字符为宽字符，因为采用了前缀 “L”，如果省略“L”，该字符串由8位的字符组成，编译器将确保将其转换成宽字符。

访问字符串内字符可以像访问数组元素一样，使用索引来访问，首字符的索引为0。这种方法只能用于读取字符串内字符，但不能用于修改字符串的内容。

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

利用Length属性，可以获取字符串内字符的数量（长度）。

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

一、连接字符串

利用 “+”可以连接字符串，形成新的字符串。执行下面的例子之后，name3将包含字符串 “Beth and Betty”。

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

“+”还可以用来连接字符串与数值、bool值等非字符串变量，在连接之前，这些变量将自动的转换成字符串。

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"

“+”还可以用来连接字符串与字符，但要注意，结果字符串的形式取决于字符的类型。这是因为char类型的字符被视为数值，wchar_t与String对象的字符具有相同的类型（Char类型）。

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

String类型定义了Join()函数，用于将数组中的多个字符串连接成一个字符串，数组元素之间用分隔符隔开，如

array<String^>^ 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"

特别注意：String对象是固定不变的，一旦创建完毕后就不能再被修改了。这意味着所有的字符串操作都是在创建新的字符串。

例子：处理字符串

将整数数组内的元素按列整齐地输出。

// Ex4_17.cpp : main project file.
#include "stdafx.h"
using namespace System;
int main(array<System::String ^> ^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(maxLength<number->Length)
maxLength = number->Length;
}
String^ format = formatStr1+(maxLength+1)+formatStr2;
int numberPerLine = 3;
for(int i=0; i<values->Length; i++)
{
Console::Write(format, values[i]);
if((i+1)%numberPerLine == 0)
Console::WriteLine();
}
}

输出为

       2     456      23
-46   34211     456
5609  112098     234
-76504     341    6788
-909121      99      10

二、修改字符串

Trim()函数用于删除字符串头部和尾部的空格。不带参数调用该函数将删除字符串头、尾部的全部空格并返回一新字符串。

String^ str = {" Handsome is as handsome does...     "};
String^ newStr = str->Trim();

也可传递给Trim()函数字符数组作为参数，字符串将从头部和尾部开始删除数组中的字符。如果字符出现在字符串中间，则不会被删除。

String^ toBeTrimed = L"wool wool sheep sheep wool wool wool";
array<wchar_t>^ notWanted = {L'w', L'o', L'l', L' ' };
Console::WriteLine(toBeTrimed->Trim(notWanted));

上面的语句将输出
sheep sheep

如果在上面的语句中没有加前缀”L“，则字符为char类型，对应于System::SByte类型。不过编译器将自动地将其转换成wchar_t类型（即System::Char类型）。

Trim()函数也支持直接输入要删除的字符列表，下面的语句将产生同样的输出

Console::WriteLine(toBeTrimed->Trim(L'w', L'o', L'l', L' '));

如果仅仅想要删除头部或者尾部中的一端，可以使用TrimStart或者TrimEnd函数。

如果要在字符串的一端填充空格或其它字符（这一般用于以固定宽度靠左或靠右对齐输出文本），可使用PadLeft()和PadRight()函数。如果字符串长度大于指定的长度参数，则返回字符串为长度等于原来字符串的新字符串。

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函数。

String^ proverb = L"Many hands make light work."
String^ upper = proverb->ToUpper();	// Result is "MANY HANDS MAKE LIGHT WORK."

如果需要在字符串中间插入一个字符串，可使用Insert()函数，第一个参数指定起始位置的索引，第二个参数指定要插入的字符串。

String^ proverb = L"Many hands light work.";
String^ newProverb = proverb->Insert(5, "deck ");

结果是

Many deck hands make light work.

如果要用另一个字符替换字符串中指定的字符，或者用另一个子串替换字符串中给定的子串，可使用Replace()函数。

String^ proverb = L"Many hands make light work."
Console::WriteLine(proverb->Replace(L' ', L'*');
Console::WriteLine(proverb->Replace(L"Many hands", L"Press switch");

输出为

Many*hands*make*light*work.
Pressing switch make light work.

三、搜索字符串

如果需要测试字符串是否以给定的子串开始或结束，可使用StartWith()或EndWith()函数。要寻找的子串句柄作为参数传递给函数，返回bool值。

String^ snetence = L"Hide, the cow's outside.";
if(sentence->StartWith(L"Hide"))
Console::WriteLine("The sentence starts with 'Hide'.");

IndexOf()函数用于返回给定字符或子串在字符串中找到的第一个实例索引，如果未找到，则返回-1。

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搜索的起始索引，这一般用于遍历整个字符串找出所有的实例，如下面的例子：

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()函数类似于IndexOf()函数，不过它用于从字符串尾部或指定索引位置开始，倒着向头部搜索。注意：如果从尾部开始的索引值是words->Lenght-1。

如果要搜索一个字符串数组中任意元素出现在字符串中的位置，可以使用IndexOfAny()函数。同样，它也有倒序搜索的版本。 下面的例子说明了IndexOfAny()的用法。

例子：搜索字符串中的标点符号

// Ex4_18.cpp : main project file.
#include "stdafx.h"
using namespace System;
int main(array<System::String ^> ^args)
{
array<wchar_t>^ punctuation = {L'"', L'\'', L'.', L',', L':',L'!', L'?'};
String^ sentence = L"\"It's chilly in here\", the boy 's mother said coldly.";
array<wchar_t>^ indicators = gcnew array<wchar_t>(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;
}
输出为

There are 6 punctuation charactors in the string:
"It's chilly in here", the boy 's mother said coldly.
^  ^                ^^         ^                    ^

一、跟踪句柄

       跟踪句柄类似于本地C++指针，但也有很大区别。跟踪句柄确实存储着某个对象的地址，但当CLR压缩堆过程中改变了该对象的地址，则垃圾回收器自动更新句柄所包含的地址。我们不能像本地指针那样用跟踪句柄来执行地址的算术运算，也不允许对跟踪句柄进行强制类型转换。

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

       通过在类型名称后加”^”符号，用于声明一个该类型的句柄。

声明了一个String类型的跟踪句柄proverb。

      在声明时句柄时，系统自动为其分配一个空值，该句柄不引用任何对象。也可显示地将某个句柄置为空值:

proverb = nullptr;

       注意不能用0来表示空值。如果用0来初始化某个句柄，则0将自动转换为被引用类型的对象，而句柄则指向该对象。

可以在声明句柄时显示的将其初始化：

String^ saying = L"I used to think I was indecisive but now I??¡ê¡èm not so sure.;"

      该语句首先在堆上创建一个包含等号右边字符串的String对象，然后将该对象的地址存入saying中。注意字符串字面值的类型为const wchar_t*而非String。类String提供了这样的方法使得const wchar_t*类型的字符串可以用来创建String类型的对象。

      下面这条语句创建了值类型的句柄：

int^ value = 99;

      该语句在堆上创建一个Int32型的值类型变量，然后将该变量的地址存入句柄value中。由于value是一种指针，因此不能直接参与算术运算，可使用*运算符对地址求值（类似于本地C++指针那样）:

int result = 2*(*value)+15;

      由于*value表示value所指向地址存储的数值，因此result的值为2*99+15=213。注意，当value作为运算式左值时，不需要*即可对value指向的变量赋值。

int^ result = 0;
result = 2*(*value)+15;

      首先创建了一个指向数值0的句柄result。（该语句会触发一条编译器警告，提示不能利用0来将句柄初始化为空值。）

      第2条语句=号右边为数值，而左边为句柄，编译器将自动将右值赋予句柄所指向的对象，即将其转换为如下语句

*result = 2*(*value)+15;

       注意，要采用上面的语句，result句柄必须实际定义过。如果仅仅声明了result，则会产生运行时错误

int^ result;
*result = 2*(*value)+15;

       这是因为第二句要对地址result求值，即意味着result指向的对象已经存在，但实际并非如此，因为声明该对象时系统默认赋予其空值(nullptr)。在这种情况下，采用下面的方法就可以正常工作了

int^ result;
result = 2*(*value)+15; 

二、数组

(一)数组句柄

       CLR数组是分配在可回收垃圾堆上的。必须用array<typename>指出要创建的数组，同其它CLR堆上的对象一样，需要用句柄来访问它，例子如下：

array<int>^ data;

      数组句柄data可用于存储对元素类型为int的一维数组的引用。下面的例子声明了一个句柄，并新建一个CLR数组来对此句柄初始化。

array<int>^ data = gcnew array<int>(100);

       和本地C++数组一样，CLR数组中元素的索引值也是从0开始的，可以通过[ ]访问数组元素。数组元素都是CLR对象，在上面的例子中数组元素为Int32型对象，它们在算术表达式中就像普通的整数类型一样。

       Length属性是数组的一个重要属性，记录着数组元素的数量。

for(int i=0; i<data->Length; i++)
data[i] = 2*(i+1);

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

      可以用for each循环遍历数组元素。

array<int>^ value = {3, 5, 6, 8, 6};
for each(int item in value)
{
item = 2*item + 1;
Console::WriteLine("{0, 5}", item);
}

    该循环输出5字符宽度的字段，以右对齐的方式输出当前元素的计算结果，输出如下：

____7___11___13___17___13

       数组句柄可以被重新赋值，只要保持数组元素类型和维数（等级）不变即可，在前面例子中的数组句柄data指向一个int类型的一维数组，可以重新给它赋值，使其指向另外的int类型1维数组：

data = gcnew array<int>(45);

       数组可以在创建时通过元素列表初始化，下例在CLR堆上创建了一个double类型的数组，并将引用赋值给了数组句柄：

array<double>^ sample = {3.4, 2.3, 6.8, 1.2, 5.5, 4.9, 7.4, 1.6};

       如果在声明数组句柄时不进行初始化，那么在给句柄赋值时不能采用上面的方法直接用元素列表用作右值，而必须采用显示创建的方式。即不能

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}

       对于字符串数组，注意每一个元素也是引用类型，这是因为每一个元素String也是在CLR堆上创建的，因此也要用String^来访问它。

array<String^>^ names = {"Jack", "John", "Joe", "Jessica", "Jim", "Joanna"};

       可以用Array类静态函数Clear()对数组中的连续数组元素清零。

Array::Clear(samples, 0, samples->Length);

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

(二)数组排序

Array类还定义了一个Sort()静态函数，可用于对数组进行排序。如果以数组句柄作为参数，则对整个数组排序。如果要对数组部分排序，则还需要增加元素起始索引及数量，如下例

////////////////////////////////////////////////////////
array<int>^ samples = {27, 3, 54, 11, 18, 2, 16};
Array::Sort(samples, 2, 3);
//////////////////////////////////////////////////////// 

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

Sort函数还有很多其它版本，下面的例子展示了如何排序两个相关的数组，即第一个数组中的元素是第二个数组对应元素的键。对第一个数组排序后，可对第二个数组进行相应的调整，使得键与值相互对应。

///////////////////////////////////////////////////////////////////////////
// Ex4_13.cpp : main project file.
#include "stdafx.h"
using namespace System;
int main(array<System::String ^> ^args)
{
array<String^>^ 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()函数对2个数组排序时，用第一个数组参数来确定两个数组的顺序，以此保持2个数组元素对应关系不变。

(三)数组搜索

Array类还提供了函数BinarySearch()以使用对分法搜索算法，对一维数组或给定范围内搜索特定元素的索引位置。使用该函数要求数组必须是顺序排列的，因此在搜索之前必须对数组进行排序。

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()的第一个参数是被搜索数组的句柄，第二个参数是要查找的内容，返回值为int类型的数值。如果返回值小于0则说明未找到。如果要指定搜索范围，则需要传递4个参数，其中第2参数为搜索起始索引，第3参数为搜索的元素数量，第4个是要搜索的内容。

array<int>^ value = { 23, 45, 68, 94, 123, 150, 203, 299 };
int toBeFound = 127;
int position = Array::BinarySearch(value, 3, 6, toBeFound);

    上面的代码从第4个元素开始，一直搜索到结束位置。

例子：搜索数组

///////////////////////////////////////////////////////////////////////////////////////
// Ex4_14.cpp : main project file.
#include "stdafx.h"
using namespace System;
int main(array<System::String ^> ^args)
{
array<String^>^ 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<String^>^ 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;
}
///////////////////////////////////////////////////////////////////////////////////////

例子说明

        当搜索不到目标时，Array::BinarySearch()函数输出的并非任意负数，而是第一个大于该目标的元素索引值的按位补码。利用该方法，可以不打乱顺序在数组中插入新值。如，我们希望插入”Fred”到names数组中

array<String^>^ 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;

此时，position保存的是大于Fred的第一个元素的位置，该数值可用于插入新值。

array<String^>^ newNames = gcnew array<String^>(names->Length+1);
for(int i=0;i<position;i++)
newNames[i] = names[i];
newNames[position] = name;
if(position<name->Length)
for(int i=position; i<names->Length; i++)
newNames[i+1] = names[i];
names = nullptr;

最后一句用于删除names数组。

(四)多维数组

C++/CLI中可以创建多维数组，最大维数32维。与ISO/ANSI C++不同的是，C++/CLI中的多维数组并非数组的数组，而是真正的多维数组，创建整数多维数组方法如下：

array<int 2>^ value = gcnew array<int, 2>(4, 5);

上面的代码创建了一个二维数组，四行五列，共20个元素。访问的方法是利用多个用逗号分隔的索引值来访问每一个元素，而不能用一个索引值访问一行

int nrows = 4;
int ncols = 5;
array<int, 2>^ value = gcnew array<int, 2>(nrows, ncols);
for(int i=0; i<nrows; i++)
for(int j=0; j<ncols; j++)
value[i, j] = (i+1)*(j+1);

上面的代码利用循环给二维数组value赋值。这里访问二维数组元素的符号与本地C++不同：后者实际上是数组的数组，而C++/CLI是真正的二维数组，不能用一个索引值来访问二维数组，那样是没有意义的。数组的维数被称为等级，上面value数组的等级为2。而本地C++数组的等级始终为1。当然，在C++/CLI中也可以定义数组的数组，方法见下例

例子：使用多维数组

///////////////////////////////////////////////////////////////////////////
// Ex4_15.cpp : main project file.
#include "stdafx.h"
using namespace System;
int main(array<System::String ^> ^args)
{
const int SIZE = 12;
array<int, 2>^ products = gcnew array<int, 2>(SIZE, SIZE);
for(int i=0; i<SIZE; i++)
for(int j=0; j<SIZE; j++)
products[i, j] = (i+1)*(j+1);
Console::WriteLine(L"Here 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<SIZE; i++)
{
Console::Write(L"{0, 3} |", i+1);
for(int j=0; j<SIZE; j++)
Console::Write("{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;
}
/////////////////////////////////////////////////////////////////////////////////////////////

例子说明

上面的例子创建了一个12x12的乘法表，输出如下：

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

第一行定义了一个整型常量SIZE，用于指定每一维数组的元素数量，第二行代码定义了一个等级2的数组，为12x12大小，该数组用于存储12x12的乘法表乘积。然后在嵌套循环中给数组赋值，大部分代码用于格式化输出以使其更加美观，这里就不再说明。

(五)数组的数组

如果数组的元素是引用数组的跟踪句柄，那么就可以创建数组的数组。同时，每一维数组的长度可以不同，即所谓的“锯齿形数组”。例如，用ABCDE来表示学生的成绩等级，根据等级分组存储班内学生的姓名，则可以创建一个包含5个元素的数组，每个元素为一个姓名数组（即字符串数组）

array<array<String ^>^>^ grades = gcnew array<array<String^>^>(5)

利用上面创建的数组，然后可以创建5个姓名数组了

grades[0] = gcnew array<String^>{"Louise", "Jack"};
grades[1] = gcnew array<String^>{"Bill", "Mary", "Ben", "Joan"};
grades[2] = gcnew array<String^>{"Jill", "Will", "Phil"};
grades[3] = gcnew array<String^>{"Ned", "Fred", "Ted", "Jed", "Ed"};
grades[4] = gcnew array<String^>{"Dan", "Ann"};

grades[n]访问grades数组的第n个元素，而各元素为指向String^类型数组的句柄，因此上面的语句用于创建了String对象句柄的数组，并将创建数组的地址赋值给了grades数组元素。同时，这些字符串数组的长度是不同的。

上面的语句也可以用一个初始化语句来实现

array<array<String^>^>^ grades = gcnew array<array<String^>^>
{
gcnew array<String^>{"Louise", "Jack"},
gcnew array<String^>{"Bill", "Maray", "Ben", "Joan"},
gcnew array<String^>{"Jill", "Will", "Phil"},
gcnew array<String^>{"Ned", "Fred", "Ted", "Jed", "Ed"},
gcnew array<String^>{"Dan", "Ann"},
};

元素的初值必须写在花括号里。

例子：使用数组的数组

////////////////////////////////////////////////////////////////////////
// Ex4_16.cpp : main project file.
#include "stdafx.h"
using namespace System;
int main(array<System::String ^> ^args)
{
array<array<String^>^>^ grades = gcnew array<array<String^>^>
{
gcnew array<String^>{"Louise", "Jack"},
gcnew array<String^>{"Bill", "Maray", "Ben", "Joan"},
gcnew array<String^>{"Jill", "Will", "Phil"},
gcnew array<String^>{"Ned", "Fred", "Ted", "Jed", "Ed"},
gcnew array<String^>{"Dan", "Ann"}
};
wchar_t gradeLetter = 'A';
for each(array<String^>^ 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;
}
///////////////////////////////////////////////////////////////////////////

例子说明

输出为

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

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

// Ex3_15.cpp : main project file. #include "stdafx.h" using namespace System; int main(array<System::String ^> ^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++/CLI中的System::Char类型，它具有一些特殊的功能，其中包括将字符代码转换为大写和小写的函数：Char::ToUpper（）和Char::ToLower()，被转换的函数作为参数被传递给它：

wchar_t uppercaseLetter = Char::ToUpper(letter);

      此外还包括检测字母是否大写或小写的函数:IsUpper()和IsLower()，因此上例可改为

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()函数，并初步了解ConsoleKeyInfo类。

// Ex3_16.cpp : main project file. #include "stdafx.h" using namespace System; int main(array<System::String ^> ^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; }

该程序的输入示例如下：

Press a key combination – press Escape to quit.

You pressed Shift A which is the A character.

You pressed Control Ａ which is the character.

You pressed Alt A which is the a character.

You pressed Escape which is the ← character.

请按任意键继续. . .

例子说明

        Console::ReadKey()函数用于测试按键，并将结果存储在ConsoleKeyInfo类对象里。该类有3个可访问属性用于帮助确定被按下的键是哪个或哪些键。属性Key识别被按下的键是哪个，属性KeyChar是被按键的Unicode字符码，属性Modifiers表示Shift,Alt,Ctrl键的按位组合，它是定义在System命名空间中的枚举类型ConsoleModifiers的常量，包括Shift\Alt\Control。

        应该注意的是，在C++/CLI中枚举常量在用作数值之前必须被显示的强制转换为值类型（整数类型）。

        从输出中可以看出，当不只一个键被按下时，用一条语句就可以得到所有的键。这是因为Modifiers枚举类型是用FlagsAttribute属性定义的，该属性表明这种枚举类型是一组唯一的位标志。这使得该枚举类型的变量可以由若干与在一起的标志位组成，而Write()或WriteLine()函数可以识别并输出各标志位。

二、for each循环

例子：从例子开始：

// Ex3_17.cpp : main project file. #include "stdafx.h" using namespace System; int main(array<System::String ^> ^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; }

输出如下：

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

The proverb contains 14 volwels and 18 consanants.

例子说明

        该程序计算字符串中的元音与辅音字母的个数。下面的语句定义了要分析的字符串：

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

        proverb变量为String句柄的String^类型，句柄被用来存储CLR管理的无用单元堆上的某个对象的位置。重复处理proverb所引用字符串中各个字符的for each循环形式如下：

for each(wchar_t ch in proverb)

{

    // Process the current character stored in ch …

}

        由于proverb字符串中的字符都是Unicode字符，因此用wchar_t（映射为Char类型）类型的变量来存储这些字符。变量ch为循环内的局部变量。

      相比于ISO/ANSI C++而言，C++/CLI进行了大量的扩充，并且提供了大量的附加功能。主要包括：

1. 在C++/CLI程序中，所有ISO/ANSI基本数据类型都可以使用，但在一些特殊的上下文环境中，它们具有一些额外属性；
2. 在控制台程序中，C++/CLI对键盘和命令行输出提供了自己的机制；
3. C++/CLI中引入了safe_cast运算符，确保强制类型转换操作能够生成可检验的代码；
4. C++/CLI提供了另外一种基于类的枚举功能，其灵活性超过了ISO/ANSI C++中的enum声明。

一、基本数据类型

     C++/CLI中包括了所有ISO/ASNI C++中的基本数据类型，算术运算也和本地C++完全一样。除此之外，C++/CLI中还定义了2种整数类型，如表1所示：

      指定long long数据类型时，需要在整数数值后面加LL或小写字母ll，如

longlong big = 123456789LL;

      指定unsinged long long类型时，需要在整数数值后面加ULL或小写字母ull，如

unsigned long long huge = 123456789LL;

      在C++/CLI中，每一个ISO/ANSI C++基本类型名称都映射到System命名空间中定义的值类类型。在C++/CLI程序中，ISO/ANSI C++基本类型名称都是CLI中对应值类类型的简略形式。表2给出了基本类型、占用内存以及对应的值类类型。

表2

基本类型	字节	CLI值类类型
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类型被视为singed char，因此其关联的值类类型为System::SByte。如果编译选项/J，则char 默认为unsigned char，此时关联为System::Byte。System为根命名空间名，C++/CLI的值类类型在这个空间中定义。此外System空间中还定义了许多其他类型，如表示字符串的String类型、精确存储的十进制小数类型Decimal等等。

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

      由于ISO/ANSI C++基本类型的名称是C++/CLI程序中值类类型名称的别名，所以原则上C++/CLI代码中可用任何一种名称。

int count = 10; double value = 2.5;

      与下面的代码是等价的

System::Int32 count = 10; System::Double value = 2.5;

     上面2种代码是完全合法的，但应尽量使用基本类型名称，如int和double，而不是System::Int32和System::Double。这是因为上面描述的这种映射关系仅适用于Visual C++ 2005及以上版本的编译器，其他版本编译器未必实现这种映射关系。

      将基本类型转换为值类类型是C++/CLI的一个重要特征。在ISO/ANSI C++中基本类型与类类型完全不同，而在C++/CLI中，所有数据都以类类型的形式存储，包括值类型（存储在堆栈上）和引用类型（存储在堆上）2种。

例子：Fruit CLR控制台项目

在Visual Studio 2005中创建CLR Console Application项目，输入名称Ex2_12，将生成如下文件

// Ex2_12.cpp : main project file. #include "stdafx.h" using namespace System; int main(array<System::String ^> ^args) {     Console::WriteLine(L"Hello World");     return 0; }

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

// Ex2_12.cpp : main project file. #include "stdafx.h" using namespace System; int main(array<System::String ^> ^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; }

       新加行用粗体字显示，编译后执行得到如下输出：

Oranges are not the only fruit…

- and we have 11 fuit in all.

例子说明

      与ISO/ANSI C++版本比较，变量的类型int将成为C++/CLI类型System::Int32。如果用System::Int32替换代码中的int，然后重新编译运行，结果将没有变化。

      WriteLine()函数为C++/CLI函数，定义在System命名空间的Console类中。Console表示标准输入输出流。Write()函数为该类的另一个输出函数，不会自动换行。下面专门讨论C++/CLI的控制台输入输出。

二、控制台输出

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

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

      Console::WriteLine()的第一个参数是L”There are {0} fruit.”，其中{0}为格式化占位符，表示在此处插入第二个参数的值，如果有更多需要插入的参数，则该参数对应的占位符编号继续增加：{1}、{2}、{3}…。在第一个字符串参数中，编号的顺序可以颠倒，如

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

      格式化占位符还可以控制显示的格式，如{1:F2}表示第2个参数显示成有2位小数的浮点数，冒号后的为格式规范

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

     输出为

There are 25 packages weighting 7.50 pounds.

      一般说来，可以编写格式为{n,w:Axx}的格式规范，其中n为索引值，用于选择逗号后的第几个参数； A为单个字母，表示如何对变量格式化；xx为1个或2个数字，指定参数的精度；w为有符号整数，表示可选的字段宽度范围，如果w为+，则字段右对齐，如果w为-，则左对齐。如果数值的位置数小于w指定的位置数，则多出来的用空格填充，如果数值的位置数大于w指定的位置数，则忽略w的限定：

Console::WriteLine(L"Packages: {0,3} Weight: {1,5：F2} pounds ", packageCount, packageWeight);

      输出为（下划线表示空格填充位）：

Packages: _25 Weight: __7.50 pounds

      可选的格式说明符如表3所示

表3

格式说明符	说 明
C或c	把值作为货币量输出
D或d	把整数作为十进制值输出。如果指定的精度大于位数，则在数值的坐标填充0
E或e	按照科学技术法输出浮点值
F或f	把浮点数作为±####.##的定点数输出
G或g	以最紧凑的形式输出，取决于是否指定了精度值，如果没有则适用默认精度
N或n	把值作为定点十进制值输出，必要时以3位一组用逗号分隔
X或x	把整数作为十六进制值输出。根据X或x，以大写或小写输出。

例子：计算地毯价格，演示CLR控制台程序的格式化输出

// Ex2_13.cpp : main project file. #include "stdafx.h" using namespace System; int main(array<System::String ^> ^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; }

例子说明：（略）

三、控制台输入

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

String^ line = Console::ReadLine();

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

char ch = Console::Read();

      用于逐字符的读入输入数据，并将其转换成对应的数字值。ReadKey的例子如下：

ConsoleKeyInfo keyPressed = Console::ReadKey(true);

      用于读取按键值，并返回ConsoleKeyInfo对象，该为对象定义在System命名空间中的值类型。参数true表示按键不在命令行上显示出来，false则表示显示按键回显。按键对应的字符可用ConsoleKeyInfo对象的KeyChar得到。

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

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

      尽管C++/CLI控制台程序中不能格式化输入，但输入一般都通过窗口组件得到，因此这仅仅是一个小缺陷。

四、强制类型转换safe_cast

      在CLR环境中safe_cast用于显示的强制类型转换。safe_cast用于将一种类型转换为另一种类型，在不成功时能够抛出异常，因此在C++/CLI中使用safe_cast是比较好的选择。其用法和static_cast一样：

double value1 = 10.5; double value2 = 15.5; int whole_number = safe_cast<int>(value1) + safe_cast<int>(value2);

五、枚举

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

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

     该语句定义了一个枚举类型Suit，该类型的变量只能被赋值枚举定义中的值，且必须用枚举类型名称限定枚举常数。

Suit suit = Suit::Diamonds;

      注意class关键字跟在enum之后。说明该枚举类型为C++/CLI，该关键字还表明在定义中规定的常量: Clubs\Diamonds\Hearts\Spades都是类对象而非ISO/ANSI C++中的基本类型（整型）值。实际上，默认情况下这些都是Int32类型的对象。

      由于C++/CLI枚举定义中的变量都是类对象，因此不能在函数内部定义。

例子

// Ex2_14.cpp : main project file. #include "stdafx.h" using namespace System; enum class Suit {Clubs, Diamonds, Hearts, Spades}; int main(array<System::String ^> ^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; }

该例子的输出为

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． Suit为枚举类型，不能在函数main()内部定义，因此只能定义为全局作用域内。

2． 必须用类型名称Suit限定枚举常量，如Suit::Clubs，否则编译器将无法识别。

3． 变量suit的值为类对象，要获取其值必须显示的将其转换成int类型。

(一）指定枚举常量的类型

      枚举中常量的类型可以是下表中任一基本类型：

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

      要指定一个枚举常量的类型，可以在枚举类型名称之后写入常量类型名称（要用冒号隔开），如下例所示：

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

      此枚举类型中的常量为Char类型，对应的基本类型为char。其中第一个常量默认情况下对应于代码值0，后面的依次递增。

(二)指定枚举常量的值

      可以赋予枚举类型定义中的一个或全部常数对应的值，如

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

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

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