文章目录

• • 一、继承概念及定义
  • 二、赋值转换——切片
  • 三、继承的作用域——隐藏
  • 四、派生类的默认成员函数
  • 五、继承与友元
  • 六、继承与静态成员
  • 七、菱形继承及菱形虚拟继承
  • 八、继承与组合
  • 九、结语

一、继承概念及定义

概念

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类 。而以前我们接触的复用都是函数复用，继承是类设计层次的复用。

比如对于一些类的共有属性提取出来，以供复用：

通过代码观察：

class Person
{
public:void Print(){cout << "name:" << _name << endl;cout << "age:" << _age << endl;}
protected:string _name = "HWC"; int _age = 18; 
};// Student和Teacher复用了Person的成员
class Student : public Person
{
protected://Person是父类，也称作基类。Student是子类，也称作派生类。int _stuid; 
};
class Teacher : public Person
{
protected:int _jobid; 
};
int main()
{Student s;Teacher t;s.Print();t.Print();return 0;
}

可以看到，父类的成员子类都可以使用。

定义

下面我们看到Person是父类，也称作基类。Student是子类，也称作派生类

继承方式和访问限定符

都有着public\private\protected：

在类和对象中，对于private和protected访问限定符并没有太大的区别，而对于继承来讲：private成员无法被子类继承下去

一块组合就是3*3=9种继承方式：

1.父类private成员在子类中无论以什么方式继承都是不可见的。这里的不可见是指父类的私有成员被继承到了子类对象中，但是语法上限制子类对象不管在类里面还是类外面都不能去访问它。 private类内可以访问类外部可以访问，不可见类内类外都不可

2.父类private成员在子类中是不能被访问，如果父类成员不想在类外直接被访问，但需要在子类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。

3.实际上面的表格我们进行一下总结会发现，父类的私有成员在子类都是不可见。父类的其他成员在子类的访问方式 == Min(成员在父类的访问限定符，继承方式)，public > protected > private

4.使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式

在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在子类的类里面使用，实际中、扩展维护性不强 。

总结来说就是：父类的private成员子类继承不可见，父类成员为protected和public,子类继承能够访问，尽量使用public继承。

二、赋值转换——切片

子类对象可以赋值给 父类的对象 / 父类的指针 / 父类的引用。这里有个形象的说法叫切片或者切割。寓意把子类中父类那部分切来赋值过去。并且这个过程中没有类型转换。没有类型转换也意味着不产生临时变量！，临时变量具有常性，所以不需要加上const

下面，我们来看一看代码是怎么体现赋值过程没有类型转换的：

class Person
{
protected:string _name; string _sex;  
public:int	_age;	 
};
class Student :public Person
{
public:int _No;
};
int main()
{Person p;Student s;//中间不存在类型转换p = s;//引用赋值Person& rp = s;rp._age = 1;//指针赋值Person* ptr = &s;ptr->_age = 2;return 0;
}

• 虽然是不同类型的，但是不会发生类型转换，而类型转换在中间会产生临时变量，而临时变量具有常性，必须加const，而对于父类和子类的赋值可以不加const!

• 赋值转换也称为向上转换，子类可以给父类的对象，指针、引用。而向下装换是不行的：父类对象不能赋值给子类对象，子类有的成员而父类没有，缺少的部分怎么去给

• 这里先简单了解一下：父类的指针可以通过强制类型转换赋值给子类的指针。但是必须是父类的指针是指向子类对象时才是安全的。这里父类如果是多态类型，可以使用RTTI(Run-Time Type Information)的dynamic_cast 来进行识别后进行安全转换。

void Test()
{Student sobj;// 1.子类对象可以赋值给父类对象/指针/引用Person pobj = sobj;Person* pp = &sobj;Person& rp = sobj;//2。父类对象不能赋值给子类对象//sobj = pobj;// 3.父类的指针可以通过强制类型转换赋值给子类的指针pp = &sobj;Student * ps1 = (Student*)pp; // 这种情况转换时可以的。ps1->_No = 10;pp = &pobj;Student* ps2 = (Student*)pp; // 这种情况转换时虽然可以，但是会存在越界访问的问题ps2->_No = 10;
}

三、继承的作用域——隐藏

