一、继承概念及定义

概念

继承(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种继承方式：

类成员/继承方式	public继承	protected继承	private继承
父类的public成员	子类的public成员	子类的protected成员	子类的private成员
父类的protected成员	子类的protected成员	子类的protected成员	子类的private成员
父类的private成员	子类中不可见	子类中不可见	子类中不可见

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<<endl;
	return 0;
}

---

七、菱形继承及菱形虚拟继承

我们前面所说的实际上都是单继承，单继承：一个子类只有一个直接父类时称这个继承关系为单继承

然而，对于C++而言，还有多继承，多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承

而菱形继承是多继承比较特殊的情况：

菱形继承的问题：菱形继承有数据冗余和二义性的问题，在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;
    解决了二义性，但是代码冗余
	a.Student::_name = "xxx";
	a.Teacher::_name = "yyy";
	return 0;
}

虚拟继承可以解决菱形继承的二义性和数据冗余的问题:如上面的继承关系，在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;
	d._b = 3;
	d._c = 4;
	d._d = 5;
	return 0;
}

下面通过内存窗口观察,对比菱形继承与菱形虚拟继承：

左边是菱形继承，我们可以清楚的看到A有两份，既代码冗余，而通过菱形虚拟继承，此时A只有一份，且在最下面的位置

这里可以分析出D对象中将A放到的了对象组成的最下面，这个A同时属于B和C，那么B和C如何去找到公共的A呢？

这里是通过了B和C的两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的A

为什么需要找到最下面的A：比如当下面的赋值发生时，d要去找出B/C成员中的A才能赋值

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

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

切片的时候就需要通过偏移量去计算位置，也就是找到最下面的A。

---

八、继承与组合

继承和组合都是一种复用，最大的区别是访问的方式有所不同

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

继承是白箱复用，组合是黑箱复用（黑与白是能不能看到内部），组合的耦合度低，而继承的耦合度高，而高内聚低耦合，耦合度高意味着依赖关系大，所以当继承与组合都符合的情况下，比较建议使用组合。

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

继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。 组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装

---

九、结语

C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承

定义一个不能被继承的类

1.构造私有

class A
{
private:
	A()
	{}
};

class B:public A
{

};
int main()
{
	B bb;
	return 0;
}

2.类定义时加final

class A final
{
public:
	A()
	{}
};

class B:public A
{

};
int main()
{
	B bb;
	return 0;
}