C++/CLI中可以對運算符進行重載，但與本地C++有所區別。同時對于運算符重載，數值類和引用類也存在不同要求。下面以例子開始，了解C++/CLI中重載運算符的方法。

一、數值類中重載運算符

下面的例子重載了加法運算符。

value class Length
{
private:
	int feet;
	int inches;

public:
	static initonly int inchesPerFoot = 12;
	
	Length(int ft, int ins) : feet(ft), inches(ins) {}
	
	virtual String^ ToString() override
	{ return feet+L" feet "+inches+L" inches"; }

	Length operator+(Length len)
	{
		int inchTotal = inches + len.inches + inchesPerFoot*(feet + len.feet);
		return Length(inchTotal/inchesPerFoot, inchTotal%inchesPerFoot);
	}
};

類的使用很簡單，方法如下

Length len1 = Length(6, 9);
Length len2 = Length(7, 8);
Console::WriteLine(L"{0} plus {1} is {2}", len1, len2, len1+len2);

上面重載的加法運算符也可通過靜態成員的方式實現。

static Length operator+(Length len)
{
	int inchTotal = inches + len.inches + inchesPerFoot*(feet + len.feet);
	return Length(inchTotal/inchesPerFoot, inchTotal%inchesPerFoot);
}

下面定義Length與數值的乘法重載運算符，它包括了數值*長度和長度*數值兩種情況。這也是二元操作的一個例子

value class Length
{
	//...

	static Length operator*(double x, Length len);
	static Length operator*(Length len, double x);
};

   函數的定義如下

Length Length::operator*(double x, Length len)
{
	int ins = safe_cast<int>(x*len.inches + x*len.feet*inchesPerFoot);
	return Length( ins/12, ins%12 );
}

length Length::operator*(Length len, double x)
{
	return operator*(x, len);
}

下面定義遞增運算符，這是一個一元運算符，可用同一個函數來定義前綴遞增和后綴遞增運算，編譯器能夠自動的根據調用情況來判斷是先遞增還是后遞增。

static Length operator++(Length len)
{
	++len.inches;
	len.feet += len.inches/len.inchesPerFoot;
	len.inches %= len.inchesPerFoot;
	return len;
}

二、引用類中重載運算符

在引用類中重載運算符的方法與數值類基本相同，主要區別是形參和返回值一般都是句柄。這里就不再贅述了。

屬性是C++/CLI的類成員，它類似于成員變量，但實際上不是。其主要區別在于，字段名引用了某個存儲單元，而屬性名則是調用某個函數。屬性擁有訪問屬性的set()和get()函數。當我們使用屬性名時，實際上在調用該函數的get()或set()函數。如果一個屬性僅提供了get()函數，則它是只讀屬性；如果一個屬性僅提供set()函數，則它是只寫屬性。

類可以有2種不同的屬性：標量屬性和索引屬性。標量屬性是指通過屬性名來訪問的單值；索引屬性是利用屬性名加方框號來訪問的一組值。如 String類，其Length屬性為標量屬性，用object->Length來訪問其長度，且Length是個只讀屬性。String還包含了索引屬性，可以用object[idx]來訪問字符串中第idx+1個字符。

屬性可以與類的實例（類對象）相關，此時屬性被稱為實例屬性，如String類的Length屬性；如果用static修飾符指定屬性，則屬性為類屬性，所有該類得實例都具有相同的屬性值。

一、標量屬性

標量屬性是單值，用property關鍵字可定義標量屬性，還需要定義其get()和set()函數，如下例所示

value class Height
{
private:
	// Records the height in feet and inches
	int feet;
	int inches;
	literal int inchesPerFoot = 12;
	literal double inchesToMeter = 2.54/100;

public:
	// Create a height from inches value
	Height(int ins)
	{
		feet = ins/inchesPerFoot;
		inches = ins%inchesPerFoot;
	}

	// Create a height from feet and inches
	Height(int ft, int ins) : feet(ft), inches(ins) {};

	// The height in meters as a property
	property double meters
	{
		double get()
		{
			return inchesToMeters * (feet*inchesPerFoot + inches);
		}
	}

	// Create a string representation of the object
	virtual String^ ToString() overrides
	{
		return feet + L" feet " + inches + L" inches";
	}
};

上面的例子定義了一個merters的屬性，下面是屬性的用法

Height ht = Height(6, 8);
Console::WriteLine(L"The height is {0} meters", ht->meters);

屬性不一定要定義成內聯函數，也可以在.cpp中外部定義它，如在上例的定義中僅保留get()函數聲明

	property double meters
	{
		double get();
	}

函數定義在.cpp中時，需要加類名和函數名的限定（但不需要返回值？），方法如下：

Height::meters::get()
{
	return inchesToMeters*(feet*inchesPerFoot+inches);
}

