初识C++(5)

最新推荐文章于 2024-11-01 14:43:43 发布

原创最新推荐文章于 2024-11-01 14:43:43 发布 · 854 阅读

19 ·

CC 4.0 BY-SA版权

文章标签：

#c++

文章目录

一、继承
二、多态
- 多态的定义及实现

一、继承

1、继承的概念

继承（inheritance）机制是面向对象程序设计使代码可以复用的最重要的手段，它允许我们在保持原有类特性的基础上进行扩展，增加方法（成员函数）和属性（成员变量），这样产生新的类，称子类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的函数层次的复用，继承是类设计层次的复用。
两个类Student和Teacher,Student和Teacher都有姓名／地址／电话／年龄等成员变量，都有identity身份认证的成员函数，设计到两个类里面就是冗余的。当然他们也有一些不同的成员变量和函数，比如老师独有成员变量是职称，学生的独有成员变量是学号；学生的独有成员函数是学习，老师的独有成员函数是授课。

#include<iostream>

using namespace std;

class Person
{
public:
	void identity()//身份信息认证
	{
		cout << "void identity()" << _name << endl;
	}
protected:
	string _name = "张三";
	string _address;
	string _tel;
	int _age = 18;
};

class Student : public Person
{
public:
	void study()//学习
	{

	}
protected:
	int _stuid;
};

class Teacher : public Person
{
public:
	void teaching()//授课
	{

	}
protected:
	string title;//职称
};

int main()
{
	Student s;
	Teacher t;

	s.identity();
	t.identity();
}

void identity()张三
void identity()张三

C:\Users\Lenovo\source\repos\继承\x64\Debug\继承.exe (进程 8140)已退出，代码为 0。
按任意键关闭此窗口. . .

2、继承的定义

class Teacher : public Person
Teacher是派生类，public是继承方式，Person是父类

1.父类private成员在子类中无论以什么方式继承都是不可见的。这里的不可见是指父类的私有成员还是被继承到了子类对象中，但是语法上限制子类对象不管在类里面还是类外面都不能去访问它。
2.父类private成员在子类中是不能被访问，如果父类成员不想在类外直接被访问，但需要在子类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
3.我们进行一下总结会发现，父类的私有成员在子类都是不可见。父类的其他成员在子类的访问方式 == Min(成员在父类的访问限定符，继承方式)，public > protected > private。
解析：取二者中最小的那个
4.使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
5.在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在子类的类里面使用，实际中扩展维护性不强。

(1)、如何访问父类中私有成员变量

#include<iostream>

using namespace std;

class Person
{
public:
	void identity()//身份信息认证
	{
		cout << "void identity()" << _name << endl;
		cout << _age << endl;
	}
protected:
	string _name = "张三";
	string _address;
	string _tel;
private:
	int _age = 18;
};

class Student : public Person
{
public:
	void study()//学习
	{

	}
protected:
	int _stuid;
};

class Teacher : public Person
{
public:
	void teaching()//授课
	{

	}
protected:
	string title;//职称
};

int main()
{
	Student s;
	Teacher t;
	//t._age;
	//age是私有对象，子类虽然继承了，但是无法使用，但是在父类中自己是可以使用的，所以我们可以让父类成员函数中包含私有成员变量，
	//然后子类调用父类的成员函数，就能访问到私有成员变量了
	s.identity();
	t.identity();

}

void identity()张三
18
void identity()张三
18

C:\Users\Lenovo\source\repos\继承\x64\Debug\继承.exe (进程 10172)已退出，代码为 0。
按任意键关闭此窗口. . .

PS：如果子类继承的是protected，而父类的成员函数也是protected，但是在main()中，子类也是访问不了的父类的成员函数的
如果子类继承的是protected，而父类的成员函数是public，子类在main()中仍然不能访问父类的成员函数。

3、继承类模版

template<class T>

class stack : public std::vector<T>//继承库里的vector
//这里存在按需实例化的情况
class stack : public vector<T>//继承非库里的vector

template<class T>
class stack : public std::vector<T>
{
public:
    void push(const T& x)
    {
        //父类是类模版时，需要指定一下类域
        //否则编译报错
        //因为stack<int>实例化时，也实例化vector<int>
        //但是模版是按需实例化，push_back等成员函数未实例化，所以找不到
        //push_back(x);就找 不到了
        //所以需要指定一下，才能调用成功
        vector<T>::push_back(x);
	}
	......

1、宏替换deque

#include<iostream>
#include<deque>
#include<vector>
#include<list>

using namespace std;

#define CONTAINER std::deque

namespace bit
{
    template<class T>
    class stack : public CONTAINER<T>
 	{
	public:
		void push(const T& x)
		{
			CONTAINER<T>::push_back(x);
		}

		void pop()
		{
			CONTAINER<T>::pop_back();
		}

		const T& top()
		{
			return CONTAINER<T>::back();
		}
		
