C++中的继承

1.继承的概念及定义

继承是面向对象编程中的一个重要概念。它允许我们定义一个类，然后从这个类派生出新的类，从而实现代码的复用和扩展。
定义：在C++中，继承通过在类定义中使用冒号和基类名称来实现。例如，如果我们有一个名为Shape的基类，我们可以定义一个名为Rectangle的派生类，它继承自Shape：

class Shape 
{
public:
    // 基类成员
};

class Rectangle : public Shape 
{
public:
    // 派生类成员
};

在这个例子中，Rectangle继承了Shape的所有成员。这意味着我们可以在Rectangle对象上调用Shape中定义的方法。
Rectangle为派生类，public为继承方式，Shape为基类。

继承有几种不同的类型，包括公有继承、保护继承和私有继承。它们之间的区别在于基类成员在派生类中的可见性和访问权限。

• 公有继承：基类的公有成员和保护成员在派生类中分别是公有成员和保护成员，基类的私有成员在派生类中不可见。
• 保护继承：基类的公有成员和保护成员在派生类中都是保护成员，基类的私有成员在派生类中不可见。
• 私有继承：基类的公有成员和保护成员在派生类中都是私有成员，基类的私有成员在派生类中不可见。

总结： 1. 基类private成员在派生类中无论以什么方式继承都是不可见的。 这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
3.在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

2.基类和派生类对象赋值转换

派生类对象可以赋值给基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。
基类对象不能赋值给派生类对象。

class Person
{
protected:
	string _name; // 姓名
	string _sex;  // 性别
	int _age; // 年龄
};
class Student : public Person
{
public:
	int _num; // 学号
};
int main()
{
	Student s;
	// 1.子类对象可以赋值给父类对象/指针/引用
	Person p = s;
	Person* pp = &s;
	Person& rp = s;
	//2.基类对象不能赋值给派生类对象
	s = p;//出错误
	// 3.基类的指针可以通过强制类型转换赋值给派生类的指针
	pp = &s;
	Student* ps1 = (Student*)pp;

	return 0;
}

继承中的作用域：

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

3.继承与友元

友元关系不能被继承，基类的友元对派生类没有特殊的访问权限。但是，一个友元类的派生类，可以通过其基类接口去访问设置其基类为友元类的类的私有成员。

class Base
{
    friend class Friend;
public:
    Base(int a)
        :x(a)
    {

    }
private:
    int x;
};

class Derived : public Base
{
public:
    Derived(int a, int b)
        :Base(a), y(b)
    {

    }
private:
    int y;
};

class Friend
{
public:
    void show(Base b)
    {
        cout << b.x << endl; // 可以访问基类的私有成员
    }
    void show(Derived d)
    {
         cout << d.y << endl; // 错误：不能访问派生类的私有成员
    }
};

int main()
{
    Base b(1);
    Derived d(1,2);
    Friend f;
    f.show(b);
    f.show(d);
}

4.继承与静态成员

静态成员是指在类中使用 static 关键字定义的成员，它们在类的所有对象中是共享的，无论创建多少个类的对象，静态成员都只有一个副本。静态成员被放在堆区。

如果基类中被派生类继承的成员是公开的或者保护的静态成员，则其静态属性也随静态成员被继承过来。这些静态成员可以通过<类名>::<成员名>或是<对象名>.<成员名>的方式来引用或调用。无论有多少个类对象和派生类对象被创建，它都只有一个拷贝。

静态成员在类中声明，在类外定义。（切记必须在类外定义，也就是全局变量中，主函数中不可以定义）

class Person {
public:
    Person() { _count++; }
private:
    string _name;
public:
    static int _count; //类中声明
};

int Person::_count = 0;//类外定义

class Student :public Person {
private:
    int _num;
};

class Teacher : public Person {
private:
    string _school;
};

int main() {
	//int Person::_count = 0; //错误写法，不可在主函数中定义
    Student s1;
    Student s2;
    Student s3;
    Teacher t;
    cout << "人数：" << Person::_count << endl;
    cout << t._count << endl;
    Person::_count = 0;
    cout << "人数：" << Person::_count << endl;
    cout << t._count << endl;
    return 0;
}

在这个例子中，我们定义了一个基类 Person，它有一个静态成员变量 _count，用来记录创建的 Person 对象的数量。然后我们定义了两个派生类 Student 和 Teacher，它们都继承自 Person 类。在 main 函数中，我们创建了三个 Student 对象和一个 Teacher 对象，然后通过访问静态成员变量 _count 来查看创建的对象数量。
可以看到，无论是通过基类 Person 还是派生类 Student 和 Teacher 来访问静态成员变量 _count，它们都指向同一个内存地址空间的变量，也就是说它们共享同一个静态成员变量。

5.复杂的菱形继承

菱形继承（Diamond Inheritance）是指在多重继承中，两个或多个基类继承自同一个基类，而派生类又同时继承这些基类的情况。这种继承关系形成了一个菱形结构，因此被称为菱形继承。

class Person{
public:
	string _name = "张三"; // 姓名
};
class Student : public Person{
protected:
	int _num = 1234; //学号
};
class Teacher : public Person{
protected:
	int _id = 5678; // 职工编号
};
class Assistant : public Student, public Teacher{
protected:
	string _majorCourse = "高数"; // 主修课程
};
int main()
{
	// 这样会有二义性无法明确知道访问的是哪一个
	Assistant a;
	//a._name = "peter";
	// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
	a.Student::_name = "xxx";
	a.Teacher::_name = "yyy";
	return 0;
}

6.虚拟继承（难点）

菱形继承造成的问题在c++3.0版本进一步完善，引入模板，解决多重继承产生的二义性问题和相应构造和析构的处理。
虚拟继承（virtual inheritance）是 C++ 中用来解决多重继承中的菱形继承问题的一种技术。它可使用 virtual 关键字来指定基类，以确保在派生类中只保留一个基类的子对象。
为了方便在内存中观察，我们用以下代码进行研究：

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;
}

由监视窗口可以看到虚拟继承中A 类_a的的值都相同， 并且多了一个A类。
在x86平台进行调试调，然后在内存窗口输入&d，查看d的内存信息。

虚基类表中存储的是偏移量，即各个虚基类的成员变量在子类中的内存布局中相对于虚函数指针的偏移值 。每个虚继承的子类都有一个虚基类指针（占用一个指针的存储空间，4字节）和虚基类表（不占用类对象的存储空间）。虚基类表中记录了虚基类与派生类的偏移地址。通过偏移地址，就可以找到虚基类成员。 当虚继承的子类被当做父类继承时，虚基类指针也会被继承。

7.继承的总结

1. 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。
2. 优先使用对象组合，而不是类继承 。
3. 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
4. 对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
5. 实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合。