如果定義一個屬性時，不提供get()和set()函數定義，這種屬性被稱為平凡標量屬性。對于此類屬性，編譯器將提供一個默認的get()和set()實現，如下例所示：

value class Point
{
public:
	property int x;
	proterty int y;

	virtual String^ ToString() overrides
	{
		return L"("+x+L","+y+")";		// Result is (x,y)
	}
};

下面是一個完整的例子，說明了標量屬性的聲明及其使用方法

// Ex7_16.cpp : main project file.

#include "stdafx.h"

using namespace System;

// Class defining a person's height
value class Height
{
private:
	// Record the height in feet and inches
	int feet;
	int inches;

	literal int inchesPerFoot = 12;
	literal double inchesToMeters = 2.54/100;

public:
	// Create a height from inches value
	Height(int ins)
	{
		feet = ins/inchesPerFoot;
		inches = ins%inchesPerFoot;
	}

	// Create a height from feet and inches
	Height(int ft, int ins) : feet(ft), inches(ins) {};

	// The height in meters
	property double meters
	{
		double get()
		{
			return inchesToMeters*(feet*inchesPerFoot+inches);
		}
	}

	// Create a string representation of the object
	virtual String^ ToString() override
	{
		return feet + L" feet " + inches + L" inches";
	}
};

// Class defining a person's weight
value class Weight
{
private:
	int lbs;
	int oz;

	literal int ouncesPerPound = 16;
	literal double lbsToKg = 1.0/2.2;

public:
	Weight(int pounds, int ounces)
	{
		lbs = pounds;
		oz = ounces;
	}

	property int pounds
	{
		int get() { return lbs; }
		void set(int value) { lbs = value; }
	}

	property int ounces
	{
		int get() { return oz; }
		void set(int value) { oz = value; }
	}

	property double kilograms
	{
		double get() { return lbsToKg*(lbs+oz/ouncesPerPound); }
	}

	virtual String^ ToString() override
	{
		return lbs + L" pounds " + oz + L" ounces";
	}
};

ref class Person
{
private:
	Height ht;
	Weight wt;

public:
	property String^ Name;

	Person(String^ name, Height h, Weight w) : ht(h), wt(w)
	{
		Name = name;
	}

	Height getHeight() { return ht; }
	Weight getWeight() { return wt; }
};

int main(array<System::String ^> ^args)
{
	Weight hisWeight = Weight(185, 7);
	Height hisHeight = Height(6, 3);
	Person^ him = gcnew Person(L"Fred", hisHeight, hisWeight);

	Weight herWeight = Weight(105, 3);
	Height herHeight = Height(5, 2);
	Person^ her = gcnew Person(L"Freda", herHeight, herWeight);

	Console::WriteLine(L"She is {0}", her->Name);
	Console::WriteLine(L"Her weight is {0:F2} kilograms.", her->getWeight().kilograms);
	Console::WriteLine(L"Her height is {0} which is {1:F2} meters.", her->getHeight(), 
		her->getHeight().meters);

	Console::WriteLine(L"He is {0}", him->Name);
	Console::WriteLine(L"His weight is {0}", him->getWeight());
	Console::WriteLine(L"His height is {0} which is {1:F2} meters.", him->getHeight(), 
		him->getHeight().meters);

    return 0;
}

輸出為

She is Freda
Her weight is 47.73 kilograms.
Her height is 5 feet 2 inches which is 1.57 meters.
He is Fred
His weight is 185 pounds 7 ounces
His height is 6 feet 3 inches which is 1.91 meters.

二、索引屬性

索引屬性是類的一組屬性值，其訪問方法同數組元素那樣，在方括號內加索引值來訪問。如果在方括號前面的是類對象的名稱，則該索引屬性被稱為默認索引屬性（如String^ obj可以用obj[idx]來訪問字符串中第idx+1個字符），如果用屬性名[idx]來訪問索引屬性值，則稱為有名索引屬性。下面的代碼在類Name中定義了一個默認索引屬性，

ref class Name
{
private:
	array<String^>^ Names;

public:
	Name(...array<String^>^ names) : Names(names) {}
	
	// Indexed property to return any name
	property String^ default[int]
	{
		// Retrieve indexed property value
		String^ get(int index)
		{
			if(index >= Names->Length)
				throw gcnew Exception(L"Index out of range");
			return Names[index];
		}
	}
};

在上面的例子中，如果將default換成別的名字，則該屬性就成為一個有名索引屬性。在定義索引屬性時，方括號內用int指定了索引的數據類型為int型，它也可以是別的數據類型。訪問索引屬性的get()函數的形參其數據類型必須與屬性名后方括號內類型相同；set()函數必須有2個形參，第一個指定索引，第二個指定屬性元素的值。

下面是一個完整的例子，說明了索引屬性的定義與使用方法。

