本文详细解释了面向对象编程中的继承概念，包括基类和派生类的定义、成员访问权限、构造函数与析构函数的调用规则，以及菱形继承和菱形虚拟继承的原理。同时讨论了继承与组合的区别，指出继承的高耦合性和组合的黑箱复用在设计中的应用。
继承是面向对象的程序使代码可以复用的重要手段，它允许程序员在保持原有类特性的基础上进行扩展、增加功能。被继承的原有类称为基类（或父类），继承基类而产生的新的类，称为派生类（或子类）。类似于函数的复用，继承是类的复用。
class Person
{
public:
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << _age << endl;
}
//protected:
private:
string _name = "peter"; // 姓名
int _age = 18; // 年龄
};
// 继承后，父类的Person的成员都会变成子类的一部分。
//这里Student和Teacher复用了Person的成员
class Student : public Person
{
public:
void func()
{
// 父类私有成员，子类用不了(无论什么方式继承)
//cout << "name:" << _name << endl;
//cout << "age:" << _age << endl;
}
protected:
int _stuid; // 学号
};
class Teacher : public Person
{
protected:
int _jobid; // 工号
};
int main()
{
Student s;
Teacher t;
s.Print();
t.Print();
return 0;
} 本篇博客总结了继承的相关用法，旨在解读继承的常见问题和背后的思想。
目录
一、继承的定义
继承定义的语法格式为：
派生类 + 指定的继承方式 + 基类
其中，继承方式与访问限定符有关。
【Tips】
- 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员虽然是被继承到了派生类对象中，但语法上限制了派生类对象不管在类里面还是类外面都不能去访问它；
- 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected（其实保护成员限定符是因继承而出现的）；
- 基类除私有成员的其他成员在子类的访问方式：public > protected > private；
- 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过，最好显示的写出继承方式；
- 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡 使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。
二、基类和派生类对象的赋值转换
【Tips】
- 派生类对象可以赋值给基类的对象 / 基类的指针 / 基类的引用（这里有个形象的说法叫切片或者切割，寓意把派生类中父类那部分切来赋值过去）；
- 基类的对象不能赋值给派生类对象（这是因为父未必有子的全部成员）；
- 但基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用（注意，必基类的指针必须是指向派生类对象，否则有安全隐患。基类如果是多态类型，可以使用RTTI(RunTime Type Information)的dynamic_cast来进行识别后进行安全转换）。
class Person
{
protected :
string _name; // 姓名
string _sex; // 性别
int _age; // 年龄
};
class Student : public Person
{
public :
int _No ; // 学号
};
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; // 姓名
string _sex; // 性别
int _age; // 年龄
};
class Student : public Person
{
public :
int _No ; // 学号
};
int main()
{
int i = 0;
double d = i;//强制类型转换
Person p;
Student s;
p = s;//也存在类似强转的赋值兼容转换（切割、切片），不会产生临时变量
//一个子类对象相当于一个特殊的父类对象
//将子类的全部变量切割后，部分赋给父类
//s=p;//但父不能赋给子，这是因为父未必有子的全部成员
}class Person
{
protected :
string _name; // 姓名
string _sex; // 性别
int _age; // 年龄
};
class Student : public Person
{
public :
int _No ; // 学号
};
//证明切片存在：
int main()
{
int i = 0;
//double& d = i; //不可用，存在具有常性的临时变量，涉及权限放大
const double& d = i; //可用，权限平移
Student s;
Person p = s; //无须添加const
Person& rp = s; //无须添加const
//故没有临时变量产生，非强制类型转换
}
//向上转换（子赋给父）是可用的
//子类对象可转换为父类的对象、引用、指针
三、继承中的作用域
【Tips】
- 在一个继承体系中，基类和派生类都有独立的作用域；
- 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏或重定义（在子类成员函数中，可以使用 基类::基类成员 显示访问）；
- 对于构成成员函数的隐藏，只需要函数名相同就构成隐藏；
- 在实际中在继承体系里面最好不要定义同名的成员。
class Person
{
public:
void fun()
{
cout << "Person::func()" << endl;
}
protected:
string _name = "小林"; // 姓名
int _num = 111; // 身份证号
};
// 隐藏/重定义：子类和父类有同名成员，子类的成员隐藏了父类的成员
class Student : public Person
{
public:
void fun()
{
cout << "Student::func()" << endl;
}
void Print()
{
cout << " 姓名:" << _name << endl;
cout << _num << endl;
cout << Person::_num << endl;
}
protected:
int _num = 999; // 学号。与父类的身份证号重名了
};
int main()
{
Student s;
s.Print();//999，
//就近原则：局部域 > 成员 > 继承的父类 > 全局域，
//编译器只要在一个地方找到了目标就不会再前往下个地方
s.fun();
s.Person::fun();
//Q：两个fun构成什么关系？
// a、隐藏/重定义 b、重载 c、重写/覆盖 d、编译报错
//A：a (父子类域中，成员函数名相同就构成隐藏)
return 0;
}四、派生类的默认成员函数
【Tips】
- 派生类的构造函数必须调用基类的构造函数初始化派生类中基类的那一部分成员。如果基类没有默认的构造函数，就必须在派生类的构造函数的初始化列表阶段显示调用。
- 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类成员的拷贝初始化；
- 派生类的operator=必须要调用基类的operator=完成基类的复制；
- 派生类的析构函数会在被调用完成后，自动调用基类的析构函数清理其中的基类成员（这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序）；
- 派生类对象初始化先调用基类构造再调派生类构造；
- 派生类对象析构清理先调用派生类析构再调基类的析构。
- 因为在一些场景下，析构函数需要构成重写（重写的条件之一是函数名相同），编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加virtual的情况下（多态），子类析构函数会和父类析构函数构成隐藏关系。
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()
{
cout << "~Person()" << endl;
delete _pstr;
}
Person& operator=(const Person& p)
{
cout << "Person& operator=(const Person& p)" << endl;
if (this != &p)
{
_name = p._name;
}
return *this;
}
protected:
string _name;
string* _pstr = new string("111111");
};
class Student : public Person
{
public:
//调用构造的顺序：先父后子
Student(const char* name="zhangsan",int id=0)
:Person(name)
,_id(0)
{}
Student(const Student& s)
:Person(s)//显示地调用拷贝构造
,_id(s._id)
{}
~Student()
{
//Person::~Person();//显示调用无法保证先子后父
// 由于后面多态的原因，析构函数的函数名被
// 特殊处理了，统一处理成destructor
// 显示调用父类析构，无法保证先子后父
// 所以子类析构函数完成就自动调用父类析构，这样就保证了先子后父的析构顺序
cout << *_pstr << endl;
delete _pstr;
}
Student& operator=(const const Student& s)
{
if (this != &s)
{
Person::operator=(s);
_id = s._id;
}
return *this;
}
protected:
int _id;
};
int main()
{
Student s1;
Student s2(s1);
Student s3("lisi", 1);
s1 = s3;
}
五、其他细节
（一） 继承与友元
友元关系不能继承，也就是说，基类友元不能访问子类私有和保护成员
class Person
{
public:
friend void Display(const Person& p, const Student& s);
protected:
string _name; // 姓名
};
class Student : public Person
{
protected:
int _stuNum; // 学号
};
void Display(const Person& p, const Student& s)
{
cout << p._name << endl;
cout << s._stuNum << endl;
}
void main()
{
Person p;
Student s;
//Display(p, s); //基类友元不能访问子类私有和保护成员
}
（二） 继承与静态成员
如果基类中定义了一个static静态成员，那么整个继承体系里面只有一个这样的成员，无论派生出多少个子类，都只有一个static成员实例。
class Person
{
public :
Person () {++ _count ;} //每调用构造一次， _count自增1
protected :
string _name ; // 姓名
public :
static int _count; // 统计人的个数。
};
int Person :: _count = 0;
class Student : public Person
{
protected :
int _stuNum ; // 学号
};
class Graduate : public Student
{
protected :
string _seminarCourse ; // 研究科目
};
int main()
{
Person p;
Student s;
Graduate g;
cout << Person::_count << endl; //3
cout << &p._name << endl; //000000D06E16F4D8
cout << &s._name << endl; //000000D06E16F518
cout << &p._count<< endl; //00007FF708CA2440
cout << &s._count << endl; //00007FF708CA2440
cout << &Person::_count << endl; //00007FF708CA2440
cout << &Student::_count << endl; //00007FF708CA2440
return 0;
}
（三）菱形继承和菱形虚拟继承 *
菱形继承是多继承的一种特殊情况。菱形继承有数据冗余和二义性的问题。如下图中，在Assistant的对象中Person成员会有两份。
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 = "peter";
// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
a.Student::_name = "xxx";
a.Teacher::_name = "yyy";
}实践当中可以用多继承，但务必不用菱形继承。数据冗余和二义性可以通过虚继承来解决，如上面的继承关系，在Student和Teacher的继承Person时使用虚拟继承，即可解决问题。但需要注意的是，虚拟继承不要在其他地方去使用。
class Person
{
public :
string _name ; // 姓名
};
class Student : virtual public Person
{
protected :
int _num ; //学号
};
class Teacher : virtual public Person
{
protected :
int _id ; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected :
string _majorCourse ; // 主修课程
};
int main()
{
Assistant a ;
a._name = "peter";
}
虚继承相比普通继承，解决了数据冗余（虽然并不意味着空间一定被节省了）。拿菱形继承来说，普通继承在每次继承后都会将父类拷贝一份跟子类存在一起，而虚继承将多个继承的子类和一个父类存在同一个空间中，通过偏移量（存在虚基表中）来定位相应的数据。
class A
{
public:
int _a;
};
class B : virtual public A
{
public:
int _b;
};
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;
d._a = 0;
D d1;
return 0;
}
class A
{
public:
int _a;
};
class B : virtual public A
{
public:
int _b;
};
class C : virtual public A
{
public:
int _c;
};
class D : public B, public C
{
public:
int _d;
};
int main()
{
D d;
d._a = 1;
B b;
b._a = 2;
b._b = 3;
B* ptr = &b;
ptr->_a++;
ptr = &d;
ptr->_a++;
return 0;
}
多继承可以算是C++语法复杂的一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，相关的底层实现相当复杂。所以，一般不建议使用多继承，且一定不要使用菱形继承，否则在复杂度及性能上都有问题。 多继承也可以认为是C++的缺陷之一，很多后来的OO（如Java语言）都没有多继承。
（四） 继承与组合 *
class C
{
//....
};
// 继承
class D : public C
{};
// 组合
class E
{
private:
C _cc;
};继承是白箱（内部细节可见）复用，组合是黑箱（内部细节不可见）复用，继承与父类的耦合度相比组合来说更高，父类的内部变化可能直接影响继承子类，但这对组合的影响很小。组合类之间没有很强的依赖关系，耦合度低。有助于保持每个类被封装，代码维护性更好。
public继承是is-a的关系（例如，植物-花 人-学生...），组合是has-a的关系（例如，车-轮胎...）。它们没有优劣之分，各自有各自适配的情景。
// Car和BMW Car和Benz构成is-a的关系
class Car{
protected:
string _colour = "白色"; // 颜色
string _num = "陕ABIT00"; // 车牌号
};
class BMW : public Car{
public:
void Drive() {cout << "好开-操控" << endl;}
};
class Benz : public Car{
public:
void Drive() {cout << "好坐-舒适" << endl;}
};
// Tire和Car构成has-a的关系
class Tire{
protected:
string _brand = "Michelin"; // 品牌
size_t _size = 17; // 尺寸
};
class Car{
protected:
string _colour = "白色"; // 颜色
string _num = "陕ABIT00"; // 车牌号
Tire _t; // 轮胎
}; 补、相关面试题
1、
2、什么是菱形继承？菱形继承的问题是什么？
3、什么是菱形虚拟继承？它是如何解决数据冗余和二义性的？
4、继承和组合的区别？什么时候用继承？什么时候用组合？
扫一扫
1672
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
