C++快速入门 (十三) 继承和多态

最新推荐文章于 2024-01-31 09:14:42 发布
原创 最新推荐文章于 2024-01-31 09:14:42 发布 · 930 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文详细介绍了C++中的继承概念，包括基本语法、protected修饰符的使用、派生类如何显式调用基类构造函数以及多重继承。接着探讨了多态的本质，讲解了虚函数、纯虚函数、虚继承和动态绑定的原理。同时，讨论了动态绑定对象切割的问题，如切割现象、值类型形参和容器与数组的影响。

一，继承

(1). 继承的基本语法
继承是面向对象的基本特征之一。简单的继承示例如下：
class   ExampleBase
{
private  :
      int  x;
public  :
    ExampleBase( ) : x(0)
    {
        cout <<   "ExampleBase 类构造函数"  << endl;
    }
      void  SetX (   int   n  )
    {
        x =   n  ;
    }
      int  GetNum()
    {
          return  x;
    }
};
class   Example  :   public   ExampleBase
{
private  :
      int  y;
public  :
    Example( ):y(10)
    {
        cout <<   "Example 类构造函数"  << endl;
    }
      int  GetNum()
    {
          return  y;
    }
};


int   _tmain  ( int   argc,   _TCHAR*   argv  [])
{
      Example  ex;
    cout << ex.GetNum() << endl;
      return  0;
};
// return:
// ExampleBase 类构造函数
// Example 类构造函数
// Example 类函数
// 10
总结：
  • 创建派生类实例时，构造函数调用从最底层基类开始直至当前类。清理对象时顺序相反。
  • 基类的访问修饰符对派生类依然有效。如 基类中的私有成员即使是派生类中依然无法访问。
  • 派生类中只要有和基类同名的函数，即便是签名不同（参数或返回值不同），对于派生类对象，基类的同名函数将会被隐藏（和重载不同）。
你可以在派生类中通过作用域操作符调用基类的函数
Base  ::GetNum();

(2). protected 修饰符
声明为 protected 的成员可以让从其派生的类访问。而在其他地方和声明为 private 一样外界无法访问（可参见下节示例）。

(3). 派生类中显式调用基类的构造函数
当基类中存在多个构造函数时，就有可能需要在派生类中调用指定的基类构造函数。方法如下：
class   ExampleBase
{
protected  :
      int  x;
public  :
    ExampleBase( ) : x(0)
    {
        cout <<   "ExampleBase 类无参数 构造函数"  << endl;
    }
    ExampleBase( int   n  ) : x(   n  )
    {
        cout <<   "ExampleBase 类有参数 构造函数"  << endl;
    }
      void  SetX (   int   n  )
    {
        cout <<   "ExampleBase 类函数"  << endl;
        x =   n  ;
    }
      int  GetNum()
    {
          return  x;
    }
};
class   Example  :   public   ExampleBase
{
private  :
      int  y;
public  :
      Example( ):y(10),ExampleBase (15)
    {
        cout <<   "Example 类构造函数"  << endl;
    }
      int  GetNum()
    {
        cout <<   "Example 类函数"  << endl;
          return  y;
    }
      int  SumXy()
    {
          return  x + y;
    }
};

(4). 多重继承
C++中允许多重继承，既 一个类可以有多个基类，
class   A
{
protected  :
      int  x;
public  :
    A(): x(1)
    {
            cout <<   "A 类构造函数"  << endl;
    }
};
class   B
{
protected  :
      int  y;
public  :
    B(): y(2)
    {
        cout <<   "B 类构造函数"  << endl;
    }
};
class   C
{
protected  :
      int  z;
public  :
    C(): z(3)
    {
        cout <<   "C 类构造函数"  << endl;
    }
};
class   Example  :   public A , public B, public C
{
public  :
    Example( )
    {
        cout <<   "Example 类构造函数"  << endl;
    }
      int  SumXyz()
    {
          return  x + y + z;
    }
};


int   _tmain  ( int   argc,   _TCHAR*   argv  [])
{
      Example  ex;
    cout << ex.SumXyz();
};
//return:
//A 类构造函数
//B 类构造函数
//C 类构造函数
//Example 类构造函数
//6
后边还会继续讨论多重继承。

二，多态

(1). 多态的基本理念
多态就是 可以用基类对象表示其派生类对象，在调用该对象上的函数时能正确调用派生类对象的相应函数（动态绑定）的一种能力。
典型的应用场景如： 某个函数的形参为基类类型（指针或引用），当调用时可以为其传入该基类的派生类并能正确调用。很显然一般的函数覆盖是实现不了动态绑定的，于是 C++引入了虚函数来完成动态绑定。

