头文件与函数声明
在传统C++的设计与实现中，你可对需建模的每种类型进行定义，并把定义放在各自的头文件中；而头文件中，一般会包含类型名、成员名、及相关小型成员函数的内联定义。
与各个单独编译的源文件是通过头文件来共享信息不同，在C++/CLI中，这些信息是通过程序集来共享的。就拿常举例的Point类来说，它单独编译，并生成了一个名为"Point.dll"的程序集。任何需要某种类型定义的应用程序，都必须编译和链接带有此类型的程序集，这同时也要求此DLL形式的程序集中有完整的类型定义；同样，在类型中所有声明的函数也必须被定义，否则，链接器将会报告错误。
举例来说，你可以在Point类中声明成员函数GetHashCode，并在类外定义它，但必须在同一源文件中（见例1）。但是，若把此成员函数的定义放在一个单独的源文件中却不行，即便源文件是作为同一程序集的输入、与Point.cpp同时编译也不行，因为编译这样一个文件需要访问程序集Point.dll，而这正好是此编译过程要生成的程序集。（此处假定在函数定义时未使用inline，这将在后面讨论。）
例1：
public ref class Point
{
...
virtual int GetHashCode() override;
};
int Point::GetHashCode() override
{
return X ^ (Y << 1);
}
在编译及链接任何程序集时，都隐含不使用头文件，且程序集所依赖的所有其他程序集都必须是已编译及链接过的。
内联函数
在Point中，每个成员函数的定义都有意写成了inline（内联），除了增加定义的灵活性外，还可把代码保持在同一源文件中，使成员函数不能在类型定义本身之外的另一文件中被定义。
编写内联函数的传统方法是把某个函数都声明为inline，其对编译器来说是一个提示，让编译器在适当的时候对它进行内联化处理，是典型的以空间换时间做法。然而，在头文件定义中使用内联函数，这种形式的优化对编译来说，却非常有限。当Point类编译时，编译器会把类型内部对成员函数的调用内联化，例如，Point定义中所有X与Y属性的get与set方法都会被内联化。
那么，如果要在其他程序集的代码中使用Point，又会怎么样呢？所有对Point成员函数的调用都会因此内联化吗？理论上来说，是的，毕竟，为编译应用程序代码，编译器需要访问Point程序集，故此它非常清楚既定的成员函数是怎样实现的，由此也会允许对这些函数的引用进行优化。
来看一下GetHashCode，从它简单的内容来看，似乎很适合进行内联化。现假定从外部另一程序集中对它的所有调用都是内联化的，那么，接下来，编译器很可能会使用不同的算法重新实现此函数。但如果未重新生成此外部程序集，它将会继续使用内联的hashcode算法，而不是新的版本。因为这通常都不是所期望发生的行为，所以要尽量避免跨程序集边界的内联，那么，也就不会对X与Y属性那些不重要的get与set方法进行内联了。
可幸的是，优化还可在编译之外进行，比如说，在最简单的执行模式中，每次一个程序只要一运行，它的CIL指令就会被执行。然而，一个即时编译器（JIT）会识别出特定的编码范式，并进行各种优化，其中就包含了代码内联。而那些大型、复杂的程序，会在每次安装时，都编译为本地代码，以这种方法，就不必在每次程序执行时，进行优化了。
GetHashCode的定义是没有声明为内联的，如果声明了，那对此头文件的多个包含，会导致同一名称的多次定义，就别指望链接器不会提出"抗议"了。但是要知道，这种方法是用于程序集而不是头文件的，所以一般不会产生此类错误，在程序集中只有这个函数的唯一定义。一般说来，在上下文中使用inline，出于自愿而不是强迫，事实上，在本例中，是不可使用的，因为声明为override的任何函数，都不能再标上inline。
遵从CLS
如果属性中的set与get方法使用了与众不同的可访问性，那么，就会阻碍语言间协同工作的能力。CLI的其中一个目标就是在无须主动请求的情况下，提升语言间的互操作性，为此，它定义了一个通用语言规范（CLS [1]）和一套CLS规则，例如，第25条规则写明："属性之访问性存取程序应为一致。"
当为CLI环境下实现一种类型时，需要考虑，是否导出了类型的多个方面，如成员函数签名等等，举例来讲，并不是所有基于CLI的语言都支持无符号整数及指针类型，又或只有一小部分语言能理解const与volatile。
CLS要求不具备某种特性的语言也能以函数调用的语法，来访问它们，正因为这个原因，属性X的存取程序在元数据中被各自称为get_X与set_X，类似地，对操作符函数，也有相应的元数据名，所以它们也能被那些没有操作符重载概念的语言所调用。
Equals函数 PK ==操作符
对一个引用类而言，相等性比较是通过一个名为Equals的函数，而不是重载 == 操作符来实现的。但是，还是可以重载此操作符的，见例2。
例2：
public ref class Point
{
...
static bool operator==(Point^ p1, Point^ p2)
{
Object^ o1 = p1;
Object^ o2 = p2;
/*1*/ if (o1 == nullptr || o2 == nullptr)
{
return false;
}
if (o1 == o2) //在测试自身吗？
{
return true;
}
if (p1->GetType() == p2->GetType())
{
return (p1->X == p2->X) && (p1->Y == p2->Y);
}
return false;
}
};
在标号1中，指明了不接受空值的句柄，但是，此处如果用p1与p2来代替o1与o2，就会造成自身的递归调用，因此，必须隐式转换为Object^。为遵从CLS，在此把函数标为static。（非静态操作符函数不符合CLS。）
除了句柄符号之外，这个函数与用传统C++编写起来非常类似，然而，最大的不同之处恰恰在于此操作符的使用，如果有这样一种情况，(p == q)，p与q都是Point^类型，问题在于，代码的阅读者可能会认为此处是在比较两个句柄，但实际上，是在比较这些句柄引用的Point。为明确地比较句柄，需要这样编写代码：
if (static_cast<Object^>(p1) == static_cast<Object^>(p2))
虽然也可为Point类提供 == 操作符函数，但仍必须提供Equals，否则，其他人对一个Point调用Equals时，就会转到System::Object中的相应函数，而其比较的是引用相等性，而不是值相等性。也就是说，如果指定Object的实例与当前实例为同一实例，它返回true，否则，返回false。
CLI数组
因为标准C++中也存在数组，它们与C语言中的数组也非常类似，也具有同样的利弊关系，即，它们都在编译时分配空间，有固定大小，且没有强制检查数组边界。多维数组并不真正存在，实际上，它们都是数组的数组，或数组的数组的数组等等，在此，我们把这类数组称为"本地数组"。
而在CLI中，数组则为对象，并分配在垃圾回收堆上，它们的大小在编译时可以为未知状态，且在运行时会自动进行数组边界检查，还支持真正的多维数组。同样地，就需要新的语法来表示这类CLI数组。
例3：
int main()
{
/*1*/ array<int>^ numbers = gcnew array<int>(5) {10, 20, 30, 40};
Display1DArray("numbers", numbers);
/*2*/ array<Point^>^ points = gcnew array<Point^> {gcnew Point(3,4), gcnew Point(5,7)};
Display1DArray("points", points);
/*3*/ numbers = gcnew array<int>{55, 66, 77};
Display1DArray("numbers", numbers);
/*4*/ numbers = gcnew array<int>{};
Display1DArray("numbers", numbers);
/*5a*/ points[0]->Move(2,5);
/*5b*/ points[1] = gcnew Point(8,1);
/*5c*/ Console::WriteLine("points[0] is {0}", points[0]);
}
请看例3，与引用类的实例相同，CLI数组的对象本质上没有名称，且它们是通过指向它们的句柄来访问的，正如标号1、2、3、4中所见，一个CLI数组类型是用类似于模板的符号进行编写的，如array<int>和arrar<Point^>。（在C++/CLI早期的版本中，必须使用using namespace cli::language，编译器才能理解这个符号，现在已不再需要了。）请仔细留意标号1与2，定义了指向数组的句柄，而不是数组，在标号2中，数组类型为"指向Point的句柄数组"，而不是"Point数组"。
默认以自动方式存储的句柄，值为nullptr，然而，在上面的数组定义中，用gcnew分配了一块内存来初始化句柄，在gcnew后紧跟着数组类型，其后可选的圆括号中指明了元素的个数，再往后可选的花括号中的列明了初始化列表。如果省略初始化列表，元素则取它们的默认值；如果省略元素个数，那么分配的个数则为初始化列表中表达式的个数；如果指定的个数大于列表中的个数，那余下的元素则取它们的默认值。（例如，numbers[4]的值为零。）元素的个数与初始化列表不能同时省略，且它们也不一定要为常量；元素个数可为零，初始化列表也能为空，两者都指明了一个零元素的数组，但这与完全没有数组却有很大的区别。
在标号2中，省略了元素个数，如果它指定了为3，那第三个元素将会被初始化为nullptr，而不是由默认构造函数生成的指向Point的句柄，这与想像的有点不同。
在标号3中，把int数组句柄numbers设为了一个新值--包含了3个int的数组，这将导致新数组比旧数组中的元素减少一个，如果减少的是已分配空间中唯一的元素，那它最终将会被垃圾回收器回收。因此，尽管数组可以有一个固定大小，但一个一维或多维数组的句柄，能被重新设为类型与维数不变情况下的任意数组，而不用在乎元素的个数（其由系统维护）。
正如标号5a、5b与5c中所示，可用下标来访问一维CLI数组。
函数Display1DArray将显示它第一个参数的文本，第二个参数所指定的数组中元素的个数，及这些元素的具体值（如果有的话），以下是输出：
numbers 5: 10 20 30 40 0
points 2: (3,4) (5,7)
numbers 3: 55 66 77
numbers 0:
points[0] is (2,5)
例4是Display1DArray的源代码。（眼下，暂时把关键字generic当作template。）
例4：
generic<typename T>
void Display1DArray(String^ text, array<T>^ ary)
{
/*6*/ if (ary == nullptr)
{
Console::WriteLine("nullptr passed");
return;
}
/*7*/ Console::Write("{0} {1}:", text, ary->Length);
/*8*/ for each (T element in ary)
{
Console::Write(" {0}", element);
}
/*9*/ Console::WriteLine();
}
很明显，参数ary是一个类型T的CLI数组句柄，但是，ary不但可为一个数组的句柄，也能为一个nullptr值的句柄，所以在标号6中，对它进行了相应的检查。
在标号7中，显示了传入进来的文本及数组中元素的个数，而后者是用只读属性Length获取的，这是所有数组都有的属性。（所有的CLI数组都隐式从类System::Array继承，而类System::Array则具有Length属性。）
接下来，在标号8中循环遍历了此数组，并在同一行中显示出每个元素，并以标号9中的新行结束。此处，没有使用一个从零到ary->Length - 1的整数索引，而是使用了新的循环语句：for each（它们两者合成为一个关键字），用它来枚举集合中的元素。在此，不必深究for each的工作原理，只需了解，一个CLI数组也是一个CLI的集合，当然也可使用这种语法来进行遍历了。虽然使用此方法不能访问到每个元素的下标索引，但要知道，并不是所有集合都是线性的（如二叉树），在这种情况下，索引毫无意义。
当使用下标来访问CLI数组时，并不是使用数组的 [] 操作符，而是使用了定义在System::Array中，称为Item的索引属性。虽然一个标量属性只能为一个单一的值，但一个索引属性却能有不同的值，且每个值都能用下标来访问。
为使Display1DArray对数组类型不敏感，一般会想到template，然而，template是一个编译时的操作，对程序中使用的每种数组类型，都会产生一个相应的副本。在版本V2中，CLI添加了对generic的支持，generic是一个依赖于上下文的标识符，它的功能类似于模板，但它在运行时只会有单一的一份副本。（与大家想的一样，也有generic类型。）
C++/CLI支持真正的多维数组
CLI数组的第二个参数为可选，其代表了一个数组的序（也即是数组的维数），默认为1。比如在前一个例子中，array<int>也能写成array<int,1>。（与模板的非类型参数相似，其必须为一个编译时的常量。）
例5：
int main()
{
/*1*/ array<String^, 2>^ names = gcnew array<String^, 2> (2,3) {
{"John", "Robert", "Peter"},
{"Mary", "Alice"}
};
/*2*/ Console::WriteLine("names has {0} elements", names->Length);
/*3*/ Console::WriteLine("names has {0} dimensions", names->Rank);
/*4*/ Console::WriteLine("names[0,0] is {0}", names[0,0]);
/*5*/ names = gcnew array<String^, 2> (5,7);
/*6*/ Console::WriteLine("names has {0} elements", names->Length);
}
请看例5，在标号1中，定义了一个指向String句柄的两维数组的句柄，但并未指明行数或列数，接下来，分配了一个2×3数组的内存空间，并以5个字符串及一个nullptr初始化了这6个数组元素，以下是输出：
names has 6 elements
names has 2 dimensions
names[0,0] is John
names has 35 elements
Length属性给出了元素总数，而Rank属性给出了维数。
请注意标号4，可在一对中括号使用逗号分隔的索引数，用以访问多维数组的一个元素，在此，逗号为一个标点符号，而不是一个操作符。
也可把例中的names引用至任意的String^两维数组，比如在标号5中，把它重新引用至一个元素值全部为nullptr的5×7数组。
参数数组
请看下列代码的重载：
static String^ Concat(... array<Object^>^ list);
左边圆括号后面声明的参数（必须有一个CLI数组类型），表明了其可接受一个数目可变的既定元素类型的参数。
例6演示了一个可接受多个Point句柄当作参数的函数，其返回最左边（即最小）的X坐标。（当然，这个函数也能是Point类的一个静态成员函数。）
例6：
int LeftMostX(... array<Point^>^ points);
int main()
{
/*1*/ array<Point^>^ p = gcnew array<Point^> {
gcnew Point(10,3), gcnew Point(5,20), gcnew Point(-3, 4),
gcnew Point(1,30), gcnew Point(-5,2)
};
/*2*/ Console::WriteLine("LeftMostX is {0}", LeftMostX(p[1], p[3], p[0]));
/*3*/ Console::WriteLine("LeftMostX is {0}", LeftMostX(p));
}
int LeftMostX(... array<Point^>^ points)
{
/*4*/ int leftMostX = Int32::MaxValue;
for each (Point^ p in points)
{
if (p->X < leftMostX)
{
leftMostX = p->X;
}
}
return leftMostX;
}
在标号2中，调用了LeftMostX，并传递给它3个Point句柄，然而，在幕后，这个函数实际上只接受一个参数--一个指向Point句柄数组的句柄，同样地，编译器安排了这3个Point句柄传递进一个数组，并把数组的句柄传给函数。但也能像标号3那样，直接传递一个Point数组的句柄。
LeftMostX定义中，唯一新的东西是标号4，因为每种C++基本类型都会映射为一个相应定义实现在CLI库中的类型，例如，在Microsoft的实现中，short映射为System:Int16，int映射为System::Int32，而long long则映射为System:Int64；这些类型均为值类型，它们的实例被分配在堆栈上，而不是垃圾回收堆上。
MaxValue是类型Int32中一个公共静态字段，其值为2,147,483,647，它是有符号32位补码整数的最大值。（严格来说，MaxValue只是一个字面上的名称。）
