实例理会C++/CLI中的担任与列举
副标题#e#
本文中，将要先容与担任相关的C++/CLI主题，并以现实糊口中银行生意业务的三种形式：存款、取款、转账，来说明类的担任体系，且以一种新的列举形式来实现。
列举器
请看例1中声明的范例，它存在于其自身的源文件中，并编译为一个只包括此范例的措施集：
例1：
public enum class TransactionType :
unsigned char {Deposit, Withdrawal, Transfer};
与想像的一样，列举器中的Deposit、Withdrawal、Transfer别离代表0、1、2的常量值，但有三个方面却让这个enum范例与尺度C++的enum范例（也就是"当地enum"）大不沟通。
·enum类只用于代替enum。这使TransactionType成为了一个CLI enum。（也答允enum布局，其与enum类等价。）
·此范例的可会见性为public，以使其可从父类措施集外可见。（在C++/CLI中，一个当地enum范例也能有一个会见限定符。）
·enum类有一个显式的根基范例限定符：在本例中为unsigned char。（在C++/CLI中，一个当地enum也能有一个根基范例。）默认环境下，根基范例为int。根基范例也能为bool或除wchar_t之外的任意整形。（假如指定bool为根基范例，列举器必需显式地举办初始化，因为没有默认的初始值。）
支持这个新语法的原因是CLI enum遵从CLS尺度，而当地enum却不遵从。
CLI enum与当地enum间最大的区别在于组成方法上，列举名的浸染范畴由它的父类enum范例来限定。别的，尺度C++中界说的整数晋升，并不合用于CLI enum。
与当地enum雷同，一个CLI enum也能被界说在一个类中，在这种环境下，就不答允利用会见限定符了，因为嵌套范例的可见性，已被其嵌入到的范例可见性所代替。
生意业务的抽象基类
生意业务范例的担任体系在基类Transaction中，默认从System::Object担任，见例2：
例2：
using namespace System;
using namespace System::Threading;
/*1*/
public ref class Transaction abstract
{
TransactionType typeOfTransaction;
/*2*/ DateTime dateTimeOfTransaction;
public:
/*3a*/ property TransactionType TypeOfTransaction
{
TransactionType get() { return typeOfTransaction; }
private:
void set(TransactionType value) { typeOfTransaction = value; }
}
/*3b*/ property DateTime DateTimeOfTransaction
{
DateTime get() { return dateTimeOfTransaction; }
private:
void set(DateTime value) { dateTimeOfTransaction = value; }
}
/*4*/ virtual void PostTransaction() abstract;
protected:
/*5*/ Transaction(TransactionType transType)
{
/*6*/ Thread::Sleep((gcnew Random)->Next(1000,2001));
/*7*/ TypeOfTransaction = transType;
/*8*/ DateTimeOfTransaction = DateTime::Now;
}
};
在标号1中，这个类被标为abstract（抽象类），这意味着它不能被直接实例化。（抽象不是一个要害字，仅仅在此上下文中作了保存。）这个abstract修饰词可用于界说一个抽象类，而无须显式地声明一个或多个成员函数为纯虚范例。
在类的私有数据成员部门，一个Transaction包括了一个生意业务范例及一个时间日期戳，两者都由界说在标号3a及3b中的属性来会见。在标号2中利用的CLI库值范例System::DateTime答允用一个即时变量显示出当天的日期与时间。请留意，两个属性是奈何拥有公有get要领与私有set要领的。（这是基于新的CLI尺度，而且此刻已与CLS兼容了。）
#p#副标题#e#
标号4要求每个详细的生意业务范例都有民众的成员函数PostTransaction，在此的abstract函数修饰符等同于尺度C++语法中的纯虚函数，一个抽象（abstract）函数必需显式地声明为virtual。
由于结构函数只应从担任类中挪用，所以界说在标号5中的结构函数为protected，但它需做的工作却很是简朴：配置新的生意业务范例为通报进来的范例，并通过挪用公有属性DateTime::Now的get要领把时间日期戳配置为当前时间。有关通报进来的生意业务范例，应为一个值范例，而不答允为nullptr，由于CLI enum的强范例查抄，编译器只答允同范例的列举器被通报，可能同范例的实例，虽然了，其也只能被同范例的列举器所初始化。
凡是地，结构函数必需尽快执行完，在此，为从测试措施中得出更多的功效，所以在措施中安放了一个延迟要领，因此时间日期戳在每次生意业务时城市改变，见标号6，结构函数会在初始化数据成员之前，随机休眠一段时间。由于每个措施至少城市有一个执行线程，而此线程的有关特征可通过sealed System::Threading::Thread引用类来配置或获取，Thread::Sleep函数则把当前执行线程挂起指定的毫秒数。
#p#分页标题#e#
为使挂起的时间有所变革，利用了System::Random引用类来生成一系列的伪随机数，标号6中重载的Next函数则获取了一个"大于便是1000，小于2001"的数，也就是一至两秒钟的延迟。
存款、取款、转账类
例3界说了存款类，为什么这个类为sealed呢？假如还没有当真思量过它是否足够"结实"以可作一个基类，那么照旧让它不行以担任吧。 例3：
using namespace System;
/*1*/
public ref class Deposit sealed : Transaction
{
/*2*/ Decimal amount;
int toAccount;
public:
/*3a*/ Deposit(double amount, int toAccount) :
Transaction(TransactionType::Deposit)
{
DepositAmount = Decimal(amount);
DepositToAccount = toAccount;
}
/*3b*/ Deposit(Decimal amount, int toAccount) :
Transaction(TransactionType::Deposit)
{
DepositAmount = amount;
DepositToAccount = toAccount;
}
property Decimal DepositAmount
{
Decimal get() { return amount; };
private:
void set(Decimal value) { amount = value; }
}
property int DepositToAccount
{
int get() { return toAccount; };
private:
void set(int value) { toAccount = value; }
}
/*4*/ void PostTransaction()
{
Console::WriteLine("{0} -- {1}", DateTimeOfTransaction, this);
}
virtual String^ ToString() override
{
/*5*/ return String::Format(" Dep: {0,10:0.00} {1,10}",DepositAmount, DepositToAccount);
}
};
CLI只支持单一担任，因此，值类和引用类只能有一个直接的基类，默认环境下为System::Object。在标号1中，Deposit直接担任自Transaction，请留意没有public会见限定符，CLI只支持公有（public）担任，所以在此也可写为": public Transaction"，但这是多余的。（对当地类而言，当担任的范例为布局struct时，默认为公有担任；当担任的范例为类class时，默认为私有担任。）
别忘了，CLI库支持一种很是适合金融计较的范例–System::Decimal，可在标号2顶用它来暗示存款额。
为了利便，提供了两个结构函数：一个接管暗示为Decimal的数额，而另一个接管暗示为double的数额。请留意，在两个结构函数的界说中，是奈何利用CLI enum浸染域符来会见列举器TransactionType中Deposit的。
为完成抽象基类，需提供标号4中的PostTransaction的实现，DateTime是一个值范例，因此当它的一个实例被通报进来时，它被装箱以匹配WriteLine所期望的Object^，而this表达式范例为Deposit^，其也担任自Object^。在这两种环境中，担任条剖析一直往下，直到抵达并挪用对应的ToString函数。
也能把函数PostTransaction声明为sealed，这样它就不能被包围了，然而，假如父类自己已经为sealed，那么函数永远也不行能被包围。
标号5中的名目指定符{0,10:0.00}，表白在10个打印位宽度中右对齐数额，并四舍五入到小数点后两位，且至少在小数点前有一位数。
Deposit范例直接依赖于Transaction与TransactionType范例，所以在Deposit的编译期间，必需确保可会见到这两者的措施集。可是，编译器大概会发出一个告诫，暗示TransactionType已经被引入了两次，一次是直接，而另一次是间接地通过Transaction，在此，可安详地忽略此告诫信息。
Withdrawal类界说在例4中，而Transfer类界说在例5中。
例4：
using namespace System;
public ref class Withdrawal sealed : Transaction
{
Decimal amount;
int fromAccount;
public:
Withdrawal(double amount, int fromAccount) : Transaction(TransactionType::Withdrawal)
{
WithdrawalAmount = Decimal(amount);
WithdrawalFromAccount = fromAccount;
}
Withdrawal(Decimal amount, int fromAccount) : Transaction(TransactionType::Withdrawal)
{
WithdrawalAmount = amount;
WithdrawalFromAccount = fromAccount;
}
property Decimal WithdrawalAmount
{
Decimal get() { return amount; };
private:
void set(Decimal value) { amount = value; };
}
property int WithdrawalFromAccount
{
int get() { return fromAccount; };
private:
void set(int value) { fromAccount = value; };
}
void PostTransaction()
{
Console::WriteLine("{0} -- {1}", DateTimeOfTransaction, this);
}
virtual String^ ToString() override
{
return String::Format("With: {0,10:0.00} {1,10}",
WithdrawalAmount, WithdrawalFromAccount);
}
};
例5：
#p#分页标题#e#
using namespace System;
public ref class Transfer sealed : Transaction
{
Decimal amount;
int fromAccount;
int toAccount;
public:
Transfer(double amount, int fromAccount, int toAccount): Transaction(TransactionType::Transfer)
{
TransferAmount = Decimal(amount);
TransferFromAccount = fromAccount;
TransferToAccount = toAccount;
}
Transfer(Decimal amount, int fromAccount, int toAccount): Transaction(TransactionType::Transfer)
{
TransferAmount = amount;
TransferFromAccount = fromAccount;
TransferToAccount = toAccount;
}
property Decimal TransferAmount
{
Decimal get() { return amount; };
private:
void set(Decimal value) { amount = value; };
}
property int TransferFromAccount
{
int get() { return fromAccount; };
private:
void set(int value) { fromAccount = value; };
}
property int TransferToAccount
{
int get() { return toAccount; };
private:
void set(int value) { toAccount = value; };
}
void Transfer::PostTransaction()
{
Console::WriteLine("{0} -- {1}", DateTimeOfTransaction, this);
}
virtual String^ ToString() override
{
return String::Format("Xfer: {0,10:0.00} {1,10} {2,10}",
TransferAmount, TransferToAccount, TransferFromAccount);
}
};
固然三个PostTransaction的实现是同样的，但在真实的生意业务处理惩罚系统中，这是不行能产生的。
测试措施
例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<
#p#分页标题#e#
在标号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"); }
};
假定有以下代码：
#p#分页标题#e#
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）。
