【C++】继承

一、继承的概念及定义

1.继承的概念

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

就比如我们设计一个学生管理系统，那里面的对象就有学生，老师，等等，而学生和老师又具有很多相同的特点，比如都有姓名，性别，年龄等等，每一学生和老师都有这些属性，就会有代码的冗余，所以我们可以把这些相同的属性放在一个"人"的类中，让学生和老师去继承"人"这个类，这样就实现了代码的复用，代码如下：

class Person
{
public:
	void Print()
	{
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
	}
protected:
	string _name = "李华"; // 姓名
	string _sex = "男"; // 性别
	int _age = 18; // 年龄
};
class Student : public Person
{
protected:
	int _stuid; // 学号
};
class Teacher : public Person
{
protected:
	int _jobid; // 工号
};
int main()
{
	Student s;
	Teacher t;
	s.Print();
	t.Print();
	return 0;
}

我们可以看到，学生和老师这两个对象里面也有了姓名，性别和年龄的属性，也有自己单独的属性。这是因为继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。

2.继承定义

1.定义格式

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

2.继承关系和访问限定符

C++一个提供了三种继承方式–public继承，protected继承和private继承

3.继承基类成员访问方式的变化

类成员/继承方式	public继承	protected继承	private继承
基类的public成员	派生类的public成员	派生类的protected成员	派生类的private成员
基类的protected成员	派生类的protected成员	派生类的protected成员	派生类的private成员
基类的private成员	在派生类中不可见	在派生类中不可见	在派生类中不可见

从上表我们可以看出，父类的私有成员子类都是不可见的，父类的其他成员在子类的访问方式等于成员在父类中的访问权限与继承方式的较小值，其中访问权限大小为public > protected > private

【总结】

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

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

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

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

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

二、基类和派生类对象赋值转换

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

派生类对象赋值给基类对象时是直接将派生类中属于基类的那一部分切割给基类，引用和指针也是如此，基类的引用是派生类中属于基类那一部分的引用，基类的指针是指向派生类中基类那一部分的指针

这里我们需要了解一下C/C++的类型转换，对于类型转换分为显示(强制)类型转换和隐式类型转换，显示类型转换是当两个不用类型的对象进行运算(比较/赋值)的时候，我们手动的将一个对象的类型强制转换为类一个对象的类型，使得能够正常的进行运算，而对于隐式类型转换来说，是当两个不同的类型的变量进行运算的时候，编译器会自动将其中一个变量的类型隐式转换为另一个变量的类型。

我们看下面的代码：

void test()
{
	int i = 1;
	double d = 2.2;
	i = d;
	const int& rd = d;
	const double& ri = i;
}

对于上面的代码，我们可以看到，如果我们不给rd 和ri的前面加上cosnt就会报错，具体原因如下：我们将一个double类型的d作为int类型的引用，此时两个变量的数据类型不相同，这次编译器会根据d的类型创建出一个临时对象，再将这个临时对象作为int类型的引用，但是临时对象具有常性，右边是只读的，左边是可读可写的，此时涉及到了引用权限的放大，所以我们必须加上const进行修饰，对于ri也是如此。所以，对于引用和指针来说，权限只能平移和缩小，不能放大。

派生类对象赋值给基类对象不存在类型转换

也就是说，派生类的对象赋值给基类对象时中间不产生临时变量，我们可以认为这种转换是天然的，所以基类对象可以直接引用/指向派生类对象，而不需要const来进行修饰

class Person
{
public:
	void Print()
	{
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
	}
protected:
	string _name = "李华"; // 姓名
	string _sex = "男"; // 性别
	int _age = 18; // 年龄
};
class Student : public Person
{
protected:
	int _stuid; // 学号
};
void test1()
{
	Person p;
	Student s;

	// 中间不存在类型转换
	p = s;

	Person& rp = s;
	Person* ptrp = &s;
}

【注意】

基类对象不能赋值给派生类对象

基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的这里基类如果是多态类型，可以使用RTTI(Run-Time Type Information)dynamic_cast 来进行识别后进行安全转换

