C++继承5 多重继承、多继承

一、概念

多重继承：当B类从A类派生，C类从B类派生，此时称为多重继承

多继承：多继承是指一个子类继承多个父类。多继承对父类的个数没有限制，继承方式可以是公共继承、保护继承和私有继承。若不写继承方式，默认是private继承。

二、代码演示

多重继承

#include<iostream>
#include<string>
using namespace std;

/*多重继承: 
         1.Person类，数据成员：m_strName 成员函数：构造、析构、pay()
	 2.Soldier类，数据成员：m_iAge 成员函数：构造、析构、work()
	 3.Infantry类，数据成员：无 成员函数：构造、析构、attack()
	 4.定义函数test1(Person p) test2(Person &p) test3(Person *p)
*/

//虚析构函数 当存在继承关系的时候，使用父类的指针去指向堆中的子类的对象
//并且还需要父类的指针去释放这块内存的时候就需要虚析构函数

class Person
{
public:
	Person(string name = "v")
	{
		m_strName = name;
		cout<<"Person()"<<endl;
	}

	virtual ~Person()
	{
		cout<<"~Person()"<<endl;
	}	
	void play()
	{
		cout<<"Person--play()"<<endl;
		cout<<m_strName<<endl;
	}
protected:
	string m_strName;
};


class Soldier:public Person
{
public:
	Soldier(string name = "wls",int age = 20)
	{
		m_strName = name;
		m_iAge = age;
		cout<<"Soldier"<<endl;
	}
	virtual ~Soldier()
	{
		cout<<"~Soldier"<<endl;
	}
	void work()
	{
		cout<<m_strName<<endl;
		cout<<m_iAge<<endl;
		cout<<"Soldier--work()"<<endl;
	}
	
protected:
	int m_iAge;
};


class Infantry:public Soldier
{
public:
	Infantry(string name = "Jack",int age = 30)
	{
		m_strName = name;
		m_iAge = age;
		cout<<"Infantry()"<<endl;
	}

	~Infantry()
	{
		cout<<"~Infantry()"<<endl;
	}

	void attack()
	{
		cout<<m_strName<<endl;
		cout<<m_iAge<<endl;
		cout<<"Soldier--work()"<<endl;
	}

};


void test1(Person p)//参数是对象p,传值的时候先实例化一个临时对象p,所以执行完后要销毁
{
	p.play();
}

void test2(Person &p)//使用基类的引用也可以接收基类的对象和派生类的对象  
{
	p.play();
}

void test3(Person *p)//参数是一个基类的指针
{
	p->play();
}

int main(void)
{
	Infantry infantry;

	test1(infantry);
	test2(infantry);
	test3(&infantry);
	/***********************************************************
	无论继承的层级有多少层，他们只要保持着直接或者间接的继承关系，
	那么子类都可以与自己的直接父类或者间接父类称之为“is a”的关系，
	并且能通过父类的指针对直接子类或者间接子类的对象进行相应的操作
	************************************************************/
	return 0;
}
           

运行结果：

（1）当实例化子类时，会首先依次调用所有基类的构造函数，最后调用该子类的构造函数；销毁该子类时，则相反，先调用该子类的析构函数，再依次调用所有基类的析构函数。

（2）无论继承的层级有多少层，只要它们保持着直接或间接的继承关系，那么子类都可以与其直接父类或间接父类构成 is a的关系，并且能够通过父类的指针对直接子类或间接子类进行相应的操作。

多继承

#include<iostream>
#include<string>
using namespace std;

/*
多继承
  1.Famer类，数据成员：m_strName,成员函数：构造、析构、sow()
  2.Worker类，数据成员：m_strCode,成员函数：构造、析构、carry()
  3.MigrantWorker类，数据成员：无，成员函数：构造、析构
*/

class Farmer
{
public:
	Farmer(string name)
	{
		m_strName = name;
		cout<<"Farmer()"<<endl;
	}

	~Farmer()
	{
		cout<<"~Farmer()"<<endl;
	}

	void sow()
	{
		cout<<m_strName<<endl;
		cout<<"Farmer--sow()"<<endl;
	}
protected:
	string m_strName;
};

class Worker
{
public:
	Worker(string code)
	{
		m_strCode = code;
		cout<<"Worker()"<<endl;
	}

	~Worker()
	{
		cout<<"~Worker()"<<endl;
	}

	void carry()
	{
		cout<<m_strCode<<endl;
		cout<<"Worker--carry()"<<endl;
	}
protected:
	string m_strCode;
};


class MigrantWorker:public Farmer,public Worker//多继承 
{
public:
	MigrantWorker(string name,string code):Farmer(name),Worker(code)//多继承 
	{
		cout<<"MigrantWorker()"<<endl;
	}

	~MigrantWorker()
	{
		cout<<"~MigrantWorker()"<<endl;
	}
};


int main(void)
{
	MigrantWorker *p = new MigrantWorker("Merry","100");
	p->sow();
	p->carry();

	delete p;
	p = NULL;

	return 0;
}
           

运行结果：

由输出结果可以看出，在多继承中，子类可以调用多个父类的成员函数，在实例化子类时，先根据继承的顺序依次调用父类的构造函数，然后再调用该子类自己的构造函数。