科技行者

行者学院 转型私董会 科技行者专题报道 网红大战科技行者

知识库

知识库 安全导航

至顶网软件频道基础软件实例解析C++/CLI中的继承与枚举

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

  • 扫一扫
    分享文章到微信

  • 扫一扫
    关注官方公众号
    至顶头条

本文中,将要介绍与继承相关的C++/CLI主题,并以现实生活中银行交易的三种形式:存款、取款、转账,来说明类的继承体系,且以一种新的枚举形式来实现。

作者:谢启东编译 来源:天极开发 2007年11月12日

关键字:

  • 评论
  • 分享微博
  • 分享邮件
覆盖 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)。

查看本文来源

    • 评论
    • 分享微博
    • 分享邮件
    邮件订阅

    如果您非常迫切的想了解IT领域最新产品与技术信息,那么订阅至顶网技术邮件将是您的最佳途径之一。

    重磅专题
    往期文章
    最新文章