• 在继承体系中基类和派生类都有独立的作用域。而如果子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用基类::基类成员显示访问）
• 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
• 注意在实际中在继承体系里面最好不要定义同名的成员。

class Person
{
protected:string _name = "HWC"; int _num = 10086; 
};
class Student : public Person
{
public:void Print(){cout << " 姓名:" << _name << endl;cout << " 身份证号:" << Person::_num << endl;cout << " 学号:" << _num << endl;}
protected:int _num = 666; 
};
int main()
{Student s1;s1.Print();return 0;
}

_num默认访问就近原则，访问自己的，如果想访问父类的成员，就直接指定作用域Person::_num。

经典题目：

class A
{
public:void fun(){cout << "A::func()" << endl;}
};class B :public A
{
public:void fun(int i){cout << "B::func(int i)->" << i << endl;}
};void Test()
{B b;b.fun(10);//传入参数
}

两个fun()是什么关系？重载？重写？重定义、隐藏？编译报错？？？？

看到函数名相同，参数不同，有人会认为是函数重载，但是函数重载要求要在同一作用域！所以不是重载。所以答案是隐藏。

class A
{
public:void fun(){cout << "A::func()" << endl;}
};class B :public A
{
public:void fun(int i){cout << "B::func(int i)->" << i << endl;}
};void Test1()
{B b;b.fun();//没有传入参数
}

此时编译会报错，同时函数还是构成隐藏，隐藏了父类的fun函数，此时子类需要传参，如果想访问，要加上作用域，即b.A::fun()

对于成员函数，只要父类和子类的同名成员函数，函数名相同就构成了隐藏。

四、派生类的默认成员函数

“默认”的意思就是指我们不写，编译器会变我们自动生成一个。那么在派生类中，这几个成员函数是如何生成的呢?

对于普通类成员，默认生成的四个成员函数（构造、析构、拷贝、赋值）：

1.内置类型：构造和析构——内置类型不处理，拷贝赋值——内置类型浅拷贝/值拷贝

2.自定义类型：构造和析构——自定义类型调用对应的构造函数和析构函数，拷贝赋值——自定义类型调用对应的拷贝或者赋值

对于派生类成员，在普通类的基础之上还有一个基类：去调用基类所对应的成员函数完成初始化/清理/拷贝，其他和普通类一样

下面，一起来看一看把：

对于构造函数

class Person
{
public:Person(const char* name="HWC"): _name(name){cout << "Person()" << endl;}Person(const Person& p): _name(p._name){cout << "Person(const Person& p)" << endl;}Person& operator=(const Person& p){cout << "Person operator=(const Person& p)" << endl;if (this != &p)_name = p._name;return *this;}~Person(){cout << "~Person()" << endl;}
protected:string _name; 
};
class Student : public Person
{
public:protected:int _num; 
};int main()
{Student s1;return 0;
}

通过运行结果我们可以知道：当我们没有写默认生成的子类的构造和析构时会由父类继承下来，会调用父类的默认构造和析构。而对于子类，与类和对象是一样的，内置类型进行值拷贝，自定义类型会调用自己的默认构造和析构。

而如果父类没有默认构造函数，此时我们就需要去子类提供构造函数，但是父类成员不能在子类通过初始化列表进行初始化：

注意：在初始化列表中必须得去调用父类的构造函数，这是规定死的。可以理解为父类调父类，子类调子类。

对于拷贝构造和赋值

此时我们不写默认生成的子类的拷贝构造和赋值运算符重载：父类的部分调用父类的默认拷贝构造和重载赋值，内置类型并不处理。

简单总结来说就是：父类成员调用父类本身的来处理，自己的成员跟类和对象是一样的。

• 对于默认构造函数，如果父类没有默认构造函数，就需要我们自己去写，显式调用构造

• 对于析构函数，根据具体实际的情况，如果子类有资源需要释放，那我们就需要自己手动实现析构。

• 对于拷贝构造和赋值重载，如果子类存在深拷贝的问题，这个时候就需要我们自己实现拷贝构造和赋值重载来实现深拷贝了。