		bool empty()
    	{
			return CONTAINER<T>::empty();
    	}
	};
	template<class T>
	class A
	{
	public:
		A()
		{
			//func();
		}

		void push(const T& x)
		{
			x.func();
		}
	};
}

int main()
{
	bit::stack<int> st;
	st.push(1);
	st.push(2);
	st.push(3);
	while (!st.empty())
	{
		cout << st.top() << " ";
		st.pop();
	}
	return 0;
}

1、宏替换vector

#include<iostream>
#include<deque>
#include<vector>
#include<list>

using namespace std;

#define CONTAINER std::vector

namespace bit
{
    template<class T>
    class stack : public CONTAINER<T>
 	{
	public:
		void push(const T& x)
		{
			CONTAINER<T>::push_back(x);
		}

		void pop()
		{
			CONTAINER<T>::pop_back();
		}

		const T& top()
		{
			return CONTAINER<T>::back();
		}
		
		bool empty()
    	{
			return CONTAINER<T>::empty();
    	}
	};
	template<class T>
	class A
	{
	public:
		A()
		{
			//func();
		}

		void push(const T& x)
		{
			x.func();
		}
	};
}

int main()
{
	bit::stack<int> st;
	st.push(1);
	st.push(2);
	st.push(3);
	while (!st.empty())
	{
		cout << st.top() << " ";
		st.pop();
	}
	return 0;
}

1、宏替换list

#include<iostream>
#include<deque>
#include<vector>
#include<list>

using namespace std;

#define CONTAINER std::list

namespace bit
{
    template<class T>
    class stack : public CONTAINER<T>
 	{
	public:
		void push(const T& x)
		{
			CONTAINER<T>::push_back(x);
		}

		void pop()
		{
			CONTAINER<T>::pop_back();
		}

		const T& top()
		{
			return CONTAINER<T>::back();
		}
		
		bool empty()
    	{
			return CONTAINER<T>::empty();
    	}
	};
	template<class T>
	class A
	{
	public:
		A()
		{
			//func();
		}

		void push(const T& x)
		{
			x.func();
		}
	};
}

int main()
{
	bit::stack<int> st;
	st.push(1);
	st.push(2);
	st.push(3);
	while (!st.empty())
	{
		cout << st.top() << " ";
		st.pop();
	}
	return 0;
}

4、父类和子类对象赋值兼容转换

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

    Person per1 = stu;
	Person* per2 = &stu;
	Person& per3 = stu;//注意这里不一样，没有产生临时变量
	//不会像
	int i = 1;
	double d = i;
	//double& rd = i;会报错，因为引用的是中间产生的临时变量，所以要加const才不会报错
	const double& rd = i;

父类对象不能赋值给子类对象。

    //父类对象不能赋值给子类对象，会编译报错
	// stu = per1;
	// 即使是强制类型转换也不行
	// stu = (Student)per1;
	//因为比如说父类中有子类中没有的成员变量，那么父类怎么把这些没有的成员变量赋值子类？

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

5、继承中的作用域

1、在继承体系中父类和子类都有独立的作用域。
2、子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，就访问子类自己的，不会访问父类的，这种情况叫隐藏。(在子
类成员函数中，可以使用父类::父类成员显示访问)

class Person
{
protected:
	string _name = "小李子";
	int _num = 4008123;
};

class Student : public Person
{
public :
	void Print()
	{
		cout << "姓名：" << _name << endl;
		cout << "身份证号：" << Person::_num << endl;//调用父类的
		cout << "学号：" << _num << endl;//调用自身的
	}
protected:
	int _num = 10086;
};

int main()
{
	Student s1;
	s1.Print();

	return 0;
}

姓名：小李子
身份证号：4008123
学号：10086

C:\Users\Lenovo\source\repos\继承\x64\Debug\继承.exe (进程 33116)已退出，代码为 0。
按任意键关闭此窗口. . .

3、需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
PS：
函数重载要求在同一个作用域，经常会用成员变量的隐藏来混淆重载的概念

class A
{
public:
	void fun()
	{
		cout << "func()" << endl;
	}
};

class B : public A
{
	public:
		void fun(int i)
		{
			cout << "func(int i)" << i <<  endl;
		}
};

int main()
{
	B b;
	//b.fun();会报错，A中的成员函数已经被隐藏了，这样调用就会报错
	b.A::fun();//正确处理
	b.fun(1);
	return 0;
}

func()
func(int i)1

C:\Users\Lenovo\source\repos\继承\x64\Debug\继承.exe (进程 29212)已退出，代码为 0。
按任意键关闭此窗口. . .

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

6、4个常见默认成员函数

6个默认成员函数，默认的意思就是指我们不写，编译器会变我们自动生成一个，那么在子类中，这几个成员函数是如何生成的呢？
1、子类的构造函数必须调用父类的构造函数初始化父类的那一部分成员。如果父类没有默认的构造函数，则必须在子类构造函数的初始化列表阶段显示调用。

父类中有默认构造函数

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;
	}