// Ex7_17.cpp : main project file.

#include "stdafx.h"

using namespace System;

ref class Name
{
private:
	array<String ^>^ Names;

public:
	Name(...array<String ^>^ names) : Names(names) {}

	// Scalar property specifying number of names
	property int NameCount
	{
		int get() { return Names->Length; }
	}

	// Indexed property to return names
	property String^ default[int]
	{
		String ^ get(int index)
		{
			if(index >= Names->Length)
				throw gcnew Exception(L"Index out of range");
			return Names[index];
		}
	}
};

int main(array<System::String ^> ^args)
{
	Name^ myName = gcnew Name(L"Ebenezer", L"Isaiah", L"Ezra", L"Inigo", L"Whelkwhistle");

	// List the names
	for(int i=0; i<myName->NameCount; i++)
		Console::WriteLine(L"Name {0} is {1}", i+1, myName[i]);
    return 0;
}

輸出為

Name 1 is Ebenezer
Name 2 is Isaiah
Name 3 is Ezra
Name 4 is Inigo
Name 5 is Whelkwhistle

索引屬性的索引也可以不是整型，甚至可以不是數字，下面的例子定義了一個商店類，其屬性Opening指定了商店的開門時間，訪問該屬性的索引有2個參數，如下面的例子所示

enum class Day { Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday };

// class defining a shop
ref class Shop
{
public:
	property String^ Opening[Day, String^]	// Opening times
	{
		String ^ get(Day day, String^ AmOrPm)
		{
			switch(day)
			{
				case Day::Saturday:
					if(AmOrPm == L"am")
						return L"9:00";
					else
						return L"14:30";
					break;

				case Day::Sunday:
					return L"closed";
					break;

				default:
					if(AmOrPm == L"am")
						return L"9:30";
					else
						return L"14:00";
					break;
			}
		}
	}
};

使用該類的方法如下

