实例解析C++/CLI中的继承与枚举

2019-11-17 05:03:08

字体：大中小

来源：转载

供稿：网友

　　本文中，将要介绍与继续相关的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兼容了。）

　　标号4要求每个具体的交易类型都有公共的成员函数PostTransaction，在此的abstract函数修饰符等同于标准C++语法中的纯虚函数，一个抽象（abstract）函数必须显式地声明为virtual。

　　由于构造函数只应从继续类中调用，所以定义在标号5中的构造函数为protected，但它需做的事情却非常简单：设置新的交易类型为传递进来的类型，并通过调用公有属性DateTime::Now的get方法把时间日期戳设置为当前时间。有关传递进来的交易类型，应为一个值类型，而不答应为nullptr，由于CLI enum的强类型检查，编译器只答应同类型的枚举器被传递，或者同类型的实例，当然了，其也只能被同类型的枚举器所初始化。

　　通常地，构造函数必须尽快执行完，在此，为从测试程序中得出更多的结果，所以在程序中安置了一个延迟方法，因此时间日期戳在每次交易时都会改变，见标号6，构造函数会在初始化数据成员之前，随机休眠一段时间。由于每个程序至少都会有一个执行线程，而此线程的有关特征可通过sealed System::Threading::Thread引用类来设置或获取，Thread::Sleep函数则把当前执行线程挂起指定的毫秒数。

　　为使挂起的时间有所变化，使用了System::Random引用类来生成一系列的伪随机数，标号6中重载的Next函数则获取了一个"大于等于1000，小于2001"的数，也就是一至两秒钟的延迟。

更多内容请看C/C++应用实例专题，或

存款、取款、转账类

　　例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，那么函数永远也不可能被覆盖。

更多内容请看C/C++应用实例专题，或

　　标号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：

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

更多内容请看C/C++应用实例专题，或

枚举与继续

　　一个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操作符。

更多内容请看C/C++应用实例专题，或

数组与继续

　　每个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

更多内容请看C/C++应用实例专题，或

覆盖 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）。

更多内容请看C/C++应用实例专题，或

上一篇：C++数据结构学习:二叉树(4)

下一篇：C语言基础:插入排序法