protected:
	string _name;
};

class Student : public Person
{
public:
	Student(const char* name, int num, const char* address)
		//:_name(name)
		//这样写是错误的，因为子类构造函数必须调用父类构造函数，不能直接写成员变量初始化
		:Person(name)//这就是显示调用父类构造函数
		,_num(num)
		,_address(address)
	{

	}
	//默认生成的构造函数的行为
	//1、内置类型 --> 不确定
	//2、自定义类型 --> 调用默认构造
    //3、继承的父类成员看做一个整体对象，要求调用父类的默认构造函数

protected:
	int _num = 1;
	string _address = "保定";
};

int main()
{
	Student s("张三", 1, "河北");
	return 0;
}

Person()
~Person()

C:\Users\Lenovo\source\repos\继承\x64\Debug\继承.exe (进程 29012)已退出，代码为 0。
按任意键关闭此窗口. . .

2、子类的拷贝构造函数必须调用父类的拷贝构造完成父类的拷贝初始化。

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;
	}
protected:
	string _name;
};

class Student : public Person
{
public:
	Student(const char* name, int num, const char* address)
		//:_name(name)
		//这样写是错误的，因为子类构造函数必须调用父类构造函数，不能直接写成员变量初始化
		:Person(name)//这就是显示调用父类构造函数
		, _num(num)
		, _address(address)
	{

	}
	
	//严格说student拷贝构造默认生成的够用了
	//假设有需要深拷贝的资源，才需要自己实现
	
	Student(const Student& s)//子类拷贝构造
	    :Person(s)//传的是子类对象，这里是赋值兼容转换
	    //这里就涉及到之前的一个知识点了
	    //就是说是初始化的顺序和声明的顺序相关，跟出现的顺序无关
		:_num(s._num)
		,_address(s._address)
	{

	}

protected:
	int _num = 1;
	string _address = "保定";
};

int main()
{
	Student s1("张三", 1, "河北");
	Student s2(s1);
	return 0;
}

Person()
Person(const Person& p)
~Person()
~Person()

C:\Users\Lenovo\source\repos\继承\x64\Debug\继承.exe (进程 16428)已退出，代码为 0。
按任意键关闭此窗口. . .

3、子类的operator＝必须要调用父类的operator＝完成父类的复制。需要注意的是子类的operator＝隐
藏了父类的operator=，所以显示调用父类的operator=，需要指定父类作用域

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;
	}
protected:
	string _name;
};

class Student : public Person
{
public:
	Student(const char* name, int num, const char* address)
		//:_name(name)
		//这样写是错误的，因为子类构造函数必须调用父类构造函数，不能直接写成员变量初始化
		:Person(name)//这就是显示调用父类构造函数
		, _num(num)
		, _address(address)
	{

	}

	//严格说student赋值重载默认生成的够用了
	//假设有需要深拷贝的资源，才需要自己实现
	Student& operator=(const Student& s)
	{
		if (this != &s)
		{
			Person::operator=(s);//调用父类的operator=需要指定是父类的。
			_num = s._num;
			_address = s._address;
		}
		return *this;
	}

	Student(const Student& s)//子类拷贝构造
		:_num(s._num)
		,_address(s._address)
		,Person(s)//传的是子类对象，这里是赋值兼容转换
	{

	}

protected:
	int _num = 1;
	string _address = "保定";
};

int main()
{
	Student s1("张三", 1, "河北");
	Student s2(s1);
	Student s3("李四", 2, "黑龙江");
	s1 = s3;

	return 0;
}

Person()
Person(const Person& p)
Person()
Person operator= (const Person& p)
~Person()
~Person()
~Person()

C:\Users\Lenovo\source\repos\继承\x64\Debug\继承.exe (进程 30816)已退出，代码为 0。
按任意键关闭此窗口. . .

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

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;
	}
protected:
	string _name;
};

class Student : public Person
{
public:
	Student(const char* name, int num, const char* address)
		//:_name(name)
		//这样写是错误的，因为子类构造函数必须调用父类构造函数，不能直接写成员变量初始化
		:Person(name)//这就是显示调用父类构造函数
		, _num(num)
		, _address(address)
	{

	}

	Student(const Student& s)//子类拷贝构造
		:_num(s._num)
		, _address(s._address)
		, Person(s)//传的是子类对象，这里是赋值兼容转换
	{

	}

	Student& operator=(const Student& s)
	{
		if (this != &s)
		{
			Person::operator=(s);//调用父类的operator=需要指定是父类的。
			_num = s._num;
			_address = s._address;
		}
		return *this;
	}

	//严格说student析构默认生成的够用了
	//假设有需要显示释放的资源，才需要自己实现
	//析构都会被特殊处理为destructor()
	~Student()
	{
		//子类析构函数和父类析构函数构成隐藏关系
		Person::~Person();
		//不需要显示调用，子类析构函数之后，会自动调用父类析构
		//显示调用，无法保证析构顺序：先子后父，除非是把父类析构放在子类析构后面
	}

protected:
	int _num = 1;
	string _address = "保定";
};