(2). 虚函数 virtual
C++中使用关键字 virtual 声明虚函数，
class   Base
{
public  :
      virtual void ShowInfo()
    {
        cout <<   "is Base class"  << endl;
    }
};
class   ExampleOne  :   public   Base
{
public  :
      void ShowInfo()
    {
        cout <<   "is ExampleOne class"  << endl;
    }
};
class   ExampleTwo  :   public   Base
{
public  :
      void  ShowInfo( int   x)
    {
        cout <<   "is ExampleTwo class"  << endl;
    }
};
int   _tmain  ( int   argc,   _TCHAR*   argv  [])
{
      Base *b = new ExampleOne ;
    b->ShowInfo();
      Base  *b2 =   new   ExampleTwo  ;
    b2->ShowInfo();
}
//return:
//is ExampleOne class
//is Base class
总结：
  • 只有虚函数才具有多态（动态绑定）性。
  • 只有派生类函数和基类中的虚函数签名完全相同时才会具有多态性，
  • 用于覆盖基类虚函数的派生类函数也可以声明为虚函数。
  • 析构函数也可以为多态的，所以一般的基类析构函数应为虚函数。
  • 构造函数或析构函数中调用虚函数时，将只会调用其类型上的版本。

顺便提一句。即便是已经实现了动态绑定，也可以用如下语法显式的指定应该调用哪个类的函数
b-> Base::ShowInfo();

(3). 纯虚函数
在虚函数后加 "= 0" 时，该虚函数就为纯虚函数。因为纯虚函数没有方法体自然就没法调用执行。这样的类是不完全的，所以 拥有纯虚函数的类会变成了抽象类（不能被实例化的类）。
class   Base
{
public  :
      virtual void ShowInfo() = 0;
};
当一个类继承自抽象类并且未覆盖其纯虚函数时，该类也会变成抽象类（显而易见）。

(4). 虚继承
当一个派生类间接继承多个相同基类时，该基类会在内存中有多个副本。
class   Base
{
public  :
      int  num;
};
class   MidOne  :   public   Base  { };
class   MidTwo  :   public   Base  { };
class   Example  :   public   MidOne  ,   public   MidTwo { };
int   _tmain  ( int   argc,   _TCHAR*   argv  [])
{
      Example  *ex =   new   Example  ;
    cout << ex->num;  
    // error C2385: 对“num”的访问不明确, 因为有多个 Base的副本
}
可以通过 继承时添加 修饰符 virtual ，使内存只存储一个该基类的副本。

(5). 动态绑定原理
当类中有虚函数时（动态绑定基础），会生成一个保存该类所有虚函数（包括继承来 未被覆盖的）地址的虚表（vtable），然后用一个指针（vptr）指向虚表，并将（大多数情况）该指针放在类的首地址。当将派生对象赋给基类对象时实际只是改变了基类对象的引用（指向派生类对象地址），这样就可以调用正确的虚函数，从而实现动态绑定。
class   Base
{
public  :
      virtual   void  ShowInfo()
    {
        cout <<   "is Base"  << endl;
    }
      virtual   void  Say()
    {
        cout <<   "is Base say"  << endl;
    }
};
class   Example  :   virtual   public   Base
{
public  :
      virtual   void  ShowInfo()
    {
        cout <<   "is Example"  << endl;
    }
};

typedef   void  (* py)();
int   _tmain  ( int   argc,   _TCHAR*   argv  [])
{
      Base  *b =   new   Example  ;
      void*   vptr  = (   void  *)*( unsigned   long*)b;
      unsigned   char  *p = ( unsigned   char  *)vptr;
    p +=   sizeof(   void  *) * 0;
      py  vtable = (   py  ) ( void  *)*( unsigned   long  *)p;
    vtable();
    p +=   sizeof(   void  *) * 1;
      py  vtable2 = (   py  ) ( void  *)*( unsigned   long  *)p;
    vtable2();
}
//return:
// is Example
// is Base say

三，动态绑定对象切割

(1). 切割
在某种情况下即便当前基类是一个指向派生类的引用（多态），也会将其转换为真正的基类，而派生类部分将被切掉。