父类成员调用父类对应的构造函数、拷贝构造、operator=析构函数来处理，子类的成员按照普通类来进行处理：深拷贝的进行深拷贝，浅拷贝的进行浅拷贝即可。

class Person
{
public:Person(const char* name): _name(name){cout << "Person()" << endl;}Person(const Person& p): _name(p._name){cout << "Person(const Person& p)" << endl;}Person& operator=(const Person& p){cout << "Person operator=(const Person& p)" << endl;if (this != &p)_name = p._name;return *this;}~Person(){cout << "~Person()" << endl;}
protected:string _name; 
};
//派生类中
//构造函数，父类成员调用父类的构造函数完成初始化
class Student : public Person
{
public:Student(const char*name,int num):Person(name),_num(num){}Student(const Student&s):Person(s),_num(s._num){}Student& operator=(const Student& s){if (this != &s){//显示调用父类的赋值Person::operator=(s);_num = s._num;}return *this;}protected:int _num; 
};int main()
{Student s1("张三",18);Student s2(s1);Student s3("李四",20);s1 = s3;return 0;
}

对于析构函数

析构函数比较特殊，如果直接去调用父类的析构：

直接报错，需要加上指定作用域，这是因为子类析构函数和父类析构函数构成隐藏关系，这是由于多态的关系需求，所有析构函数都会特殊处理成destructor(),下面进行指定作用域：

结果发现父类析构居然调用了两次，这说明了析构函数自己会调用，不需要我们显示的调用父类的析构函数，并且析构顺序是在子类析构完成之后在进行调用：

子类析构之后自动调用父类的析构函数，这样保证了先析构子类成员后析构父类的成员（自己写就没办法保证这个顺序了），所以子类析构函数不需要显示调用父类析构，会自动调用父类析构。

五、继承与友元

友元关系不能继承：

正确的做法：

六、继承与静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例 ，通过代码来观察一下把：

class Person
{
public:Person() { ++count; }
public:static int count;
};
int Person::count = 0;
class Student :public Person
{
protected:int _stuNum;
};
int main()
{Person p;Student s;p.count++;s.count++;cout << p.count << endl;cout << s.count << endl;cout << &p.count << endl;cout << &s.count << endl;return 0;
}

因为成员是在对象里面的，而静态成员是属于整个类的，属于类所有对象，同时属于所有派生类及对象。

我们在来看这一段代码的运行结果如何：

class Person
{
public:Person(){++count;}void Print(){cout << "Print()" << endl;}
public:string _name;static int count;
};
int Person::count = 0;
class Student :public Person
{
protected:int _stuNum;
};
int main()
{Person* ptr = nullptr;//cout << ptr->_name << endl;报错ptr->Print();cout << ptr->count << endl;//下面是等价的(*ptr).Print();cout<<(*ptr).count<

class Person
{
public:string _name;
};
class Student :public Person
{
protected:int _num;
};
class Teacher :public Person
{
protected:int _id;
};
class Assistant : public Student, public Teacher
{
protected:string _majorCourse; 
};
int main()
{//二义性Assistant a;a._name;解决了二义性，但是代码冗余a.Student::_name = "xxx";a.Teacher::_name = "yyy";return 0;
}

class A
{
public:int _a;
};
// class B : public A
class B : virtual public A
{
public:int _b;
};
// class C : public A
class C : virtual public A
{
public:int _c;
};
class D : public B, public C
{
public:int _d;
};
int main()
{D d;d.B::_a = 1;d.C::_a = 2;d._b = 3;d._c = 4;d._d = 5;return 0;
}

B*ptr = &d;
ptr->_a= 1;C*ptr = &d;
ptr->_a= 2;

// Car和BMW Car构成is-a的关系 class Car{protected:string _colour = "黑色";string _num = "粤A10000"; }; class BMW : public Car{public:void Drive() {cout << "is-a" << endl;}};// Tire和Car构成has-a的关系(轮胎和车)class Tire{protected:string _brand = "Michelin";  size_t _size = 17;};class Car{protected:string _colour = "黑色";string _num = "粤A10000"; Tire _t; };  

class A
{
private:A(){}
};class B:public A
{};
int main()
{B bb;return 0;
}

class A final
{
public:A(){}
};class B:public A
{};
int main()
{B bb;return 0;
}