int main()
{
	Student s1("张三", 1, "河北");
	Student s2(s1);
	Student s3("李四", 2, "黑龙江");
	s1 = s3;

	return 0;
}

Person()
Person(const Person& p)
Person()
Person operator= (const Person& p)
~Person()
~Person()
~Person()
~Person()
~Person()
~Person()

C:\Users\Lenovo\source\repos\继承\x64\Debug\继承.exe (进程 36044)已退出，代码为 0。
按任意键关闭此窗口. . .

5、子类对象初始化先调用父类构造再调子类构造。
6、子类对象析构清理先调用子类析构再调父类的析构。
7、因为多态中一些场景析构函数需要构成重写，重写的条件之一是函数名相同。那么编译器会对析构函数名进行特殊处理，处理成destructor()，所以父类析构函数不加virtual的情况，子类析构函数和父类析构函数构成隐藏关系。
总结一句话：
子类的构造，拷贝构造，赋值重载都需要显示调用父类的，而析构函数不用显示调用父类的。

7、实现一个不能被继承的类

1、父类的构造函数私有，子类的构成必须调用父类的构造函数，但是父类的构成函数私有化后，子类看不见就不能调用了，那么子类就无法实例化处对象。
2、C++11新增了一个final关键字，final修改父类，子类就不能继承了。
例：
class A final
{

};

8、继承与友元

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

//前置声明
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)
{
	//Display是Person的友元函数，而不是Student的友元函数，所以调用p的成员变量不会报错
	cout << p._name << endl;
	//调用s的成员变量就会报错
	//cout << s._stuNum << endl;
}

int main()
{
	Person p;
	Student s;
	//编译报错：
	//Student::_stuNum无法访问protected成员
	//解决方法：
	//Display也变成Student的友元即可
	Display(p, s);

	return 0;
}

9、继承与静态成员

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

class Person
{
public:
	string _name;
	static int _count;
};

int Person::_count = 0;

class Student : public Person
{
protected:
	int _stuNum;
	//子类会继承_count，但是这个_count是同一个count
};

int main()
{
	Person p;
	Student s;
	//这里的运行结果客可以看到非静态成员_name的地址是不一样的，
	//说明子类继承下来了，父子类对象各有一份
	cout << &p._name << endl;
	cout << &s._name << endl;

	//这里的运行结果可以看到静态成员_count的地址是一样的
	//说明子类和父类共用一份静态成员
	cout << &p._count << endl;
	cout << &s._count << endl;

	//共有情况下，父子类指定类域都可以访问静态成员
	cout << Person::_count << endl;
	cout << Student::_count << endl;

	cout << p._count << endl;
	cout << s._count << endl;
	return 0;

}

000000AC4B3CFAD8
000000AC4B3CFB18
00007FF6116A1444
00007FF6116A1444
0
0
0
0

C:\Users\Lenovo\source\repos\继承\x64\Debug\继承.exe (进程 6532)已退出，代码为 0。
按任意键关闭此窗口. . .

10、多继承及其菱形继承问题

(1)、继承模型

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

例：

//class Person被 class Student 继承
class Person
class Student::public Person
//class Student被 class PostGraduate 继承
class PostGraduate::public Student

多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承，多继承对象在内存中的模型是，先继承的父类在前面，后面继承的父类在后面，子类成员在放到最后面。

//class Assistant同时继承了class Student 和class Teacher
class Student

class Teacher

class Assistant : public Student, public Teacher

菱形继承：菱形继承是多继承的一种特殊情况。
菱形继承的问题，是菱形继承有数据冗余和二义性的问题，在Assistant的对象中Person成员会有两份。支持多继承就一定会有菱形继承，像Java就直接不支持多继承，规避掉了这里的问题，所以实践中我们也是不建议设计出菱形继承这样的模型的。

//class Assistant同时继承了class Student 和class Teacher
class Student

class Teacher

class Assistant : public Student, public Teacher 
同时 class Student 和class Techer 又继承了class Person

11、虚继承

//class Assistant同时继承了class Student 和class Teacher
class Student

class Teacher

class Assistant : public Student, public Teacher 
同时 class Student 和class Techer 又虚继承了class Person
class Student : virtual public class Person
class Teacher : virtual public class Person

虚继承解决了数据冗余和二义性问题，只会有一份成员变量

不加virtual

class Person
{
public:
	string _name;
};

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

	protected:
		int _id; // 职工编号
};

class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse; // 主修课程
};

int main()
{
	Assistant a;
	//如果不用虚继承就会报错，不知道调用谁的成员变量
	a._name = "张三";
    //只能通过加具体的父类名称，才能对成员变量进行赋值
    a.Teacher::_name = "老李";
	a.Student::_name = "小李";
	return 0;
}