class Person
{
protected:
	string _name; // 姓名
	string _sex;   // 性别
	int _age; // 年龄
};
class Student : public Person
{
public:
	int _No; // 学号
};
void Test2()
{
	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;
}

三、继承中的作用域

1.在继承体系中基类和派生类都有独立的作用域

2.子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。(在子类成员函数中，可以使用 基类::基类成员 显示访问)

3.需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏

4.注意在实际中在继承体系里面最好不要定义同名的成员

// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是非常容易混淆
class Person
{
public:
	void func()
	{
		cout << "Person::func()" << endl;
	}
protected:
	string _name = "李华"; // 姓名
	int _num = 111;  // 身份证号
};
class Student : public Person
{
public:
	void func(int i)
	{
		cout << "Student::func()" << endl;
	}
	void Print()
	{
		cout << " 姓名:" << _name << endl;
		cout << " 身份证号:" << Person::_num << endl;
		cout << " 学号:" << _num << endl;
	}
protected:
	int _num = 999; // 学号
};
void Test()
{
	Student s1;
	s1.Print();
	s1.func(1);
	s1.Person::func();
};

我们可以看到，虽然子类和父类的func()的参数不同，但是他们仍然构成了隐藏，因为他们的函数名相同

此外，子类的成员_num和父类相同，所以构成隐藏，编译器调用同名成员的时候默认调用子类成员，如果需要调用父类成员，需要指定类的作用域

经典相关面试题

下面两个func是什么关系、运行的结果是什么？

A.重载 B.重写 C. 重定义/隐藏 D.编译报错

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

解析： C.重定义/隐藏

虽然A类中的func和B类的func函数名相同且参数不同，但是他们不构成重载，因为他们的作用域不同，重载函数必须在同一个作用域中，所以两个func的关系是隐藏，因为B继承于A，且两个函数名相同，此时编译器会默认去调用子类的函数，所以输出的结果为func(int i)->；如果我们需要调用父类的成员就必须指定作用域。

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

对于上面的代码，两个func构成隐藏，但是这里会编译报错，因为编译器会默认去调用子类的func，子类的func需要传递一个参数i，此时没有传递参数，所以编译会报错。

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

普通类的默认成员函数

C++有六个默认成员函数，分别为构造函数，析构函数，拷贝构造，赋值重载和取地址重载，C++中成员变量一个可以分为两类–内置类型和自定义类型，各个默认成员函数对他们的处理如下：

对于取地址重载和const取地址重载这两个默认成员函数，我们一般使用编译器默认生成的即可。

派生类的默认成员函数

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

1.派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。

2.派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。

3.派生类的operator=必须要调用基类的operator=完成基类的复制。

4.派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。

5.派生类对象初始化先调用基类构造再调派生类构造。

6.派生类对象析构清理先调用派生类析构再调基类的析构。

7.因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同(这个我们后面会讲解)。那么编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加virtual的情况下，子类析构函数和父类析构函数构成隐藏关系

【总结】

1.派生类的成员变量分为三类–内置类型，自定义类型以及父类成员变量，其中派生类成员函数对内置类型和自定义类型的处理方式和普通类的成员函数的处理方式相同，对于父类的成员变量必须由父类成员函数进行处理

2.派生类的析构函数不需要我们显式的调用父类的析构函数，而是在派生类的析构函数调用完毕之后，编译器自动调用父类的析构函数。这样是为了保证子类成员先被析构，父类成员后被析构。当一个对象被销毁时，析构函数的调用顺序是与构造函数的调用顺序相反的。也就是说，先构造的对象后析构，后构造的对象先析构。如果一个类的析构函数中调用了其基类的析构函数，那么在对象销毁时，基类的析构函数会先被调用，然后才调用派生类的析构函数。如果显式地调用析构函数，则可能导致基类的析构函数被重复调用，从而引发错误。所以在C++中，派生类的析构函数会自动调用其基类的析构函数，以确保派生类对象中的基类部分能够正确地被销毁

