实例解析C++/CLI中的接口与泛型
接口
某些时候，让不相关的类分享一组公有成员，以便产生相同的行为，是非常有用的。一个最基本的方法可能是通过一个公共的基类来定义它们，但这种方法太受局限，因为它要求这些类通过继续而互相关联，另外，它们也许还有着各自的基类，且CLI类型只支持单一类继续。
C++/CLI提供了一种方法，可利用多个类实现一组通用的功能，这就是我们通称的"接口"，而一个接口则是一组成员函数的声明。要注重，这些函数只是声明，没有定义，也就是说，一个接口定义了一个由抽象函数组成的类型--这些函数实际上是纯虚函数，且在适当的时候，这些函数由客户类来实现。一个接口可答应不相关的类用同一名称和类型，实现同一功能，而无须要求这些类分享公共基类。在例1中演示了怎样定义一个接口。
例1：
using namespace System;
public interface class ICollection
{
void Put(Object^ o); //隐式public abstract
Object^ Get(); //隐式public abstract
};
一个接口的定义看上去非常像一个类，除了用interface取代了ref或value，所有的函数都没有函数体，且均隐式为public和abstract。按照通常的约定，一个接口名带有起始字母I，后再接一个大写字母。（接口类与接口结构是等价的。）与类相似，一个接口也能有public或PRivate访问可见性。
一个接口能有一个或多个"基接口"，在这种情况下，它将继续这些接口中的所有抽象函数，例如，在例2中，接口I2显式继续自I1，而I3显式继续自I1与I2，并通过I2隐式继续自I1。
例2：
interface class I1 { /* ... */ };
interface class I2 : I1 { /* ... */ };
interface class I3 : I1, I2 { /* ... */ };
一个类可像从基类继续时那样，来实现一个接口，见例3。
例3：
public ref class List : ICollection
{
public:
void Put(Object^ o)
{
// ...
}
Object^ Get()
{
// ...
}
// ...
};
一个类能实现一个以上的接口，在这种情况下，必须使用逗号来分隔接口列表，顺序倒不是很重要。当然，一个类在实现一个或多个接口时，也能显式地带有一个基类，在这种情况下，基类通常（但不是必须）写在最前面。
假如一个类实现了一个接口，但没有定义接口中所有的函数，这个类就必须声明为abstract。当然了，任何从抽象类继续而来的类也是抽象类，除非定义了之前的这些抽象函数。
接口不提供多重继续，与此相比，一个CLI类也只能有一个基类，然而，接口却提供某种与多重类继续相似的功能，但概念与之完全不同，例如，一个类不能从接口中继续函数定义；接口继续体系是独立于类继续体系的--实现同一接口的类也许会、但也许不会通过类继续体系相互关联。
例4演示了一个类：Queue，其与List无关联（但除了这个外，两者都是从Object继续而来的），两者都实现了同一接口。
例4：
public ref class Queue : ICollection
{
public:
void Put(Object^ o)
{
// ...
}
Object^ Get()
{
// ...
}
// ...
};
现在，可用它来编写处理参数为List或Queue的函数了，如例5。
例5：
ref class Item { /* ... */ };
void ProcessCollection(ICollection^ c);
int main()
{
List^ myList = gcnew List;
Queue^ myQueue = gcnew Queue;
ProcessCollection(myList);
ProcessCollection(myQueue);
}
void ProcessCollection(ICollection^ c)
{
Item^ x = gcnew Item();
/*1*/ c->Put(x);
/*2*/ x = static_cast<Item^>(c->Get());
}
在标号1与2中，为访问底层的List或Queue，使用了一个指向接口的句柄c，由此，你可传递给ProcessCollection一个指向任意对象的句柄，只要它的类实现了这个接口，或者它是从实现了这个接口的类继续而来的。
例6演示了一个包含只读属性X、只写属性Y、读写属性Z的接口，对读写属性来说，get与set声明的顺序并不重要。
例6：
public interface class iproperties
{
property int X { int get(); }
property String^ Y { void set(String^ value); }
property Object^ Z { Object^ get(); void set(Object^ value); }
};
一个接口的成员，可以为静态数据成员、实例或静态函数、静态构造函数、实例或静态属性、实例或静态事件、操作符函数、或任意的嵌套类型。
一般来说，我们会用for each语句来枚举集合中的所有元素，要对集合中的每个元素逐个进行操作，可使用如下语法：
for each (表达式形式的类型标识符)
嵌入语句
表达式类型必须为一个"集合类型"，假如要成为一个集合类型，这个类型必须实现接口System::Collections::IEnumerable，如例7中所定义。
例7：
public interface class IEnumerable
{
IEnumerator^ GetEnumerator();
};
正如大家所见，GetEnumerator返回一个指向IEnumerator的句柄，如例8中所定义。
例8：
public interface class IEnumerator
{
bool MoveNext();
void Reset();
property Object^ Current { Object^ get(); }
};
System::Array为一个集合类型，因为所有的CLI数组类型都继续自System::Array，所以，任何数组类型表达式都可以作为for each语句中的表达式。在例9的标号1中，for each用于遍历一个int数组，标号2中的处理过程也一样，但直接使用了枚举器。
例9：
using namespace System;
using namespace System::Collections;
int main()
{
array<int>^ ary = gcnew array<int>{10, 20, 30, 40};
/*1*/ for each (int i in ary)
{
Console::Write(" {0}", i);
}
Console::WriteLine();
/*2*/ IEnumerator^ ie = ary->GetEnumerator();
while (ie->MoveNext())
{
Console::Write(" {0}", static_cast<int>(ie->Current));
}
Console::WriteLine();
}
泛型
就像函数能用一个或多个类型表示符来定义一样，类型也可以这样来定义。假如有这样一种情况，某种类型建模了一个"数组"，其可使用下标来访问每个元素，这样的类型往往被称为"向量"，实现一个向量之后，可以保存一组int、一组double、或一组用户自定义类型的元素。然而，正是因为每种类型实现的代码对类型中的元素来说，都是唯一的，因此，可使用泛型机制来定义一个向量类型，并创建特定类型的实例。例10就是这样的一个例子。
例10：
generic <typename T>
public ref class Vector
{
int length;
/*1*/ array<T>^ vector;
public:
property int Length
{
int get() { return length; }
private:
void set(int value) { length = value; }
}
/*2*/ property T default[int]
{
T get(int index) { return vector[index]; }
void set(int index, T value) { vector[index] = value; }
}
Vector(int vectorLength, T initValue)
{
Length = vectorLength;
vector = gcnew array<T>(Length);
for (int i = 0; i < Length; ++i)
{
/*3*/ this[i] = initValue;
}
/*4*/ //for each (T element in vector)
//{
// element = initValue;
//}
}
Vector(int vectorLength)
{
Length = vectorLength;
vector = gcnew array<T>(Length);
for (int i = 0; i < Length; ++i)
{
/*5*/ this[i] = T();
}
}
Vector()
{
Length = 0;
/*6*/ vector = gcnew array<T>(0);
}
~Vector() //多余的
{
/*7*/ vector = nullptr;
}
virtual String^ ToString() override
{
String^ s = "[";
int i;
for (i = 0; i < Length - 1; ++i)
{
/*8*/ s = String::Concat(s, this[i], ":");
}
/*9*/ s = String::Concat(s, this[i], "]");
return s;
}
virtual bool Equals(Object^ obj) override
{
if (obj == nullptr)
{
return false;
}
if (this == obj) //在测试自身吗？
{
return true;
}
/*10*/ if (GetType() == obj->GetType())
{
Vector<T>^ v = static_cast<Vector^>(obj);
if (Length != v->Length) //是否向量有不同的长度？
{
return false;
}
for (int i = 0; i < Length; ++i)
{
/*11*/ //if (this[i] != v[i])
if (this[i]->Equals(v[i]) == false)
{
return false;
}
}
return true;
}
return false;
}
/*12*/ virtual int GetHashCode() override
{
return 0;
}
};
如同泛型函数一样，泛型的定义一般由generic <typename t1, ..., typename tn>打头，意思是通过tn引入了类型参数t1，这些参数的作用范围，可从类型定义的结束直到它们所依附的对象。在本例中，只有一个类型参数T。
在标号1中可见，一个Vector是作为一个类型为T的元素数组存储的。
在标号2中，定义了一个默认的索引属性，以便可用一个int下标值来访问一个Vector。当然了，在运行时，我们可以存取类型为T的元素，而不用管它实际上是什么类型。
与其直接访问私有成员，倒不如通过公有属性来进行访问，比如说，用Length来取代length；使用下标来访问当前的Vector（标号3）时，我们使用了this[i]。在此，很有可能会想到使用for each循环来取代一般的老式for循环，如标号4，但是，在此使用for循环是行不通的。在for each循环中，通过命名在循环结构中的局部变量，可为每个元素都产生一个副本，也就是说，变量已经不是原来的元素了，因此，修改它的值不会改变元素的值。
在标号5中，需要把每个元素设为默认值，幸运的是，标准C++要求每种类型都有一个默认的构造函数--甚至对不是类的类型也是这样，一般表示为类型名后紧跟空的圆括号。
程序在构造函数没有参数的情况下（标号6），分配了一个零元素数组。（注重，指向零元素数组的句柄，不等同于包含nullptr的句柄。）这样做的目的是为了让成员函数可以正常工作，甚至对空Vector也是如此。
为了完整起见，还定义了一个析构函数，以把句柄设为nullptr，目的是为了显式地告之垃圾回收器，我们对这个对象及与之关联内存的工作已经完成。
使用在标号8及9中的this[i]还是真有点让人糊涂，那它真正的目的是什么呢？不像等价的模板类，泛型类Vector是在类型T未知的情况下编译为一个程序集，假如编译器不知道T的类型，它也不知道this[i]的类型，因此，它该怎样生成代码，才能把这个表达式转换为Concat所期望的类型呢？其实它不必知道，Concat的其中一个重载版本会要求它的第二个参数为Object^类型，且因为this[i]有类型T，无论类型T是否处在运行时，它都是从System::Object继续来的，因此，它与参数类型相兼容。更进一步来说，因为System::Object有一个名为ToString的虚函数，对此虚函数的调用将产生一个String^，假定类型T已覆盖了这个函数，那么就可返回正确的字符串了。
函数Equals非常简单明了，但有一件事需要指出，请看标号11，从直觉上来说，我们一般会在此写成!=操作符，但是，这却通不过编译。请记住，类Vector是在对类型T一无所知的情况下编译的，除了它是继续自System::Object，同样地，唯一它答应对T调用的成员函数是那些由System::Object提供的函数，而这些类型未定义!=操作符，幸运的是，它提供了Equals函数，因此可使用它来达到同样的目的；接着，类型T覆盖了这个函数以执行对两个T的相等性判别，例11是主程序。
例11：
int main()
{
/*1*/ Vector<int>^ iv1 = gcnew Vector<int>(4);
/*2*/ Console::WriteLine("iv1: {0}", iv1);
/*3*/ Vector<int>^ iv2 = gcnew Vector<int>(7, 2);
Console::WriteLine("iv2: {0}", iv2);
iv2[1] = 55;
iv2[3] -= 17;
iv2[5] *= 3;
Console::WriteLine("iv2: {0}", iv2);
/*4*/ Vector<String^>^ sv1 = gcnew Vector<String^>(3);
Console::WriteLine("sv1: {0}", sv1);
/*5*/ Vector<String^>^ sv2 = gcnew Vector<String^>(5, "X");
Console::WriteLine("sv2: {0}", sv2);
sv2[1] = "AB";
sv2[3] = String::Concat(sv2[4], "ZZ");
Console::WriteLine("sv2: {0}", sv2);
/*6*/ Vector<DateTime>^ dv1 = gcnew Vector<DateTime>(2);
Console::WriteLine("dv1: {0}", dv1);
/*7*/ Vector<DateTime>^ dv2 = gcnew Vector<DateTime>(3, DateTime::Now);
Console::WriteLine("dv2: {0}", dv2);
for (int i = 0; i < dv2->Length; ++i)
{
Thread::Sleep(1100);
dv2[i] = DateTime::Now;
}
Console::WriteLine("dv2: {0}", dv2);
/*8*/ Vector<Vector<int>^>^ viv = gcnew Vector<Vector<int>^>(3);
Console::WriteLine("viv: {0}", viv);
viv[0] = gcnew Vector<int>(2, 1);
viv[1] = gcnew Vector<int>(4, 2);
viv[2] = gcnew Vector<int>(3, 5);
Console::WriteLine("viv: {0}", viv);
/*9*/ Vector<int>^ iv3 = gcnew Vector<int>(4,3);
Vector<int>^ iv4 = gcnew Vector<int>(4,3);
Vector<int>^ iv5 = gcnew Vector<int>(4,2);
Vector<int>^ iv6 = gcnew Vector<int>(5,6);
Console::WriteLine("iv3->Equals(iv4) is {0}", iv3->Equals(iv4));
Console::WriteLine("iv3->Equals(iv5) is {0}", iv3->Equals(iv5));
Console::WriteLine("iv3->Equals(iv6) is {0}", iv3->Equals(iv6));
}
为创建Vector的一个特定类型，可在尖括号中作为类型参数指定一个类型，如标号1、3所示。记住，int是值类System::Int32的同义词。（假如泛型有多个类型参数，需要以逗号把它们分隔开。）
在标号4、5中，定义了一个String^类型的Vector--一个引用类型；在标号6、7中，定义了一个DateTime类型的Vector--一个值类型；在标号8中，定义了一个Vector，而其的元素则为int类型的Vector；最后，用不同的length及Vector int值测试了Equals函数，插1是程序的输出：
插1：例11的输出
iv1: [0:0:0:0]
iv2: [2:2:2:2:2:2:2]
iv2: [2:55:2:-15:2:6:2]
sv1: [::]
sv2: [X:X:X:X:X]
sv2: [X:AB:X:XZZ:X]
dv1: [1/1/0001 12:00:00 AM:1/1/0001 12:00:00 AM]
dv2: [4/9/2005 3:30:40 PM:4/9/2005 3:30:40 PM:4/9/2005 3:30:40 PM]
dv2: [4/9/2005 3:30:41 PM:4/9/2005 3:30:42 PM:4/9/2005 3:30:43 PM]
viv: [::]
viv: [[1:1]:[2:2:2:2]:[5:5:5]]
iv3->Equals(iv4) is True
iv3->Equals(iv5) is False
iv3->Equals(iv6) is False
实际上，不但可以定义泛型类，还可以定义泛型接口与代理。
在前面，也指出了调用泛型成员函数时的一些限制，默认情况下，一个类型参数被限定为从System::Object继续来的任意类型，也就是任意CLI类型。对泛型或函数中的类型参数，假如使用where子句，还可以施加一个或多个限定条件，见例12。
例12：
generic <typename T>
where T : ValueType
public ref class Vector
{ ... };
value class C {};
/*1*/ Vector<int>^ iv;
/*2*/ Vector<String^>^ sv; //错误
/*3*/ Vector<DateTime>^ dv;
/*4*/ Vector<Vector<int>^>^ viv; //错误
/*5*/ Vector<C>^ cv;
在本例中，编译器将答应任意有着System::ValueType类型的类型参数，或从它继续来的类型被传递给泛型。假设此时又想定义某种特定的类型，如标号2和3所示，就会出错，因为String与Vector<int>不是值类型。同样地，假如换成例13中的限定条件，那么标号5就会被拒绝，因为值类型C没有实现接口System::IComparable，而System::Int32和System::DateTime却实现了。
例13：
generic <typename T>
where T : ValueType
public ref class Vector, IComparable
{ ... };
一旦编译器知道T可以被限定为比System::Object更明确的类型，就会答应调用这些类型中的成员函数，而这些类型则可包含一个基类型或任意顺序、任意数目的接口类型。