|
测试程序
例6是测试交易类型的程序，它会创建一个具体交易类型的数组、遍历此数组、调用每个元素的PostTransaction函数。插1是某次执行后的输出，默认使用的是美国式的日期时间格式，即为，月、日、年、12小时制。
例6：
|
using namespace System;
int main()
{
array<Transaction^>^ list = gcnew array<Transaction^> {
gcnew Deposit(123.05, 12345),
gcnew Transfer(Decimal::Parse("1256.40"), 1111, 222),
gcnew Withdrawal(34.54, 232323),
gcnew Deposit(56.12, 14321)
};
for each (Transaction^ t in list)
{
t->PostTransaction();
}
} |
插1：例6某次执行后的输出
|
3/20/2005 12:36:16 AM -- Dep: 123.05 12345
3/20/2005 12:36:18 AM -- Xfer: 1256.40 222 1111
3/20/2005 12:36:19 AM -- With: 34.54 232323
3/20/2005 12:36:21 AM -- Dep: 56.12 14321 |
枚举与继承
一个CLI enum类型通常实现为一个值类型，且隐式继承自System::Enum。同样地，此类型的静态与实例成员，它们的基类System::ValueType与类型的基类System::Object，在CLI enum类型或此类型的任意实例中，都可以访问到。插2是例7的输出。
例7：
|
using namespace System;
public enum class Color {Black, White, Red};
public enum class TransactionType :
unsigned char {Deposit, Withdrawal, Transfer};
int main()
{
Color c = Color::White;
/*1*/ Console::WriteLine("Color::Red's name is >{0}<",
Enum::GetName(c.GetType(), Color::Red));
Console::Write("Color's members are:");
/*2*/ array<String^>^ names = Enum::GetNames(Type::GetType("Color"));
for each (String^ s in names)
{
Console::Write(" {0}", s);
}
Console::WriteLine();
/*3*/ Console::WriteLine("The type underlying Color is >{0}<",
Enum::GetUnderlyingType(Color::typeid));
/*4*/ Console::WriteLine("The type underlying TransactionType is >{0}<",
Enum::GetUnderlyingType(TransactionType::typeid));
} |
插2：例7的输出
|
Color::Red's name is >Red<
Color's members are: Black White Red
The type underlying Color is >System.Int32<
The type underlying TransactionType is >System.Byte< |
在标号1中，调用了Enum::GetName以找出特定enum类型枚举器的名称，第一个参数必须为System::Type类型，而获取它的一个方法就是通过对感兴趣的变量调用Object::GetType。
在标号2中，调用了Enum::GetNames以找出特定enum类型全部枚举器的名称，第一个参数必须为System::Type类型，而获取它的一个方法就是通过对感兴趣的变量（其以字符串形式表示的名称）调用Type::GetType。
在标号3及标号4中，调用了Enum::GetUnderlyingType以找出这两个CLI enum类型的底层类型，此处使用了一个更简单的方法用于找出类型的Type对象--新形式的typeid操作符。
数组与继承
每个CLI数组类型隐式继承自抽象引用类型System::Array，另外，数组的某些成员属性也继承自这个基类，所以当使用一个CLI数组时，便可访问到数组及对象的每个公有成员，见例8，插3是对应的输出。数组的成员函数在此是直接调用的。
例8：
|
using namespace System;
generic<typename T>
void Display1DArray(String^ text, array<T>^ ary)
{
if (ary == nullptr)
{
Console::WriteLine("nullptr passed");
return;
}
Console::Write("{0} {1}:", text, ary->Length);
for each (T element in ary)
{
Console::Write(" {0}", element);
}
Console::WriteLine();
}
int main()
{
array<int>^ numbers = gcnew array<int>{10, 75, 23, 18, 53, 18};
Display1DArray("numbers, original", numbers);
/*1*/ Console::WriteLine("IndexOf(18) {0}", Array::IndexOf(numbers, 18));
/*2*/ Console::WriteLine("LastIndexOf(18) {0}",
Array::LastIndexOf(numbers, 18));
/*3*/ Array::Sort(numbers);
Display1DArray("numbers, sorted ", numbers);
/*4*/ Console::WriteLine("BinarySearch(23) {0}",
Array::BinarySearch(numbers, 23));
/*5*/ Array::Reverse(numbers);
Display1DArray("numbers, reversed", numbers);
array<int>^ numbers2 = gcnew array<int>(4);
/*6*/ Array::Copy(numbers, numbers2, numbers2->Length);
Display1DArray("numbers2 ", numbers2);
/*7*/ Array::Clear(numbers, 1, 4);
Display1DArray("numbers, cleared ", numbers);
} |
插3：例8的输出
|
numbers, original 6: 10 75 23 18 53 18
IndexOf(18) 3
LastIndexOf(18) 5
numbers, sorted 6: 10 18 18 23 53 75
BinarySearch(23) 3
numbers, reversed 6: 75 53 23 18 18 10
numbers2 4: 75 53 23 18
numbers, cleared 6: 75 0 0 0 0 10 |
覆盖 VS 隐藏
在一个虚拟函数调用时，其实例的运行时类型决定了实际要调用的具体函数实现；在一个非虚拟函数调用时，实例的编译时类型才是最终的决定因素。
我们可从标准C++中得知，一个虚拟函数的实现，可被继承类中的相应实现所取代，而这个取代的过程被称为"覆盖"，其是通过使用override函数修饰符来完成的。鉴于一个虚拟函数的声明引入了一个新的函数，那么，通过提供一个此函数新的实现，一个覆盖函数声明可对继承来的虚拟函数进行专门的细化。需覆盖的函数必须显式声明为virtual。
当一个类重新声明了一个它继承来的函数名称时，由于出现了new函数修饰符，那么可以说这个类，隐藏了父类中的那个名称。
请看例9中的代码，留意变量的定义及在调用成员函数时的使用情况：
例9：
|
using namespace System;
public ref struct A
{
/*1a*/ void F0() { Console::WriteLine("A::F0"); }
/*1b*/ virtual void F1() { Console::WriteLine("A::F1"); }
/*1c*/ virtual void F2() { Console::WriteLine("A::F2"); }
//*1d*/ virtual void F3() { Console::WriteLine("A::F3"); }
};
public ref struct B : public A
{
/*2a*/ void F0() new { Console::WriteLine("B::F0"); }
/*2b*/ virtual void F1() override { Console::WriteLine("B::F1"); }
/*2c*/ virtual void F2() new { Console::WriteLine("B::F2"); }
private:
//*2d*/ void F3() new { Console::WriteLine("B::F3"); }
};
public ref struct C : public B
{
/*3a*/ void F0() new { Console::WriteLine("C::F0"); }
/*3b*/ virtual void F1x() override = B::F1 { Console::WriteLine("C::F1x"); }
/*3c*/ virtual void F2x() = B::F2 { Console::WriteLine("C::F2x"); }
//*3d*/ virtual void F3() { Console::WriteLine("C::F3"); }
}; |
假定有以下代码：
|
A^ a = gcnew A();
a->F0(); //调用 A::F0
a->F1(); //调用A::F1
a->F2(); //调用A::F2
a->F0()：A::F0是一个非虚拟函数，因此使用的是a的编译时类型（也就是A），导致A::F0被调用。
a->F1()：A::F1是一个虚拟函数，因此使用的是a的运行时类型（也就是A），导致A::F1被调用。
a->F2()：与A::F1类似，A::F2也是一个虚拟函数，因此使用的是a的运行时类型（也就是A），导致A::F2被调用。
B^ b = gcnew B();
b->F0(); //调用 B::F0
b->F1(); //调用B::F1
b->F2(); //调用B::F2
b->F0()：B::F0是一个非虚拟函数，因此使用的是b的编译时类型（也就是B），导致B::F0被调用。
b->F1()：B::F1覆盖了虚拟函数A::F1，因此使用的是b的运行时类型（也就是B），导致B::F1被调用。
b->F2()：B::F2（通过new）隐藏了虚拟函数A::F2，因此使用的b的是编译时类型（也就是B），导致B::F2被调用。这个隐藏函数同样也为virtual，允许继承自B的类覆盖这个带有new的函数。
a = b;
a->F0(); //调用 A::F0
a->F1(); //调用B::F1
a->F2(); //调用A::F2
a->F0()：A::F0是一个非虚拟函数，因此使用的是a的编译时类型（也就是A），导致A::F0被调用。
a->F1()：A::F1是一个虚拟函数，因此使用的是a的运行时类型（也就是B），导致B::F1被调用。
a->F2()：A::F2是一个虚拟函数，其被函数B::F2所隐藏，因此使用的是a的编译时类型（也就是A），导致A::F2被调用。（请记住，要先有后续的覆盖函数，才会有动态查询过程，而在本例中，是不存在的。）
C^ c = gcnew C();
c->F0(); //调用C::F0
c->F1(); //调用C::F1x
c->F2(); //调用 C::F2x
c->F0()：C::F0是一个非虚拟函数，因此使用的是c的编译时类型（也就是C），导致C::F0被调用。
c->F1()：C::F1x是一个虚拟函数，因此使用的是c的运行时类型（也就是C），但是，在C::F1x的情况中，使用了一个命名覆盖，也就是说，被覆盖的函数与覆盖函数有着不同的名称，这导致C::F1x被调用。
c->F2()：C::F2x覆盖了虚拟函数B::F2，因此使用的是c的运行时类型（也就是C），导致C::F2x被调用。（正如大家所见，在这个命名覆盖中，省略了显式覆盖修饰符。）
b = c;
b->F0(); //调用 B::F0
b->F1(); //调用C::F1x
b->F2(); //调用C::F2x
b->F0()：B::F0是一个非虚拟函数，因此使用的是b的编译时类型（也就是B），导致B::F0被调用。
b->F1()：B::F1覆盖了虚拟函数A::F1，因此使用的是b的运行时类型（也就是C），导致C::F1x被调用。
b->F2()：B::F2是一个虚拟函数，因此使用的是b的运行时类型（也就是C），导致C::F2x被调用。
a = c;
a->F0(); //调用A::F0
a->F1(); //调用C::F1x
a->F2(); //调用 A::F2
a->F0()：A::F0是一个非虚拟函数，因此使用的是a的编译时类型（也就是A），导致A::F0被调用。
a->F1()：A::F1是一个虚拟函数，因此使用的是a的运行时类型（也就是C），导致C::F1x被调用。
a->F2()：A::F2是一个虚拟函数，其被函数B::F2所隐藏，因此使用的是a的编译时类型（也就是A），导致A::F2被调用。（请记住，要先有后续的覆盖函数，才会有动态查询过程，而在这些例子中，是不存在的。） |
访问限定符
标准C++支持三种成员访问限定符：public、protected、private。为了适应程序集，C++/CLI添加了另外三种，完整地列在下表中：
·public意味着访问不受限制。
·protected意味着访问受限于包含的类，及任意继承自包含类的类型。
·private意味着访问受限于包含的类中。
·internal意味着访问受限于父类程序集。
·public protected（或protected public）意味着访问受限于父类程序集，及继承自包含类的类型--即使这些类型位于程序集之外。
·private protected（或protected private）意味着访问受限于父类程序集，及继承自包含类的类型--倘若这些类型是定义在这个程序集内的。
通过对父类施予更严格的访问限定符，成员也能具有更少的可访问性，另外，千万不要混淆成员名可访问性和类型可见性（类型可见性只能为public或private）。
（Alex 转自天极网）
|
