标题：[C++] 继承
@水墨不写bug
目录
正文开始：
（一）继承的概念
如何理解继承呢？其实可以类比我们之前的经历：我们之前在实现vector的时候，我们首先实现了push_back（），因为push_back（）是最基本的操作，并且实现起来简便。但是当我们继续往后实现insert的时候，会发现push_back()不就是在容器的最后insert吗？于是我们可以在push_back（）中直接复用insert，不必再实现push_back（）——这就是函数的复用。
继承是针对类设计的，所以可以理解为继承是对类的复用。但是，继承也有继承的语法规则。
什么样的类之间才能实现继承呢？浅显的理解是：如果有一些类，他们之间有属性上的“是”关系时，这些类一般可以体现继承：
比如：学生是一些人；老师是一些人——学生类和老师类可以是Person类的子类。
在继承关系中，如果我们实现
父类（基类）Person；
子类（派生类）：Student类和Teacher类
class Person
{
public:
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << _age << endl;
}
protected:
string _name = "peter"; // 姓名
int _age = 18; // 年龄
};
class Student : public Person
{
protected:
int _stuid; // 学号
};
class Teacher : public Person
{
protected:
int _jobid; // 工号
};
那么Person和Student；Person和Teacher都构成继承关系。可以理解：父类的成员能够是子类成员的公共需求：
一个Person类有成员 ID，name ，telphone 和其他成员函数，这些成员可以继承到派生类Student类和Teacher类中，继承允许我们在保持原有类特性的基础上进行扩展，是面向对象程序设计使代码可以复用的最重要的手段。
（二）继承语法、继承方式
其实，从上面的一个例子就可以看出继承的基本使用方式：
就上述的两个例子而言： 
需要注意的是：派生类名称和继承方式之间的分号不要忘记了。
对于不同的继承方式和访问限定符，派生类对象的访问权限是不同的：
| 类成员/继承方式 | public继承 | protected继承 | private继承 |
| 基类的public成员 | 派生类的public成员 | 派生类的protected 成员 | 派生类的private 成员 |
| 基类的protected 成员 | 派生类的protected 成员 | 派生类的protected 成员 | 派生类的private 成员 |
| 基类的private成 员 | 在派生类中不可见 | 在派生类中不可见 | 在派生类中不可 见 |
理解记忆：从最简单的开始：
1，基类的private成员在派生类中不可见。这里的不可见是基类的成员还是继承到了派生类对象中的，但是由于语法private的限制，派生类对象无论是在类里面还是类外面都无法访问基类的private成员；就像是你的父亲为了锻炼你，拒绝将家里的矿继承给你，尽管矿山属于你家，但是你无法拥有矿山的权限。
2，protected是在继承中特殊引入的访问限定符：如果基类成员需要在派生类中被访问，而不希望在类外被直接访问，需要将继承关系改为protected。特别的，对于protected继承，基类的public成员权限缩小，成为派生类的protected；基类的protected成员保持；基类的private成员保持。
3，public可以说是权限的平移，没有任何的缩小：基类产生的派生类，如果继承关系是public，则基类的成员在访问权限不变的情况下成为派生类的成员。
实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。
使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强
（三） 基类和派生类对象赋值转换
C++中，规定派生类对象可以赋值给基类对象；派生类的地址可以存储于基类的指针；基类可以是派生类的引用。但是反过来，基类不能给派生类赋值，........等等。因为派生类的一部分没有参与赋值，会发生未定义的行为：
class Person
{
protected:
string _name; // 姓名
string _telphone; // 性别
string _id; // 身份证号
};
class Student : public Person
{
public:
int _stuid; // 学号
};
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->_stuid = 10;
//基类指针指向基类对象
pp = &Pobj;
Student* ps2 = (Student*)pp; // 转换为派生类，这种情况转换时虽然可以，但是会存在越界访问的问题
ps2->_stuid = 10;
}（四）继承中的作用域与隐藏
继承是类的复用，类有自己的作用域。当然在继承体系中，基类和派生类都有独立的作用域。
在继承中，如果基类定义的一个函数，在派生类中也有定义一个同名函数（仅仅是同名），则会构成隐藏：
子类成员将屏蔽父类对同名成员直接访问，这就是隐藏，也叫重定义。（但是在子类成员函数中，仍然可以使用类作用限定符：：来显示访问基类成员）
需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。注意在实际中在继承体系里面最好不要定义同名的成员。
重名的成员变量：
// Student的_num和Person的_num构成隐藏关系
class Person
{
protected:
string _name = "zhangsan";
int _num = 123;
};
class Student : public Person
{
public:
void Print()
{
cout << " 姓名:" << _name << endl;
/*Person和Student的_num构成隐藏，如果直接访问，访问的是派生类内部的_num
如果想要访问Person的，需要手动指定作用域*/
cout << _num << endl;
cout << Person::_num << endl;
}
protected:
int _num = 789; // 学号
};
void Test()
{
Student s1;
s1.Print();
};重名的成员函数：
// B中的fun和A中的fun不是构成重载，因为不是在同一作用域
// B中的fun和A中的fun构成隐藏，成员函数满足函数名相同就构成隐藏。
class A
{
public:
void fun()
{
cout << "func()" << endl;
}
};
class B : public A
{
public:
void fun(int i)
{
cout << "func(int i)->" << i << endl;
}
};
void Test()
{
B b;
b.A::fun();
b.fun(10);
};（五）继承中派生类的默认成员函数
default 成员函数，“default ”意味着我们不写，编译器会为我们自动生成，class中，有如default member function：
在继承体系中，default成员函数会有不同的表现：
constructor：
派生类的构造函数必须调用基类的constructor来初始化基类那一部分的成员。如果基类没有默认的构造函数，则必须在派生类的构造函数的初始化列中显示调用。
派生类对象初始化，会先调用基类构造，再调用派生类构造。
对于多继承，拷贝构造根据继承的顺序依次进行，析构函数反之进行。
destructor：
派生类的析构函数在被调用完成后自动调用基类的destructor。这样才能保证 派生类对象 先清理派生类成员，再清理 基类成员。
尽管不同类的析构函数名不同，实际上编译器会进行特殊处理，将类的析构函数的名称统一处理为“destructor”，所以父类析构函数不加virtual的情况下，派生类和基类的析构构成隐藏关系。
copy constructor：
拷贝构造必须调用基类的拷贝构造完成基类那一部分的拷贝。
copy assignment：
赋值重载必须调用基类的赋值重载完成基类的赋值。
其实看似在派生类对象在调用派生类构造函数之前调用基类构造函数，其实不然，基类构造函数就是派生类构造函数的一部分；
class Person
{
public:
Person(const char* name = "zhangsan")
: _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; // 姓名
};这是一个类，实现的方式对你想必非常熟悉。在这个类的基础上派生出Student：
class Student : public Person
{
public:
Student(const char* name, int num)
: Person(name)
, _num(num)
{
cout << "Student()" << endl;
}
Student(const Student& s)
: Person(s)
, _num(s._num)
{
cout << "Student(const Student& s)" << endl;
}
Student& operator = (const Student& s)
{
cout << "Student& operator= (const Student& s)" << endl;
if (this != &s)
{
Person::operator =(s);
_num = s._num;
}
return *this;
}
~Student()
{
cout << "~Student()" << endl;
}
protected:
int _num; //学号
};派生的构造在初始化列中调用基类的构造；派生的拷贝构造同样；派生的operator=（）在函数体内调用基类operator=（）；析构函数则需要特殊处理，本文先不讲解，留在多态章节娓娓道来。
（六）继承和友元friend
友元关系不能继承。基类的友元函数不能访问派生类的private和protected成员。
（七）继承和静态成员static
基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例 。
（八）虚继承（virtual）
继承分为多种类别：单继承
多继承：
多继承有一种非常特别的情况：菱形继承
菱形继承有一个非常恼人的问题：数据冗余和二义性。
在Assistant的对象中Person成员会有两份
虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在Student和Teacher的继承Person时使用虚拟继承，即可解决问题：
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; return 0; }可以观察到，b和c的_a是同一个。
这里是通过了B和C的两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的A。
需要注意的是，虚拟继承不要在其它地方去使用。
（九）关于继承的思考
继承是一种复用类的方式，一般实现都是public继承。
在现实中，一般不要使用菱形继承。但是使用菱形继承的例子：我们熟知的STl中的iostream是菱形继承的派生类。
继承和组合：
public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。
优先使用对象组合，而不是类继承。对象组合可以保持设计的高内聚，低耦合。便于后期的debug，添加接口，维护成本低。
完~
未经作者同意禁止转载
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