E0266	"Assistant::_name" 不明确
C2385	对“_name”的访问不明确

加virtual

class Person
{
public:
	string _name = "李四";
};

class Student : virtual public Person
{
protected:
	int _num; //学号
};
	
class Teacher : virtual public Person
{
	public:

	protected:
		int _id; // 职工编号
};

class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse; // 主修课程
};

int main()
{
	Assistant a;
	//如果不用虚继承就会报错，不知道调用谁的成员变量
	a._name = "张三";
	a.Student::_name = "小李";
	a.Teacher::_name = "老李";
	cout << a.Teacher::_name << endl;
	cout << a.Student::_name << endl;
	cout << a._name << endl;
	//这里为什么会显示同一个，是因为虚继承后，它们共用一份name了，所以最后对_name赋值是"老李"时，就是老李了。
	return 0;
}

所以：不用去用菱形继承！！！

例：

class Base1
{
public:
	int _b1 = 1;
};

class Base2
{
public:
	int _b2 = 2;
};

class Derive : public Base1, public Base2
{
public :
	int _d = 3;
};

int main()
{
	Derive d;
	Base1* p1 = &d;
	Base2* p2 = &d;
	Derive* p3 = &d;

	cout << p1 << endl;
	cout << p2 << endl;
	cout << p3 << endl;

	return 0;
}

00000046BB0FFB38
00000046BB0FFB3C
00000046BB0FFB38

C:\Users\Lenovo\source\repos\继承\x64\Debug\继承.exe (进程 21284)已退出，代码为 0。
按任意键关闭此窗口. . .

注意：
Derive作为最后子类，其中父类的顺序和继承的顺序有关，本题中是先继承的Base1，所以Base1在Base2上面，指针p1位置在指针p2上面，
但是如果继承的顺序发生改变，先继承Base2，后继承Base1，那么指针p2就会在指针p1上面。

12、继承与组合

1、public继承是一种is-a的关系。也就是说每个子类对象都是一个父类对象。
例：
class stack ：public list
2、组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。
例：
class stack
{
list _lt;
};
3、继承允许你根据父类的实现来定义子类的实现。这种通过生成子类的复用通常被称为白箱复用(white-box reuse)。术语"白箱"是相对可视性而言：在继承方式中，父类的内部细节对子类可见。继承一定程度破坏了父类的封装，父类的改变，对子类有很大的影响。子类和父类间的依赖关系很强，耦合度高。
4、对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用（black-box reuse),因为对象的内部细节是不可见的。对象只以"黑箱"的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
5、优先使用组合，而不是继承。实际尽量多去用组合，组合的耦合度低，代码维护性好。不过也不太那么绝对，类之间的关系就适合继承（is-a）那就用继承，另外要实现多态，也必须要继承。类之间的关系既适合用继承（is-a）也适合组合（has-a)，就用组合。
6、很多人说C+＋语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂，性能也会有一些损失，所以最好不要设计出菱形继承。多继承可以认为是C+＋的缺陷之一，后来的一些编程语言都没有多继承，如Java。

二、多态

多态（polymorphism）的概念：通俗来说，就是多种形态。多态分为编译时多态（静态多态）和运行时多态（动态多态），这里我们重点讲运行时多态，编译时多态（静态多态）和运行时多态（动态多态）。编译时多态（静态多态）主要就是我们前面讲的函数重载和函数模板，他们传不同类型的参数就可以调用不同的函数，通过参数不同达到多种形态，之所以叫编译时多态，是因为他们实参传给形参的参数匹配是在编译时完成的，我们把编译时一般归为静态，运行时归为动态。
运行时多态，具体点就是去完成某个行为（函数），可以传不同的对象就会完成不同的行为，就达到多种形态。比如买票这个行为，当普通人买票时，是全价买票；学生买票时，是优惠买票（5折或75折）；军人买票时是优先买票。再比如，同样是动物叫的一个行为（函数），传猫对象过去，就是"(>^w<)喵"，传狗对象过去，就是"汪汪"。

多态的定义及实现

(1)、多态的构成条件

多态是一个继承关系的下的类对象，去调用同一函数，产生了不同的行为。比如Student继承了Person。Person对象买票全价，Student对象优惠买票。
实现多态还有两个必须重要条件：
● 必须基类的指针或者引用调用虚函数
● 被调用的函数必须是虚函数
说明：要实现多态效果，第一：必须是基类的指针或引用，因为只有基类的指针或引用才能既指向派生类对象；第二：派生类必须对基类的虚函数重写／覆盖，重写或者覆盖了，派生类才能有不同的函数，多态的不同形态效果才能达到。

(2)、虚函数

类成员函数前面加virtual修饰，那么这个成员函数被称为虚函数。注意非成员函数不能加virtual修饰。

(3)、虚函数的重写/覆盖