Shop^ shop = gcnew Shop;
Console::WriteLine(shop->Opening(Day::Saturday, L"pm");

三、靜態屬性

靜態屬性為類的所有實例共有，類似于類的靜態成員變量。通過在屬性定義前添加修飾符static來定義，如下面的例子所示

value class Length
{
public:
	static property String ^ Units
	{
		String ^ get() { return L"feet and inches"; }
	}
};

無論是否創建類實例，靜態屬性都存在。如果已經定義了類實例，則可以用實例名.屬性名來訪問靜態屬性。對于上面的例子如果已經定義了一個類對象len，則可以如此訪問其靜態屬性：

Console::WriteLine(L"Class units are {0}.", len.Units);

 注意：在定義了屬性之后，對應的get_屬性名和set_屬性名自動成為系統保留名稱，不能為其它目的而使用他們。如果定義了默認索引屬性，則set_Item和get_Item也成為系統保留名稱，不可被使用。

C++/CLI中可以定義兩種類型的struct和class類型，一種為數值類（或數值結構）：value class(value struct)；一種是引用類（或引用結構）：ref class(ref value)。與本地C++一樣，class與struct的區別在于前者的成員默認為私有，后者默認為公有。下面僅以類來介紹，內容同樣適用于結構。

value class與ref class組成的是雙關鍵字，也就是說，單獨的value、ref并不是關鍵字。數值類與引用類的區別，以及它們與本地C++類的區別主要包括以下幾個方面：

• 數值類的對象包含自己的數據，引用類的對象只能用句柄來訪問。
• 在C++/CLI中，函數成員不能聲明為const類型，取而代之的是字面值類型，修飾詞關鍵字為 literal。
• 在非靜態函數成員中，this指針類型與本地C++不同：數值類的this指針為內部指針類型(interior_ptr<T>)，而引用類的this指針為句柄類型(T^)。
• C++/CLI類的數據成員不能包含本地C++數組或本地C++類對象。
• C++/CLI類無友元函數。
• C++/CLI類的數據成員不能包含位類型的數據成員。（什么是位數據類型）
• C++/CLI類的函數成員不能有默認的形參。

此外，在C++/CLI中，不推薦類命名時使用前綴‘C’，其成員變量命名也不用前綴’m_’。

一、定義數值類

數值類主要用于表示具有有限個數據成員的簡單對象，其定義方法與本地C++類基本相同。首先看一個定義數值類，以及使用類的完整例子。

// Ex7_14.cpp : main project file.

#include "stdafx.h"

using namespace System;

// class representing a height
value class Height
{
private:
	// Records the height in feet and inches
	int feet;
	int inches;

public:
	// Create a height from inches value
	Height(int ins)
	{
		feet = ins/12;
		inches = ins%12;
	}

	// Create a height fromm feet and inches
	Height(int ft, int ins) : feet(ft), inches(ins) {}
};

int main(array<System::String ^> ^args)
{
	Height myHeight = Height(6, 3);
	Height^ yourHeight = Height(70);
	Height hisHeight = *yourHeight;

	Console::WriteLine(L"My height is {0}", myHeight);
	Console::WriteLine(L"Your height is {0}", yourHeight);
	Console::WriteLine(L"His height is {0}", hisHeight);
    return 0;
}

輸出為

My height is Height
Your height is Height
His height is Height

在上面的例子中，myHeight和hisHeight被分配在堆棧上，yourHeight被分配到了CLR堆上。其中hisHeight是yourHeight的一個副本，當向 hisHeight賦值時，需要用*操作符對句柄yourHeight進行解除引用計算。這是因為數值類對象總是包含自己的數據，因此它們不能引用同一個對象，在賦值時總是采用復制的方式進行。注意：在C++/CLI中，不能重寫默認構造函數。默認構造函數將所有的值類型數據成員初始化為0，將引用類型（句柄）初始化為nullptr。同樣，也不能重載復制構造函數和賦值操作符。默認的復制操作是將每一個數據成員進行復制，對象間的賦值也是如此。

C++/CLI中的類都有一個成員函數ToString()，它返回一個表示對象的字符串句柄。默認情況下，該字符串為類名。這從上面的輸出可以看出：傳遞給WriteLine()函數的是Height對象，結果輸出的并非對象所包含的高度值，而是類名Height，這是因為編譯器認為此處需要調用該對象的字符串表示法，因此安排的ToString()函數調用，這個過程可以顯示的表達為

double pi = 3.142;
Console::WriteLine(pi.ToString());

double類型被映射到System命名空間中的System::Double類，該類實現了ToString方法，因此可以正確的輸出變量pi的數值3.142而非類名Double。在上面的例子中，為了正確地輸出高度，可給Height定義中增加ToString()的重載函數。

	//Create a string repesentation og the object
	virtual String^ ToString() override
	{
		return feet + L" feet " + inches + L" inches";
	}

現在可以正確的輸出為

My height is 6 feet 3 inches
Your height is 5 feet 10 inches
His height is 5 feet 10 inches

在定義數值類時，如果數據成員為常量，C++/CLI中將其定義為”字面值”(literial)。在上面的例子中，將12定義為字面值，可以使得代碼的可讀性更高，避免“幻數”的出現（意指程序代碼中難以理解其來源或意義的常數，如上面例子中的12）。定義字面值的方法如下

value class Height
{
	int feet;
	int inches;
	literial int inchesPerFoot = 12;
	
	// Other code...
};

這樣就可以在其后直接使用該字面值，而非難以理解的12了

Height(int ins)
{
	feet = ins/ inchesPerFoot;
	inches = ins% inchesPerFoot;
}

利用”字面值”leterial來定義常量的一個缺點是：必須在定義常量的同時指定它的值。另外一種定義常量的方法是使用initonly修飾符，使用該修飾符的常量變量只能在構造函數的初始化表，或者構造函數體內進行一次初始化， 之后再也不能被修改。注意：不能在聲明非靜態initonly常量時指定初值，而必須是在構造函數的初始化表或構造函數體內。下面的例子描述了onlyinit的用法

value class Length
{
private:
	int feet;
	int inches;
	
public:
	initonly int inchesPerFoot;
	
	// Constructor
	Length(int ft, int ins) : 
		feet(ft), inches(ins),
		inchesPerFoot(12);
}

上面的構造函數也可以寫成

Lenght(int ft, int ins) :
	feet(ft), inches(ins)
{
	inchesPerFoot = 12;
}

如果是靜態地initonly變量，則只能在定義時指定初值。因為如果自構造函數中定義，則每次創建類實例都將對靜態變量賦值，這顯然與靜態、常量這樣的概念沖突。解決的辦法是，如果一定要在構造函數中初始化initonly類型的靜態常量，則可定義一個靜態構造函數。

value class Length
{
private:
	int feet;
	int inches;

	static Length() { inchesPerFoot = 12; }

public:
	initonly static int inchesPerFoot;

	Length(int ft, int ins) :
		feet(ft), inches(ins)
	{ }
};

靜態構造函數函數沒有形參，且沒有初始化表，總是被聲明為private。它不能被直接調用，而是由普通構造函數在調用之前自動調用。這種方法與在定義靜態initonly變量時指定初始值的唯一區別是，初始化值可以是在運行時確定的。

二、定義引用類

引用類更加類似于本地C++類，它沒有數值類那么多的限制。但引用類沒有默認的復制構造函數和賦值運算符，如果定義的類需要進行復制或賦值，必須顯式地添加相應的函數成員。下面的例子定義了一個引用類及其使用方法。

// Ex7_15.cpp : main project file.

#include "stdafx.h"

using namespace System;

ref class Box
{
public:
	// No-arg constructor supplying default field values
	Box():Length(1.0), Width(1.0), Height(1.0)
	{
		Console::WriteLine(L"No-arg constructot called.");
	}
	// Constructor definition using an initialisation list
	Box(double lv, double bv, double hv):Length(lv), Width(bv), Height(hv)
	{
		Console::WriteLine(L"Constructor called.");
	}

	// Function to calculate the volume of a box
	double Volume()
	{
		return Length*Width*Height;
	}

private:
	double Length;
	double Width;
	double Height;
};

int main(array<System::String ^> ^args)
{
	Box^ aBox;
	Box^ newBox = gcnew Box(10, 15, 20);
	aBox = gcnew Box;

	Console::WriteLine(L"Default box volume is {0}", aBox->Volume());
	Console::WriteLine(L"New box volume is {0}", newBox->Volume());
    return 0;
}

輸出為

Constructor called.
No-arg constructot called.
Default box volume is 1
New box volume is 3000

在上面的例子中，main()函數的第一句沒有創建任何對象，僅僅聲明了一個句柄，并被默認的賦值成nullptr。此外，引用對象總是在堆上創建，因此總是用gcnew來調用其構造函數，并用句柄來跟蹤引用對象。

類函數是C++/CLI中引入的新概念，其功能類似于函數模板，但原理上卻迥然不同。使用函數模板時，編譯器根據模板生成函數源代碼，然后將其與其它代碼一起編譯。這種方法可能會產生許多函數，從而使得生成模塊的體積增加，這就是所謂的“代碼膨脹”。類函數與之不同，類函數本身將被編譯，在調用類函數時，實際類型在運行時取代了類函數的類型形參，這不會導致新增代碼的問題。

一、類函數的定義

類函數與普通函數的區別在于：它需要定義一個特殊的形參——類型形參，該參數說明在運行時傳遞給函數的參數類型。下面的例子定義了一個類函數，用于找出某種數據類型數組中最大的元素。

generic<typename T> where T:IComparable
T MaxElement(array<T>^ x)
{
	T max = x[0];
	for(int i=1; i<x->Lenght; i++)
		if(max->CompareTo(x[i])<0)
			max = x[i];
	return max;
}

關鍵字generic規定后面的內容為類函數定義，尖括號內用關鍵字typename定義了一個類型形參T，如果有多個類型形參，它們都放在尖括號內，用逗號分開。

關鍵字where引入使用類函數時，傳遞給T的類型實參應滿足的約束條件。這里的條件是：所有用于替代T的類型必須實現了IComparable接口。該約束也意味著，所有傳入的類型實參都實現了CompareTo()函數，允許對該類型兩個對象進行比較。

第二行定義了函數的返回值類型、函數名稱以及形參，與普通函數定義類似，但有的類型用T來描述，它們將在運行時被確定。

二、使用類函數

調用類函數的方法與調用普通函數的方法一樣。對上面聲明的MaxElement()函數可如此調用：

array<double>^ data = {1.5, 3.5, 6.7, 4.2, 2.1};
double maxData = MaxElement(data);

 在這個例子中，編譯器能夠判斷出該類函數的類型實參為double，生成調用函數的代碼(并非是該類函數的double版)，執行時再用 double代替T。注意：與函數模板不同，對于類函數編譯器不創建函數實例，而是僅僅是使編譯后的代碼可以接受數據類型作為類型實參，實際的類型替換在運行時實現。

應該注意的是，如果以字符串常量作為實參傳遞給類函數，編譯器將認為類型實參是String^，無論該字符串常量是窄字符串(“Hello”)還是寬字符串(L“Hello”)。

有些情況下，編譯器無法根據函數調用來判斷類型實參是什么，這時可用在函數名后面加尖括號和類型名稱來顯示的指定，上面的例子也可以寫作

double maxData = MaxElement<double>(data);

另外需要注意的是，提供給類函數作為類型實參的不能是本地C++類類型、本地指針、引用，也不能是值類類型的句柄(如 int^)。而只能是值類型(如int、double)或引用類型的跟蹤句柄(如String^)。

下面是一個使用類函數的完整示例。

// Ex6_10.cpp : main project file.
// Defining and using generic fuctions
#include "stdafx.h"

using namespace System;

// Generic function to find the maximum element in an array
generic<typename T> where T:IComparable
T MaxElement(array<T>^ x)
{
	T max = x[0];
	for(int i=1; i<x->Length; i++)
		if(max->CompareTo(x[i])<0)
			max = x[i];
	return max;
}

// Generic function to remove an element from an array
generic<typename T> where T:IComparable
array<T>^ RemoveElement(T element, array<T>^ data)
{
	array<T>^ newData = gcnew array<T>(data->Length-1);
	int Index = 0;		// Index to elements in newData array
	bool found = false;	// Indicates that the element to remove from was found
	for each(T item in data)
	{
		// Check for invalid index or element found
		if((!found) && item->CompareTo(element)==0 )
		{ 
			found = true;
			continue;
		}
		else
		{
			if(Index == newData->Length)
			{
				Console::WriteLine(L"Element to remove not found");
				return data;
			}
			newData[Index++] = item;
		}
	}
	return newData;
}

// Generic function to list an array
generic<typename T> where T:IComparable
void ListElements(array<T>^ data)
{
	for each(T item in data)
		Console::Write(L"{0, 10}", item);
	Console::WriteLine();
}

int main(array<System::String ^> ^args)
{
	array<double>^ data = {1.5, 3.5, 6.7, 4.2, 2.1};
	Console::WriteLine(L"Array contains:");
	ListElements(data);
	Console::WriteLine(L"\nMaximun element = {0}\n", MaxElement(data));
	array<double>^ result = RemoveElement(MaxElement(data), data);
	Console::WriteLine(L"After removing maximun, array contains:");
	ListElements(result);


	array<int>^ numbers = {3, 12, 7, 0, 10, 11};
	Console::WriteLine(L"Array contains:");
	ListElements(numbers);
	Console::WriteLine(L"\nMaximun element = {0}\n", MaxElement(numbers));
	Console::WriteLine(L"After removing maximun, array contains:");
	ListElements(RemoveElement(MaxElement(numbers), numbers));

	array<String^>^ strings = {L"Many", L"hands", L"make", L"light", L"work"};
	Console::WriteLine(L"Array contains:");
	ListElements(strings);
	Console::WriteLine(L"\nMaximun element = {0}\n", MaxElement(strings));
	Console::WriteLine(L"After removing maximun, array contains:");
	ListElements(RemoveElement(MaxElement(strings), strings));

	return 0;
}

輸出如下

Array contains:
       1.5       3.5       6.7       4.2       2.1

Maximun element = 6.7

After removing maximun, array contains:
       1.5       3.5       4.2       2.1
Array contains:
         3        12         7         0        10        11

Maximun element = 12

After removing maximun, array contains:
         3         7         0        10        11
Array contains:
      Many     hands      make     light      work

Maximun element = work

After removing maximun, array contains:
      Many     hands      make     light

C++/CLI中函數的工作方式與ISO/ANSI C++完全相同，但由于在C++/CLI中用跟蹤句柄和跟蹤引用替代了本地指針和引用，因此也帶來一些變化，主要包括

• CLR程序中函數的形參與返回值可以是數值類型、跟蹤句柄、跟蹤引用和內部指針。
• 如果某個形參是CLR數組，程序不需要另外的參數指定其大小，因為數組大小在屬性Length中。
• 在C++/CLI程序中，不能像C++一樣進行地址的算術運算，而應使用數組索引。（內部指針不是可以算術操作嗎？）
• 可以方便的返回CLR堆上的句柄，因為CLR有垃圾回收機制自動清理無用的內存。
• C++/CLI函數接收可變長度參數的機制與本地C++不同。
• C++/CLI中main()函數訪問命令行實參的機制與本地C++不同。

下面就最后2條進行說明。

一、接收可變長度參數的函數

C++/CLI允許將形參列表指定為數組，數組聲明前面加省略號，從而實現實參的長度可變。

int sum(...array<int>^ args)
{
	// Code for sum
}

上面的sum()函數可以接收任意數量的整數作為實參，在函數內部，通過訪問數組args的元素就可以實現對實參的處理，實參個數由args的屬性Length得到。下面是一個完整的例子，描述了該機制的工作過程。

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

double sum(...array<double>^ args)
{
	double sum = 0.0;
	for each(double arg in args)
		sum += arg;
	return sum;
}

int main(array<System::String ^> ^args)
{
	Console::WriteLine( sum(2.0, 4.0, 6.0, 8.0, 10.0, 12.0) );
	Console::WriteLine( sum(1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8, 9.9) );
        return 0;
}

輸出為

42
49.5

二、main()的實參

從前面的例子可以看出，CLR程序中main()函數僅有一個形參，它為String^類型的數組，這就將處理命令行實參簡化為訪問該數組的元素。下面的例子展示了這個用法。

此外還應注意：與本地C++中main()不同，命令行參數中不包括程序名稱本身。

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

int main(array<System::String ^> ^args)
{
	Console::WriteLine(L"There were {0} command line arguments.", args->Length);
	Console::WriteLine(L"Command line arguments received are:");
	int i=1;
	for each(String^ str in args)
		Console::WriteLine(L"Argument {0}: {1}", i++, str);
    
	return 0;
}

輸出為

D:\My Documents\My Projects\Ex5_16\Debug>ex5_16 tring multiple "arguments values
" 4.5 0.0
There were 5 command line arguments.
Command line arguments received are:
Argument 1: tring
Argument 2: multiple
Argument 3: arguments values
Argument 4: 4.5
Argument 5: 0.0

與本地C++自己維護堆不同，C++/CLI中動態分配的內存是由CLR來維護的。當不需要堆時，CLR自動將其刪除回收，同時CLR還能自動地壓縮內存堆以避免產生不必要的內存碎片。這種機制能夠避免內存泄露和內存碎片，被稱為垃圾回收，而由CLR管理的這種堆被稱為CLR堆。它由操作符gcnew創建。

由于垃圾回收機制會改變堆中對象的地址，因此不能在CLR堆中使用普通C++指針，因為如果指針指向的對象地址發生了變化，則指針將不再有效。為了能夠安全地訪問堆對象，CLR提供了跟蹤句柄（類似于C++指針）和跟蹤引用（類似于C++）引用。

一、跟蹤句柄

跟蹤句柄類似于本地C++指針，但能夠被CLR垃圾回收器自動更新以反映被跟蹤對象的新地址。同時不允許對跟蹤句柄進行地址的算術運算，也不能夠進行強制類型轉換。

凡是在CLR堆上創建的對象必須被跟蹤句柄引用，這些對象包括：(1)用gcnew操作符顯示創建在堆上的對象；(2)所有的引用數據類型（數值類型默認分配在堆棧上）。注意：所有分配在堆上的對象都不能在全局范圍內被創建。

關于跟蹤句柄的相關使用方法參見《C++/CLI學習入門(三):數組》

二、跟蹤引用

跟蹤引用類似于本地C++引用，表示某對象的別名?？梢越o堆棧上的值對象、CLR堆上的跟蹤句柄創建跟蹤引用。跟蹤引用本身總是在堆棧上創建的。如果垃圾回收移動了被引用的對象，則跟蹤引用將被自動更新。

跟蹤引用用%來定義，下面的例子創建了一個對堆棧上值對象的跟蹤引用：

int value = 10;
int% trackValue = value;

stackValue為value變量的引用，可以用stackValue來訪問value：

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

三、內部指針

C++/CLI還提供一種用關鍵字interior_ptr定義的內部指針，它允許進行地址的算術操作。必要時，該指針內存儲的地址會由CLR垃圾回收自動更新。注意，內部指針總是函數的局部自動變量。

下面的代碼定義了一個內部指針，它含有某數組中第一個元素的地址：

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

必須給interio_ptr指定內部指針指向的對象類型。此外還應該給指針進行初始化，如果不提供初始值，系統將其默認初始化為nullptr。

內部指針在指定類型時應注意：可以包含堆棧上值類型對象的地址，也可以包含指向CLR堆上某對象句柄的地址，還可以是本地類對象或本地指針，但不能是CLR堆上整個對象的地址。也就是說，可以使用內部指針存儲作為CLR堆上對象組成部分的數值類對象（如CLR數組元素）的地址，也可以存儲System::String對象跟蹤句柄的地址，但不能存儲String對象本身的地址。

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

與本地C++指針一樣，內部指針可以進行算術計算。可以通過遞增或遞減來改變其包含的地址，從而引用后面或前面的數據項；還可在內部指針上加上或減去某個整數；可以比較內部指針。下面的例子展示了內部指針的用法：

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

int main(array<System::String ^> ^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<String^>^ strings = { L"Land ahoy!",
		L"Splice the mainbrace!",
		L"Shiver me timbers!",
		L"Never throw into the wind!"
	};

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

    return 0;
}

輸出為

Total of data array elements = 18

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

C++/CLI字符串（Unicode字符組成的字符串）是指在System命名空間中定義的String類，即由System:Char類型的字符序列組成的字符串。它包含大量強大的功能，使得字符串的處理非常容易。創建一個String對象的方法如下例所示：

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。

String^ proverb;

在聲明時句柄時，系統自動為其分配一個空值，該句柄不引用任何對象。也可顯示地將某個句柄置為空值:

proverb = nullptr;

注意不能用0來表示空值。如果用0來初始化某個句柄，則0將自動轉換為被引用類型的對象，而句柄則指向該對象?？梢栽诼暶骶浔鷷r顯示的將其初始化：

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屬性是數組的一個重要屬性，記錄著數組元素的數量。保存了64位的數組長度。

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

可以用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函數還有很多其它版本，下面的例子展示了如何排序兩個相關的數組，即第一個數組中的元素是第二個數組對應元素的鍵。對第一個數組排序后，可對第二個數組進行相應的調整，使得鍵與值相互對應。

Sort()函數對2個數組排序時，用第一個數組參數來確定兩個數組的順序，以此保持2個數組元素對應關系不變。

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

(三)數組搜索

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個是要搜索的內容。下面的代碼從第4個元素開始，一直搜索到結束位置。

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 : 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類對象里。該類有3個可訪問屬性用于幫助確定被按下的鍵是哪個或哪些鍵。屬性Key識別被按下的鍵是哪個，屬性KeyChar是被按鍵的Unicode字符碼，屬性Modifiers表示Shift,Alt,Ctrl鍵的按位組合，它是定義在System命名空間中的枚舉類型ConsoleModifiers的常量，包括Shift\Alt\Control。

應該注意的是，在C++/CLI中枚舉常量在用作數值之前必須被顯示的強制轉換為值類型（整數類型）

例子：使用Console::ReadKey()函數

// 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 Enter which is the  character
You pressed Spacebar which is the   character
You pressed Spacebar which is the   character

從輸出中可以看出，當不只一個鍵被按下時，用一條語句就可以得到所有的鍵。這是因為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. 

注意：由于proverb字符串中的字符都是Unicode字符，因此用wchar_t（映射為Char類型）類型的變量來存儲這些字符。變量ch為循環內的局部變量。

從今日開始，將前期學習《Visual C++ 2005入門經典》（Ivor Horton著 清華大學出版社出版）的相關筆記整理到隨筆中，希望能和C++/CLI愛好者分享學習過程中的心得。文中主要內容和例子摘自原書相關章節，如有侵權，請留言或來信告知。

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

• 在C++/CLI程序中，所有ISO/ANSI基本數據類型都可以使用，但在一些特殊的上下文環境中，它們具有一些額外屬性；
• 在控制臺程序中，C++/CLI對鍵盤和命令行輸出提供了自己的機制；
• C++/CLI中引入了safe_cast運算符，確保強制類型轉換操作能夠生成可檢驗的代碼；
• C++/CLI提供了另外一種基于類的枚舉功能，其靈活性超過了ISO/ANSI C++中的enum聲明。

一、基本數據類型

C++/CLI中包括了所有ISO/ASNI C++中的基本數據類型，算術運算也和本地C++完全一樣。除此之外，C++/CLI中還定義了2種整數類型，如表1所示：

表1:C++/CLI新增基本數據類型

指定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值類型

默認情況下，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￡oF2} pounds ", packageCount, packageWeight);