class Person
{
public:
	// 构造
	Person(const char* name = "peter")
		: _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;
		delete[] p;
	}
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)
	{
		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; //学号
};

【注意】

1.对于构造函数来说，父类如果没有提供默认的构造函数，我们需要在子类的构造函数的初始化列表处显式的调用父类的构造函数来完成父类的初始化

2.子类的拷贝构造必须调用父类的拷贝构造来完成对父类成员变量的拷贝，这里存在子类对象赋值给父类对象(切片)的问题，s是Student对象，而父类的拷贝构造函数需要的参数是Person对象，我们这里能够直接将s作为父类拷贝构造的参数，中间不存在类型转换

3.子类的赋值重载必须调用父类的赋值重载来完成对父类的赋值，我们需要注意的是，子类和父类的赋值重载函数名相同，构成隐藏，所以我们调用父类的赋值重载的时候需要指定作用域，否则会按照就近原则去调用子类的赋值重载，就会出现无限递归的调用子类非赋值重载。

4.父类析构会在子类析构调用完毕之后由编译器自动调用来完成对父类对象的清理，同时子类析构和父类析构函数会被处理成destructor，构成隐藏

五、继承与友元

友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员

class Student;
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;
}
int main()
{
	Person p;
	Student s;
	Display(p, s);
	return 0;
}

六、继承与静态成员

我们知道类的静态成员有如下特性：

静态成员为所有类对象所共享，不属于某个具体的对象，而是属于整个类，存在在静态区

静态成员必须在类外定义，定义不添加static关键字，需要指定类域，在类中只是声明

静态成员变量的访问受类域和访问限定符的限制

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例

class Person
{
public:
	Person()
	{
		++_count;
	}
	string _name; // 姓名
public:
	static int _count; // 统计人的个数。
};
int Person::_count = 0;
class Student : public Person
{
protected:
	int _stuNum; // 学号
};
void TestPerson()
{
	Person p;
	Student s;
	p._name = "张三";
	s._name = "李四";
	p._count++;
	s._count++;
	cout << p._count << endl;
	cout << s._count << endl;
	cout << &p._count << endl;
	cout << &s._count << endl;
	cout << Person::_count << endl;
	cout << Student::_count << endl;
}

我们可以看到，父类和子类改变的是同一个静态成员变量，因为父类和子类的静态成员是同一个地址，所以，静态成员属于所以父类及其对象、所有它的子类及其对象，且只有一份

相关经典面试题

class Person
{
public:
	Person()
	{
		++_count;
	}

	void Print()
	{
		cout << this << endl;
		//cout << _name << endl;
		//cout << _count << endl;
	}
	string _name; // 姓名
public:
	static int _count; // 统计人的个数。
};

int Person::_count = 0;

class Student : public Person
{
protected:
	int _stuNum; // 学号
};

// 静态成员属于整个类，所有对象。同时也属于所有派生类及对象
int main()
{
	Person* ptr = nullptr;
	cout << ptr->_name << endl;  // no  1
	ptr->Print();                // ok  2
	cout << ptr->_count << endl; // ok  3

	(*ptr).Print();             // ok   4
	cout << (*ptr)._count << endl; // ok 5

	return 0;
}

【解析】

1.编译错误：_name是Person类中的普通成员变量，存在于对象里面，当我们访问_name时，编译器会到ptr指向的Person对象去取_name,此时会发生空指针的解引用问题

2.正常运行：Print()是Person类中的成员函数，成员函数存在于代码段，不存在于对象的里面，调用成员函数需要this指针，刚好ptr是Person类的指针，所以ptr的值0x0000会被当做this指针传递给Print()函数，同时，Print()函数并没有访问普通成员变量，所以不会发生空指针的解引用问题，所以会访问普通成员变量，此时也会发生空指针的解引用问题

3.正常运行：count是静态成员变量，存在于静态区，不存在对象里面，访问const时编译器会直接到静态区取数据，所以不会有ptr的解引用，此处ptr的作用是指明类域，等价于Person::_count

