继承和派生
01 继承和派生的概念
继承:
- 在定义一个新的类 b 时,如果该类与某个已有的类 a 相似(指的是 b 拥有 a 的全部特点),那么就可以把 a 作为一个基类,而把b作为基类的一个派生类(也称子类)。
派生类:
- 派生类是通过对基类进行修改和扩充得到的,在派生类中,可以扩充新的成员变量和成员函数。
- 派生类拥有基类的全部成员函数和成员变量,不论是private、protected、public。需要注意的是:在派生类的各个成员函数中,不能访问基类的private成员。
02 需要继承机制的例子
程序猿种类有很多种,如 c/c++ 程序猿,java 程序猿,python 程序猿等等。那么我们要把程序猿设计成一个基类, 我们则需要抽出其特有的属性和方法。
所有程序猿的共同属性(成员变量):
- 姓名
- 性别
- 职位
所有的程序猿都有的共同方法(成员函数):
- 是否要加班?
- 是否有奖励?
而不同的程序猿,又有各自不同的属性和方法:
- c++ 程序猿:是否是音视频、网游领域
- java 程序猿:是否是微服务领域
- python 程序猿:是否是人工智能、大数据领域
03 派生类的写法
继承的格式如下:
class 派生类名:public 基类名 { };
程序猿 coder
基类:
class coder { public: bool isworkovertime(){} // 是否要加班 bool isreward(){} // 是否有奖励 void set(const string & name) // 设置免费精选名字大全 { m_name = name; } ... private: string m_name; // 姓名 string m_post; // 职位 int m_sex; // 性别 };
python 程序猿 pythoncoder
派生类:
class pythoncoder : public coder { public: bool isaifield(){} // 是否是人工智能领域 bool isbigdatafield(){} // 是否是大数据领域 };
04 派生类对象的内存空间
派生类对象的大小 = 基类对象成员变量的大小 + 派生类对象自己的成员变量的大小。在派生类对象中,包含着基类对象,而且基类对象的存储位置位于派生类对象新增的成员变量之前,相当于基类对象是头部。
class cbase { int a1; int a2; }; class cderived : public cbase { int a3; };
继承关系和复合关系
01 类之间的两种关系
继承的关系是「是」的关系:
- 基类 a,b 「是」基类 a 的派生类。
- 逻辑上要求:一个 b 对象也「是」一个 a 对象。
继承的关系是「有」的关系:
- c 类中「有」成员变量 i,i 成员变量是 d 类的,则 c 和 d 是复合关系。
- 逻辑上要求:d 对象是 c 对象的固有属性或组成部分。
02 继承关系的使用
假设已经存在了 man 类表示男人,后面需要些一个 women 类来表示女人。man 类和 women 类确实是有共同之处,那么就让 women 类继承 man 类,是否合适?
我们先想想继承的逻辑要求,假设 women 类继承 man 类后的逻辑就是:一个女人也是一个男人。很明显,这显然不成立!
所以,好的做法是概括男人和女人的共同特点,抽象出一个 human 类表示人,然后 man 和 woman 都继承 human 类。
03 复合关系的使用
假设要写一个小区养狗管理系统:
- 需要写一个「主人」类。
- 需要些一个「狗」类。
假定狗只有一个主人,但是一个主人可以最多有 10 条狗,应该如何设计和使用「主人」类 和「狗」类呢?我们先看看下面几个例子:
例子一:
- 为主人类设一个狗类的成员对象数组;
- 为狗类设一个主人类的成员对象。
class cdog; class cmaster // 主人类 { cdog dogs[10]; // 狗类的成员对象数组 }; class cdog // 狗类 { cmaster m; // 主人类的成员对象 };
例子一可以发现是:
- 主人类会构造 10 个狗对象
- 狗类会构造 1 个主人对象
相当于人中有狗,狗中有人:
这样是不好的,因为会产生循环不断的构造,主人类构造狗对象,狗类又构造主人对象….
例子二:
- 为狗类设一个主人类的成员对象;
- 为主人类设一个狗类的对象指针数组。
class cdog; class cmaster // 主人类 { cdog * pdogs[10]; // 狗类的对象指针数组 }; class cdog // 狗类 { cmaster m; // 主人类的成员对象 };
这样又变成狗中有人,人去指向「狗中有人」的狗,关系就会显得很错乱,如下图:
例子三:
- 为狗类设一个主人类的对象指针;
- 为主人类设一个狗类的对象数组。
class cdog; class cmaster // 主人类 { cdog dogs[10]; // 狗类的对象数组 }; class cdog // 狗类 { cmaster * pm; // 主人类的对象指针 };
这样就会变成,人中有狗,人里面的狗又会指向主人,虽然关系相对好了一点,但是同样还是会绕晕,效果如下图:
例子四:
- 为狗类设一个主人类的对象指针;
- 为主人类设一个狗类的对象指针数组。
class cdog; class cmaster // 主人类 { cdog * pdogs[10]; // 狗类的对象指针数组 }; class cdog // 狗类 { cmaster * pm; // 主人类的对象指针 };
这个是正确的例子,因为相当于人和主人是独立的,然后通过指针的作用,使得狗是可以指向一个主人,主人也可以同时指向属于自己的 10 个狗,这样会更灵活。
04 指针对象和对象的区别
如果不用指针对象,生成 a 对象的同时也会构造 b 对象。用指针就不会这样,效率和内存都是有好处的。
比如:
class car { engine engine; // 成员对象 wing * wing; // 成员指针对象 };
定义一辆汽车,所有的汽车都有 engine,但不一定都有 wing
这样对于没有 wing 的汽车,wing 只占一个指针,判断起来也很方便。
- 空间上讲,用指针可以节省空间,免于构造 b 对象,而是只在对象中开辟了一个指针,而不是开辟了一个对象 b 的大小。
- 效率上讲,使用指针适合复用。对象 b 不但 a 对象能访问,其他需要用它的对象也可以使用。
- 指针对象可以使用多态的特性,基类的指针可以指向派生链的任意一个派生类。
- 指针对象,需要用它的时候,才需要去实例化它,但是在不使用的时候,需要手动回收指针对象的资源。
派生类覆盖基类成员
01 覆盖
派生类(子类)可以定义一个和基类(父类)成员同名的成员,这叫「覆盖」。在派生类(子类)中访问这类成员时,默认的情况是访问派生类中定义的成员。要在派生类中访问由基类定义的同名成员时,要使用作用域符号::
。
下面看具体的例子:
// 基类 class father { public: int money; void func(); }; // 派生类 class son : public father // 继承 { public: int money; // 与基类同名成员变量 void func(); // 与基类同名成员函数 void myfunc(); }; void son::myfunc() { money = 100; // 引用的是派生类的money father::money = 100; // 引用的是基类的money func(); // 引用的是派生类的 father::func(); // 引用的是基类的 }
相当于 son 对象占用的存储空间:
类的保护成员
我们都知道基类的 public 成员,都是可以被派生类成员访问的,那么基类的 protected、private 成员,分别可以被派生类成员访问吗?带着这个问题,我们可以先看下面的栗子:
class father { public: int npublic; // 公有成员 protected: int nprotected; // 保护成员 private: int nprivate; // 私有成员 }; class son : public father { void func() { npublic = 1; // ok nprotected = 1; // error nprivate =1; // ok,访问从基类继承的protected成员 son a; a.nprotected = 1; // error,a不是当前对象 } }; int main() { father f; son s; f.npublic; // ok s.npublic; // ok f.nprotected; // error s.nprotected; // error f.nprivate; // error s.nprivate; // error }
基类的 protected、private 成员对于派生类成员的权限说明:
基类的 protected 成员 | 基类的 private 成员
—|—
派生类的成员函数可以访问当前对象的基类的保护成员| 不能被派生类成员访问
派生类的构造函数
通常在初始化派生类构造函数时,派生类构造函数是要实现初始化基类构造函数的。那么如何在派生类构造函数里初始化基类构造函数呢?
class bug { private : int nlegs; int ncolor; public: int ntype; bug (int legs, int color); void printbug (){ }; }; class flybug : public bug // flybug 是bug 的派生类 { int nwings; public: flybug( int legs,int color, int wings); }; bug::bug( int legs, int color) { nlegs = legs; ncolor = color; } // 错误的flybug 构造函数 flybug::flybug ( int legs,int color, int wings) { nlegs = legs; // 不能访问 ncolor = color; // 不能访问 ntype = 1; // ok nwings = wings; } // 正确的flybug 构造函数: flybug::flybug ( int legs, int color, int wings):bug( legs, color) { nwings = wings; } int main() { flybug fb ( 2,3,4); fb.printbug(); fb.ntype = 1; fb.nlegs = 2 ; // error. nlegs is private return 0; }
在上面代码例子中:
第24-30行的派生类构造函数初始化基类是错误的方式,因为基类的私有成员是无法被派生类访问的,也就无法初始化。
第33-36行代码是正确派生类构造函数初始化基类构造函数的方式,通过调用基类构造函数来初始化基类,在执行一个派生类的构造函数
之前,总是先执行基类的构造函数。
从上面的例子中我们也得知构造派生对象前,是先构造基类对象,那么在析构的时候依然依据“先构造,后初始化”的原则,所以派生类析构时,会先执行派生类析构函数,再执行基类析构函数。
如下栗子:
class base { public: int n; base(int i) : n(i) { cout << "base " << n << " constructed" << endl; } ~base() { cout << "base " << n << " destructed" << endl; } }; class derived : public base { public: derived(int i) : base(i) { cout << "derived constructed" << endl; } ~derived() { cout << "derived destructed" << endl; } }; int main() { derived obj(3); return 0; }
输出结果:
base 3 constructed derived constructed derived destructed base 3 destructed
继承的赋值兼容规则
01 public 继承
// 基类 class base {}; // 派生类 class derived : public base {}; base b; // 基类对象 derived d; // 派生类对象
- 派生类的对象可以赋值给基类对象
b = d;
- 派生类对象可以初始化基类引用
base & br = d;
- 派生类对象的地址可以赋值给基类指针
base * pb = & d;
==注意:如果派生方式是 private 或 protected,则上述三条不可行==
02 protected 和 private 继承
// 基类 class base {}; // 派生类 class derived : protected base {}; base b; // 基类对象 derived d; // 派生类对象
- protected 继承时,基类的 public 成员和 protected 成员成为派生类的 protected 成员;
- private 继承时,基类的 public 成员成为派生类的 private 成员,基类的 protected 成员成
为派生类的不可访问成员; - protected 和 private 继承不是「是」的关系。
所以派生方式是 private 或 protected,则是无法像 public 派生承方式一样把派生类对象赋值、引用、指针给基类对象。
03 基类与派生类的指针强制转换
public 派生方式的情况下,派生类对象的指针可以直接赋值给基类指针
base *ptrbase = & objderived;
- ptrbase 指向的是一个 derived 派生类(子类)的对象
- *ptrbase 可以看作一个 base 基类的对象,访问它的 public 成员直接通过 ptrbase 即可,但不能通过 ptrbase 访问 objderived 对象中属于 derived 派生类而不属于基类的成员。
通过强制指针类型转换,可以把 ptrbase 转换成 derived 类的指针
base * ptrbase = &objderived; derived *ptrderived = ( derived * ) ptrbase;
程序员要保证 ptrbase 指向的是一个 derived 类的对象,否则很容易会出错。
本文来自网络收集,不代表计算机技术网立场,如涉及侵权请联系管理员删除。
ctvol管理联系方式QQ:251552304
本文章地址:https://www.ctvol.com/c-cdevelopment/600503.html