輸出為（下劃線表示空格填充位）：

Packages: _25 Weight: __7.50 pounds

可選的格式說明符如表3所示

表3：格式說明符

例子：計算地毯價格，演示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()的例子如下：

ReadLine()用于將整行文本存入字符串中，按下Enter鍵時，文本結束。變量line為String^型，表示String數據類型的引用，line為Console::ReadLine()函數讀入字符串的引用。

String^ line = Console::ReadLine();

Read()用于逐字符的讀入輸入數據，并將其轉換成對應的數字值。ReadKey的例子如下：

char ch = Console::Read();

ReadKey()用于讀取按鍵值，并返回ConsoleKeyInfo對象，該為對象定義在System命名空間中的值類型。參數true表示按鍵不在命令行上顯示出來，false則表示顯示按鍵回顯。按鍵對應的字符可用ConsoleKeyInfo對象的KeyChar得到。

ConsoleKeyInfo keyPressed = Console::ReadKey(true);
Console::WriteLine(L"The key press corresponds to the character: {0}", keyPress.KeyChar);

盡管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中的一個枚舉類型：該語句定義了一個枚舉類型Suit，該類型的變量只能被賦值枚舉定義中的值，且必須用枚舉類型名稱限定枚舉常數。

enum class Suit {Clubs, Diamonds, Hearts, Spades};
Suit suit = Suit::Diamonds;

注意class關鍵字跟在enum之后。說明該枚舉類型為C++/CLI，該關鍵字還表明在定義中規定的常量: Clubs\Diamonds\Hearts\Spades都是類對象而非ISO/ANSI C++中的基本類型（整型）值。實際上，默認情況下這些都是Int32類型的對象。

由于C++/CLI枚舉定義中的變量都是類對象，因此不能在函數內部定義。

(一）指定枚舉常量的類型

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

要指定一個枚舉常量的類型，可以在枚舉類型名稱之后寫入常量類型名稱（要用冒號隔開），下例枚舉類型中的常量為Char類型，對應的基本類型為char。其中第一個常量默認情況下對應于代碼值0，后面的依次遞增。

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

(二)指定枚舉常量的值

可以賦予枚舉類型定義中的一個或全部常數對應的值，下例使得Ace獲得1，Two獲得2，其余依此類推，直到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};

例子：使用枚舉類型

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

例子說明

• Suit為枚舉類型，不能在函數main()內部定義，因此只能定義為全局作用域內。
• 必須用類型名稱Suit限定枚舉常量，如Suit::Clubs，否則編譯器將無法識別。
• 變量suit的值為類對象，要獲取其值必須顯示的將其轉換成int類型。