虚函数的重写／覆盖：派生类中有一个跟基类完全相同的虚函数（即派生类虚函数与基类虚函数的返回值类型、函数名字、参数列表完全相同），称派生类的虚函数重写了基类的虚函数。
注意：在重写基类虚函数时，派生类的虚函数在不加virtual关键字时，虽然也可以构成重写（因为继承后基类的虚函数被继承下来了在派生类依旧保持虚函数属性），但是该种写法不是很规范，不建议这样使用，不过在考试选择题中，经常会故意买这个坑，让你判断是否构成多态。

例1：

class Person
{
public:
    //虚函数的重写
	virtual void BuyTicket()
	{
		cout << "买票-全价" << endl;
	}
};

class Student : public Person
{
public:
    //虚函数的重写
	virtual void BuyTicket()
	{
		cout << "买票-打折" << endl;
	}
};

void Func(Person* ptr)//这里是基类的指针，也可以是基类的引用
{
	//这里可以看到虽然都是Person指针ptr在调用BuyTicket
	//但是跟ptr没有关系，而是由ptr指向的对象决定的。
	ptr->BuyTicket();
}

int main()
{
	Person ps;
	Student st;
	Func(&ps);
	Func(&st);
	return 0;
}

买票-全价
买票-打折

C:\Users\Lenovo\source\repos\继承\x64\Debug\继承.exe (进程 32968)已退出，代码为 0。
按任意键关闭此窗口. . .

注意：
构成多态的两个条件缺一不可！！！！！

例2：坑！！

class Person
{
public:
	void BuyTicket()
	{
		cout << "买票-全价" << endl;
	}
};

class Student : public Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票-打折" << endl;
	}
};

void Func(Person* ptr)//这里是基类的指针，也可以是基类的引用
{
	//这里可以看到虽然都是Person指针ptr在调用BuyTicket
	//但是跟ptr没有关系，而是由ptr指向的对象决定的。
	ptr->BuyTicket();
}

int main()
{
	Person ps;
	Student st;
	Func(&ps);
	Func(&st);
	return 0;
}

买票-全价
买票-全价

C:\Users\Lenovo\source\repos\继承\x64\Debug\继承.exe (进程 7560)已退出，代码为 0。
按任意键关闭此窗口. . .

这里我们删除了基类中成员函数的virtual，这样就不满足多态的第二个条件了，所以就不是多态了
但是！！！！！

class Person
{
public:
	virtual void BuyTicket()
	{
		cout << "买票-全价" << endl;
	}
};

class Student : public Person
{
public:
	void BuyTicket()
	{
		cout << "买票-打折" << endl;
	}
};

void Func(Person* ptr)//这里是基类的指针，也可以是基类的引用
{
	//这里可以看到虽然都是Person指针ptr在调用BuyTicket
	//但是跟ptr没有关系，而是由ptr指向的对象决定的。
	ptr->BuyTicket();
}

int main()
{
	Person ps;
	Student st;
	Func(&ps);
	Func(&st);
	return 0;
}

买票-全价
买票-打折

C:\Users\Lenovo\source\repos\继承\x64\Debug\继承.exe (进程 29196)已退出，代码为 0。
按任意键关闭此窗口. . .

当我们删除了派生类成员函数中的virtual时，仍是多态，这里是一个易错点！！！！！

例3：坑！！

class A
{
public:
	virtual void func(int val = 1)
	{
		std::cout << " A -> " << val << std::endl;
	}

	virtual void test()
	{
		func();
	}
};

class B : public A
{
public:
	void func(int val = 0)
	//注意：虽然没有写virtual，但是是多态
	{
		std::cout << " B -> " << val << std::endl;
	}
};

int main(int argc, char* argv[])
{
	B* p = new B;
	p->test();
	//B去调用A中的test，因为B继承了A
	//调用A中的test，那么是A*this还是B*this？
	//在A中，所以无论是A的指针，还是B的指针，都是A*this
	//this -> func()，是否构成多态？？
	//是，因为是A*指针，基类指针，func还是重写的成员函数，所以构成多态
	//然后因为是B的指针，所以调用B中的func
	//那么在这个时候，很多人就认为输出结果会是 B -> 0
	//错！！！！！
	//重写的本质是重写虚函数的实现！！！
	//这里是A的virtual void func(int val = 1)加上B的
	//{
		//std::cout << " B -> " << val << std::endl;
	//}
	//
	return 0;
}

 B -> 1

C:\Users\Lenovo\source\repos\继承\x64\Debug\继承.exe (进程 11060)已退出，代码为 0。
按任意键关闭此窗口. . .

例4：

class A
{
public:
	virtual void func(int val = 1)
	{
		std::cout << " A -> " << val << std::endl;
	}

	virtual void test()
	{
		func();
	}
};

class B : public A
{
public:
	void func(int val = 0)
	{
		std::cout << " B -> " << val << std::endl;
	}
};

int main(int argc, char* argv[])
{
	B* p = new B;
	p -> func();
	return 0;
}

 B -> 0