4.5正常运行：这里虽然看起来堆ptr存在解引用，其实并没有，这个代码经过编译器的处理之后和2.3一样

七、多继承与菱形继承

1.多继承

单继承：一个子类只有一个直接父类时称这个继承关系为单继承

多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承

多继承使得子类可以同时继承多个直接父类的成员，进一步实现了代码的复用

2.菱形继承

菱形继承：菱形继承是多继承的一种特殊情况。

菱形继承存在数据冗余和代码二义性的问题。比如下面的模型中，Student和Teacher都继承了Person的成员，而Assistant又同时继承了Student和Teacher的成员，所以Person的成员在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; // 主修课程
};

我们可以通过类域来解决二义性的问题，但是数据冗余的问题依然存在

3.菱形虚拟继承

虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在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 ; // 主修课程
};
void Test ()
{
    Assistant a ;
    a._name = "peter";
}

虚拟继承解决数据冗余和二义性的原理

为了研究虚拟继承原理，我们给出了一个简化的菱形继承继承体系，再借助内存窗口观察对象成员的模型。

我们首先观察不是虚拟继承时菱形继承的内容情况：

class A
{
public:
	int _a;
};
class B : public A
{
public:
	int _b;
};
class C : public A
{
public:
	int _c;
};
class D : public B, public C
{
public:
	int _d;
};

我们可以看到，在没有进程虚拟继承时，D对象中存在着三部分成员–从B继承过来的成员，从C继承过来的成员以及D自身的成员，同时，由于B,C都继承于A，所以D对象中存在两份A的成员，所以造成了数据冗余和二义性

下面我们观察虚拟继承之后的内存情况：

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

我们可以发现，整个D对象只有一份A对象的成员了，并且存于最下面，B和C对象中不再有A的成员；但是B和C对象中多了一个指针，并且我们查看指针指向的内存窗口的时候，发现该窗口第二个整形值恰好为B/C对象的起始地址距离A对象起始地址的偏移量

【总结】

这样D对象就只有一份A对象的成员了，位于最下面，这样就解决了数据冗余和二义性的问题。

B和C对象多出来的那个指针指向的内容被称为虚基表，虚基表中前四个字节的内容和多态有关，后四个字节的内容存放的是对象的起始地址与虚基类对象起始地址的偏移量

那么为什么要记录虚继承的类对象中距离虚基类对象的偏移量呢？这是为了满足切片的场景

我们可以看到，虚拟继承之后，B和C的模型也发生了变化，B对面里面有自己的成员，A成员的值也是放在最下面 ，也有一个指向虚基类的指针，即A成员的地址，上述在都是B对象的成员去访问A的成员变量_a,在内存中的位置是不一样的，如果我们此时仍然到对底下去访问_a,那么第二个的访问结果就会是C的虚基表指针，但是按照偏移量访问就不会有这个问题。

我们可能觉得上面的基础并没有解决数据冗余的问题，反而多浪费了空间，这是因为上面的代码浪费的空间大于了节省的空间，当我们的类很大的时候，就会节省空间

上面的Person关系菱形虚拟继承的原理解释如下：

【总结】虚继承是如何解决菱形继承数据冗余和二义性问题的

1.在对象模型上，虚继承将虚基类放在模型的最下面，使得虚基类在对象模型中只有一份，其他的对象保存对虚基类成员的偏移量即可

2.为了满足在切片的场景下也能够找到虚基类，虚继承的类对象中会存储一个虚基表的指针，虚基表里面存储了虚继承对象的存储地址与虚基类地址的偏移量，虚继承类对象可以根据这个偏移量来找到虚基类。

八、继承的总结和反思

1.很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题

2.多继承可以认为是C++的缺陷之一，很多后来的高级语言都没有多继承，如Java

九、继承与组合

public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象，而组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象

继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高

对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装

实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合

十、笔试面试题

1.什么是菱形继承？菱形继承的问题是什么？

菱形继承是一种继承关系，其中一个子类同时继承自两个不同的父类，而这两个父类又共同继承自同一个父类，形成了一个类似菱形的继承结构。