(2). 值类型形参
当形参为值类型时，动态绑定类型将被切割，转换为纯基类类型。
class   Base
{
public  :
      virtual   void  ShowInfo()
    {
        cout <<   "is Base"  << endl;
    }
};
class   Example  :   virtual   public   Base
{
public  :
      virtual   void  ShowInfo()
    {
        cout <<   "is Example"  << endl;
    }
};
void  Test (   Base b  )
{
      b.ShowInfo();
}
int   _tmain  ( int   argc,   _TCHAR*   argv  [])
{
      Base *ex = new Example ;
    Test(*ex);
}
//return:
//is Base

(3). 容器和数组
当将动态绑定的类型存入容器（对象而非指针）时，也会被切割，转换为纯基类类型。
int   _tmain  ( int   argc,   _TCHAR*   argv  [])
{
      Base *ex = new Example ;
      Base  baseArray[3] = {};
      baseArray[0] = *ex;
    baseArray[0].ShowInfo();

      Base *ex2 = new Example ;
      Vector<   Base  > vr;
      vr.push_back(*ex2);
    vr[0].ShowInfo();
}
//return:
// is Base
// is Base




-

<原创文章 转载请注明出处 http://blog.csdn.net/meiwm 谢谢>


作者：meiwm
出处： http://blog.csdn.net/meiwm
本文为原创，本文版权归作者所有。欢迎转载，但请务必保留此段声明，且在文章页面明显位置给出原文连接，谢谢合作。

-