C:\Users\Lenovo\source\repos\继承\x64\Debug\继承.exe (进程 29768)已退出，代码为 0。
按任意键关闭此窗口. . .

(4)、虚函数重写的一些其他问题

协变（了解）
派生类重写基类虚函数时，与基类虚函数返回值类型不同。即基类虚函数返回基类对象的指针或者引用，派生类虚函数返回派生类对象的指针或者引用时，称为协变。协变的实际意义并不大，所以我们了解一下即可。

(5)、析构函数的重写

基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加virtual关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同看起来不符合重写的规则，实际上编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成destructor，所以基类的析构函数加了virtual修饰，派生类的析构函数就构成重写。

class A
{
public:
	virtual ~A()
	{
		cout << "~A()" << endl;
	}
};

class B : public A
{
public:
	//构成重写，即使没写virtual
	~B()
	{
		cout << "~B() -> delete：" << _p << endl;
		delete _p;
	}
protected:
	int* _p = new int[10];
};

int main()
{
    //为什么析构会选择构成重写？？
	//就是为了解决类似这样的问题：
	//父类指针，可能指向父类
	A* p1 = new A;
	//有可能指向子类对象，这时候我们就希望调用子类的析构函数
	A* p2 = new B;

	//因为编译器会把析构函数的函数名统一换成destructor，所以这里就构成了基类指针+重写的成员函数，构成了重写
	delete p1;
	delete p2;
	return 0;
}

~A()
~B() -> delete：00000206F7B01170
~A()

C:\Users\Lenovo\source\repos\继承\x64\Debug\继承.exe (进程 37208)已退出，代码为 0。
按任意键关闭此窗口. . .

为什么又调用了一次A的析构函数，因为之前讲过，子类调用完析构函数后，会自动调用父类的析构函数。
上面的代码我们可以看到，如果～A()，不加virtual，那么delete p2时只调用的A的析构函数，没有调用B的析构函数，就会导致内存泄漏问题，因为～B(）中在释放资源。
注意：这个问题面试中经常考察，大家一定要结合类似下面的样例才能讲清楚，为什么基类中的析构函数建议设计为虚函数。

(6)、override和final关键字

从上面可以看出，C+＋对虚函数重写的要求比较严格，但是有些情况下由于疏忽，比如函数名写错参数写错等导致无法构成重写，而这种错误在编译期间是不会报出的，只有在程序运行时没有得到预期结果才来debug会得不偿失，因此C++11提供了override，可以帮助用户检测是否重写。如果我们不想让派生类重写这个虚函数，那么可以用final去修饰。

(7)、重载/重写/隐藏的对比

注意：
这个概念对比经常考，大家得理解记忆一下

1、重载：
两个函数在同一作用域
函数名相同，参数不同，参数类型或者个数不同，返回值可同，可不同

2、重写/覆盖：
两个函数分别在继承体系的父类和子类不同作用域
函数名，参数，返回值都必须相同，协变例外
两个函数都必须是虚函数

3、隐藏：
两个函数分别在继承体系的父类和子类不同作用域
函数名相同
两个函数都只要不构成重写，就是隐藏
父子类的成员变量相同也叫做隐

(8)、纯虚函数和抽象类

在虚函数的后面写上 = 0 ，则这个函数为纯虚函数，纯虚函数不需要定义实现（实现没啥意义因为要被派生类重写，但是语法上可以实现），只要声明即可。包含纯虚函数的类叫做抽象类，抽象类不能实例化出对象，如果派生类继承后不重写纯虚函数，那么派生类也是抽象类。纯虚函数某种程度上强制了派生类重写虚函数，因为不重写实例化不出对象。

class Car
{
public:
	//纯虚函数
	virtual void Drive() = 0;
};

class Benz : public Car
{
public:

};

int main()
{
	//抽象类不能实例化
	Car c;
	//b也是抽象类，只要继承了抽象类，且不去重写虚函数，就还是抽象类
	Benz b;
	return 0;
}

错误	C2259	“Benz”: 无法实例化抽象类	
错误	C2259	“Car”: 无法实例化抽象类
错误(活动)	E0322	不允许使用抽象类类型 "Benz" 的对象:	
错误(活动)	E0322	不允许使用抽象类类型 "Car" 的对象:

修改后：

class Car
{
public:
	//纯虚函数
	virtual void Drive() = 0;
};

class Benz : public Car
{
public:
	virtual void Drive()
	{
		cout << "Benz" << endl;
	}
};

int main()
{
	//抽象类不能实例化
	//Car c;
	//b也是抽象类，只要继承了抽象类，且不去重写虚函数，就还是抽象类
	Benz b;
	return 0;
}


C:\Users\Lenovo\source\repos\继承\x64\Debug\继承.exe (进程 9072)已退出，代码为 0。
按任意键关闭此窗口. . .

抽象类还有用处：

class Car
{
public:
	//纯虚函数
	virtual void Drive() = 0;
};

class Benz : public Car
{
public:
	virtual void Drive()
	{
		cout << "Benz" << endl;
	}
};

class BMW : public Car
{
public:
	virtual void Drive()
	{
		cout << "BEW" << endl;
	}
};
int main()
{
    //可以做指针
	Car* pBenz = new Benz;
	pBenz->Drive();
	Car* pBMW = new BMW;
	pBMW->Drive();
	return 0;
}

Benz
BEW

C:\Users\Lenovo\source\repos\继承\x64\Debug\继承.exe (进程 40196)已退出，代码为 0。
按任意键关闭此窗口. . .

(9)、虚函数表指针

class Base
{
public:
	virtual void Func1()
	{
		cout << "Func1()" << endl;
	}
protected:
	int _b = 1;
	char _ch = 'x';
};

int main()
{
	Base b;
	cout << sizeof(b) << endl;
	return 0;
}

12

C:\Users\Lenovo\source\repos\继承\Debug\继承.exe (进程 7464)已退出，代码为 0。
按任意键关闭此窗口. . .

上面题目运行结果12bytes，除了＿b和＿ch成员，还多一个＿vfptr放在对象的前面（注意有些平台可能会放到对象的最后面，这个跟平台有关），对象中的这个指针我们叫做虚函数表指针（v代表virtual,f代表function)。一个含有虚函数的类中都至少都有一个虚函数表指针，因为一个类所有虚函数的地址要被放到这个类对象的虚函数表中，虚函数表也简称虚表。
虚函数表：
是一个数组，一个指针数组，一个函数指针数组

