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

来源：

---

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