菱形继承的问题是多重继承带来的问题，主要有以下两个方面：

1. 潜在的二义性问题。当子类继承了两个父类，且这两个父类都有相同的方法或属性时，子类可能会出现二义性问题，即无法确定调用哪个父类的方法或属性。
2. 内存空间浪费问题。由于两个父类都继承自同一个父类，因此子类会继承两份相同的数据成员和方法，造成内存空间的浪费。

2.什么是菱形虚拟继承？如何解决数据冗余和二义性的

菱形虚拟继承是通过虚拟继承的方式来解决菱形继承问题的一种方法。在菱形虚拟继承中，虚拟继承的基类只会在虚拟继承链的最顶端被实例化，而在其他派生类中只保留一个指向该基类的指针，从而避免了数据冗余和二义性问题。

具体而言，菱形虚拟继承通过在派生类中使用关键字virtual来声明对基类的继承，从而使得基类只被实例化一次，并在派生类中保留一个指向该基类的指针。这样，当派生类中需要访问基类的成员时，就可以通过该指针来访问。

通过菱形虚拟继承，可以有效地解决数据冗余和二义性问题，同时还能够保持多重继承的优点，即提高代码的复用性和灵活性。

菱形虚拟继承是一种通过虚拟继承来解决菱形继承问题的技术。在菱形虚拟继承中，两个继承同一个父类的父类都使用虚拟继承方式，这样在子类中就只有一个共享的父类，避免了数据冗余和二义性的问题。
通过虚拟继承，子类只继承了一份父类的成员，而不是继承自两个不同的父类。在虚拟继承中，父类的成员只会被构造一次，避免了数据冗余的问题。此外，虚拟继承还可以解决二义性的问题，因为在子类中只有一个祖先类的实例，所以无论调用哪个父类的成员函数，都只有一个实现。
在实现菱形虚拟继承时，需要在父类的继承声明前加上关键字"virtual"，并在子类的构造函数中调用父类的构造函数来初始化祖先类的成员。例如：

class A {
public:
  int x;
};
class B : virtual public A {
public:
  int y;
};
class C : virtual public A {
public:
  int z;
};
class D : public B, public C {
public:
  int w;
  D(int a, int b, int c, int d) : A{a}, B{b}, C{c}, w{d} {}
};

在上面的例子中，B和C都使用了虚拟继承方式继承自A，而D继承自B和C。在D的构造函数中，需要调用A、B、C的构造函数来初始化所有的成员。

3.继承和组合的区别？什么时候用继承？什么时候用组合？

继承和组合是面向对象编程中两种常用的代码复用方式。

继承是指一个类可以从另一个类中继承属性和方法，并且可以在此基础上扩展自己的属性和方法。继承关系通常表现为“is-a”的关系，即一个类是另一个类的一种特殊形式。例如，狗是一种动物，可以用“Dog extends Animal”来表示狗类继承自动物类。

组合是指一个类可以包含其他类的对象，并且可以在此基础上扩展自己的属性和方法。组合关系通常表现为“has-a”的关系，即一个类包含另一个类的对象作为自己的属性。例如，一个汽车类可以包含一个发动机类作为其属性，可以用“Car has an Engine”来表示汽车类包含一个发动机类的对象。

在选择继承和组合时，应该根据具体情况进行选择。通常情况下，当两个类之间存在“is-a”关系时，可以使用继承；当两个类之间存在“has-a”关系时，可以使用组合。具体来说：

1. 继承适用于在一个类的基础上进行扩展，使其成为一个更具体、更特殊的类的情况下。例如，可以从一个通用的动物类中继承出狗、猫等具体的动物类。
2. 组合适用于将多个类的功能组合到一个更大的类中，以实现更复杂的功能的情况下。例如，可以将汽车类组合成由发动机、车轮等组成的更复杂的类。

需要注意的是，在使用继承和组合时，应该避免过度使用，以免导致代码的复杂性增加。此外，应该优先考虑组合，只有在确实需要使用继承时才使用