(10)、动态绑定与静态绑定

对不满足多态条件（指针或者引用＋调用虚函数）的函数调用是在编译时绑定，也就是编译时确定调用函数的地址，叫做静态绑定。
满足多态条件的函数调用是在运行时绑定，也就是在运行时到指向对象的虚函数表中找到调用函数的地址，也就做动态绑定。

(11)、虚函数表

1、基类对象的虚函数表中存放基类所有虚函数的地址。同一个类定义的不同对象的虚函数表是一样的。/2派生类由两部分构成，继承下来的基类和自己的成员，一般情况下，继承下来的基类中有虚函数表指针，自己就不会再生成虚函数表指针。但是要注意的这里继承下来的基类部分虚函数表指针和基类对象的虚函数表指针不是同一个，就像基类对象的成员和派生类对象中的基类对象成员也独立的。
3、派生类中重写的基类的虚函数，派生类的虚函数表中对应的虚函数就会被覆盖成派生类重写的虚函数地址。
4、派生类的虚函数表中包含，基类的虚函数地址，派生类重写的虚函数地址，派生类自己的虚函数地址三个部分。
5、虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个0x00000000标记。（这个C+＋并没有进行规定，各个编译器自行定义的，vs系列编译器会再后面放个0x00000000标记，g+＋系列编译不会放）
6、虚函数存在哪的？虚函数和普通函数一样的，编译好后是一段指令，都是存在代码段的，只是虚函数的地址又存到了虚表中。
7、虚函数表存在哪的？这个问题严格说并没有标准答案C+＋标准并没有规定，我们写下面的代码可以对比验证一下。vs下是存在代码段（常量区）

class Base 
{
public:
	virtual void func1() 
	{ 
		cout << "Base::func1" << endl; 
	}
	virtual void func2() 
	{ 
		cout << "Base::func2" << endl; 
	}
	void func5() 
	{ 
		cout << "Base::func5" << endl; 
	}
protected:
	int a = 1;
};

class Derive : public Base
{
public:
	// 重写基类的func1
	virtual void func1() 
	{ 
		cout << "Derive::func1" << endl; 
	}
	virtual void func3() 
	{ 
		cout << "Derive::func1" << endl; 
	}
	void func4() 
	{ 
		cout << "Derive::func4" << endl; 
	}

protected:
	int b = 2;
};


int main()
{
	int i = 0;
	static int j = 1;
	int* p1 = new int;
	const char* p2 = "xxxxxxxx";
	printf("栈:%p\n", &i);
	printf("静态区:%p\n", &j);
	printf("堆:%p\n", p1);
	printf("常量区:%p\n", p2);


	Base b;
	Derive d;
	Base* p3 = &b;
	Derive* p4 = &d;
	printf("Person虚表地址:%p\n", *(int*)p3);
	printf("Student虚表地址:%p\n", *(int*)p4);
	printf("虚函数地址:%p\n", &Base::func1);
	printf("普通函数地址:%p\n", &Base::func5);
	return 0;
}

栈:0095FC20
静态区:0038D000
堆:00D45CC8
常量区:0038AB94
Person虚表地址:0038AB34
Student虚表地址:0038AB74
虚函数地址:00381474
普通函数地址:003814B0

C:\Users\Lenovo\source\repos\继承\Debug\继承.exe (进程 40128)已退出，代码为 0。
按任意键关闭此窗口. . .