c++快速入门
lijianhua003的博客
07-21 1838
c++其实就比c多了一点内容，如：类，继承，多态..面向对象的内容，如果你学习过C语言，学C++就非常简单，本文章写的比较简单，适合快速入门
C++快速入门 (一) Hello C++
meiwm的专栏
12-24 1867
序 这一系列文章是学习C++时的笔记整理而来, 当时主要参阅的是 《C++ Primer》,《Exceptional C++》《C++ Common Knowledge: Essential Intermediate Programming 》这几本书，推荐阅读。其中《C++ Primer》有条件的尽量看英文版，中文版的翻译个人感觉很绕。 本系列文章主要是对C++语法介绍，还有一些涉及底层
C++之继承与多态
weixin_30952103的博客
03-28 286
在程序设计领域，一个广泛认可的定义是“一种将不同的特殊行为和单个泛化记号相关联的能力”。和纯粹的面向对象程序设计语言不同，C++中的多态有着更广泛的含义。除了常见的通过类继承和虚函数机制生效于运行期的动态多态（dynamic polymorphism）外，带变量的宏，模板，函数重载，运算符重载，拷贝构造等也允许将不同的特殊行为和单个泛化记号相关联，由于这种关联处理于编译期而非运行期，因此被称为静态...
C++ 继承和多态
鄭高兴
12-30 1600
(1) 继承是C++源生支持的一种语法特性，是C++面向对象的一种表现(2) 继承特性可以让派生类“瞬间”拥有基类的所有（当然还得考虑权限）属性和方法(3) 继承本质上是为了代码复用(4) 类在C++编译器的内部可以理解为结构体，派生类是由基类成员叠加派生类新成员得到的父类的public成员 在子类中是public的父类的protected成员 在子类中是protected的父类的private成员 在子类中是private的，权限进一步降低，只能通过父类的public方法间接访问。
【C++】多态
℉f的博客
01-31 2167
涉及多态底层原理剖析，万字详解，助你攻克C++多态。
vs2012 MSDN帮助文档离线包 下载安装方法
热门推荐
meiwm的专栏
11-19 2万+
vs2012安装文件 自带的 MSDN帮助文档不全, 需要自己手动添加需要的离线文档包, 具体方法如下 1. 打开 vs2012  2. 按 ctrl + alt + F1  打开帮助文档管理器 3. 在 “安装源” 文字 下方 选 联机 , 在下方输入相关帮助文档的关键字, 点搜索（放大镜图标）,  4. 在下方出现的内容中点添加，并点击右下角的更新即可 界面如下
C++快速入门 (十) 创建类
meiwm的专栏
02-05 1842
一，类的定义 (1). 什么是类 类是包含某种对象特性的集合，可以通过类来创建对象。如人(类) --> 具体的某个人(对象)。可以看些面向对象的文章。这里就不多阐述了。 (2). 创建类 和 类成员 使用关键字class 创建类。 class 类型 {    }; 类可以包含，一般成员 和 函数成员，如下面的 Base class
C++快速入门 (八) 函数运行原理
meiwm的专栏
01-20 1650
一 目标文件 (1). 编译器都做了什么 从源代码到可执行文件，基本上是顺序通过以下几步完成 预处理 -- 主要处理 以#开头的预编译指令，及删除注释等编译 -- 将语法翻译成汇编语句汇编编译 -- 将汇编语句变成机器码，转换后的文件叫 目标文件，一般后缀为 .obj（vc编译器） 或 .o（gcc等其他编译器）链接 -- 为当前目标文件中 调用其他文件变量或函数 的地方
C++快速入门 (二) 变量和运算符
meiwm的专栏
12-25 1358
一 变量 (1). 声明一个变量 要声明一个变量非常简单 类型 变量名 = 变量值; 如: int x = 10; 也可以声明时不指定变量值 类型 变量名; 如: int x;   当编译器编译到这样的未声明初始值的变量时，有可能会为其进行隐式的初始化（按类型）,而默认的初始化值根据变量声明的位置不同其值也可能不同 当变量声明于
C++快速入门 (十六) 预编译处理命令
meiwm的专栏
03-01 1200
一 宏 (1). 宏的用途 C++中可以使用预处理命令创建宏。而宏的主要用途有， 宏替换条件编译 (2). 宏替换 宏替换是指将代码中的字符，预处理时替换为指定字符串。 C++中使用预处理命令 #define 定义宏替换。其语法为： #define   #define () C++中的宏替换是 将引用宏名的地方直接替换为其后的字符串，而
C++快速入门 (三) 常量, 字面值常量 及作用域
meiwm的专栏
12-26 1001
一 常量 (1). 声明常量 C++ 使用关键字 coust 声明常量 const 变量类型 变量名 = 变量值 如： const int x = 10; (2). 声明和使用全局常量 使用关键字 extern const 来声明和使用全局常量 classA.cpp extern const int x = 101; -----
C++快速入门 (四) 引用 和 指针
meiwm的专栏
12-26 953
一. 引用  (1). 内存中变量的存储 前边说过 计算机管理内存时，会以字节为基本单位进行顺序线性格式化（x86保护模式下），这样每一字节的内存都会有一个独一无二的十六进制数字标识, 定义一个变量的过程 其底层就是将 变量的值写入某个数字标识符所代表的内存的过程。如 int a = 10; 变量名 a 实质上只是为了方便编程而由 编程语言机制 附加的功
C++快速入门 (五) 数组 和 字符串
meiwm的专栏
12-27 911
一. 数组 (1). 内存中对象的存储 C++环境下 向内存中存储对象 就像是 向弹夹里装子弹，压进去一个然后在压进去另一个，抓到哪个子弹装哪个，是无序的，而有时，我们需要有序的存储一组相同类型的对象，可以通过封装成某种结构体，也可以使用更简单（看上去是）的数组。 数组能实现有序的存储，是用了一个投机取巧的方法，就是将所有成员所需要的内存大小一起申请，然后一次“压”进内存
C++快速入门 (六) 函数
meiwm的专栏
12-28 878
一. 函数特性 (1). 函数的原型 一个典型的函数由，返回值 函数名 形参 实现代码组成，其中参数根据需要 可以是 0～ n 个 ，而除去实现的其余部分就叫 函数的原型 如 int Add(int x, int y) {   return (x+y); } 其中 粗体 部分就是函数的原型，当函数没有形参时，圆括号为空 或 在圆括号里填入关键字
C++快速入门 (十五) 模板
meiwm的专栏
02-25 872
一，模板和泛型 (1). 泛型编程 一般的函数只能对固定某一系列（基类及其派生类）类型进行操作。如 int Add(const int & t1, const int & t2) {     return t1 + t2 ; } 该函数只能应用于 int 类型。显然不太利于重用（顺便提一句，面向对象的终极目标就是重用最大化）。如果写代码时可以使
C++快速入门 (十四) 结构和联合
meiwm的专栏
02-25 840
一，结构 struct (1). 结构与类的异同 在C++中除了 结构struct 默认的访问权限为 公有，而 类class 默认的访问权限为私有 外没有任何区别。但一般的 只用结构包含一些简单的数据类型。 (2). 位域 位域就是将成员类型按位存储。如 struct DateTime {     int   a:12;     in
C++快速入门 (十一) 类的其他内容
meiwm的专栏
02-09 742
一，类的静态成员及友元 (1). 静态成员 由前面的介绍知道，一般的类成员只有实例化（后的对象名）才能访问，可以简单理解为 一般的类成员属于类的实例。而使用 关键字static 修饰的类成员可以通过类名直接访问。 class Example { private :     static int sum; public :     void ShowSum()
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值