------------------siwuxie095

多继承 和 多重继承，两个词差别不大，但是差之毫厘、谬以千里 …

多重继承

如果有这样三个类：人类、士兵类、步兵类，其中：士兵类继承了人类，

步兵类继承了士兵类，这三个类之间的关系称之为多重继承

如果在继承时，这三个类都使用了 public 公有继承，那么它们也

存在着以下的关系：

士兵是一个人，步兵是一个士兵，步兵也是一个人

具体到代码上，可以这样来写：

多继承

如果有一个类，不仅继承了工人类，还继承了农民类，暂且把这个类

称之为 农民工类

即 一个子类同时有两个父类，或 一个派生类同时有两个基类，这样的

关系称之为多继承

多继承和多重继承是完全不同的，在多继承的关系下，如果农民工类

在继承工人类和农民类时，都以 public 公有继承的方式继承，那么

它们还存在着这样一种关系：

农民工是一个工人，农民工是一个农民，但工人和农民本身是平行的

具体到代码上，可以这样来写：

注意：写法上，中间要加逗号隔开，在继承每一个类时，都要将继承

方式写出来，如果不写，系统默认继承方式为 private 私有继承

程序 1：多重继承

Person.h：

#include

using namespacestd;

classPerson

{

public:

Person(string name = "Jim");

~Person();

voidplay();

protected:

string m_strName;

};

Person.cpp：

#include"Person.h"

#include

using namespacestd;

Person::Person(string name)

{

m_strName = name;

cout << "Person()"<< endl;

}

Person::~Person()

{

cout << "~Person()"<< endl;

}

voidPerson::play()

{

cout << "Person--play()"<< endl;

cout << m_strName << endl;

}

Soldier.h：

#include"Person.h"

classSoldier:publicPerson

{

public:

Soldier(string name = "James", intage = 20);

~Soldier();

voidwork();

protected:

intm_iAge;

};

Soldier.cpp：

#include"Soldier.h"

#include

using namespacestd;

Soldier::Soldier(string name, intage)

{

m_strName = name;

m_iAge = age;

cout << "Soldier()"<< endl;

}

Soldier::~Soldier()

{

cout << "~Soldier()"<< endl;

}

voidSoldier::work()

{

cout << "Soldier--work()"<< endl;

cout << m_strName << ","<< m_iAge << endl;

}

Infantry.h：

#include"Soldier.h"

classInfantry:publicSoldier

{

public:

Infantry(string name = "Jack", intage = 30);

~Infantry();

voidattack();

};

Infantry.cpp：

#include"Infantry.h"

#include

using namespacestd;

Infantry::Infantry(string name, intage)

{

m_strName = name;

m_iAge = age;

cout << "Ifantry()"<< endl;

}

Infantry::~Infantry()

{

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

}

voidInfantry::attack()

{

cout << "Infantry--attack()"<< endl;

cout <

}

main.cpp：

#include

#include"Infantry.h"

#include

using namespacestd;

voidtest1(Person p)

{

p.play();

}

voidtest2(Person &p)

{

p.play();

}

voidtest3(Person *p)

{

p->play();

}

//无论继承的层级有多少，只要保持着直接或间接的继承关系，

//子类都可以与自己的直接父类或间接父类称为is-a关系

//并且能够通过指针对直接子类或间接子类的对象进行相应的操作

intmain(void)

{

Infantry infantry;

cout << endl;

infantry.play();

infantry.work();

infantry.attack();

cout << endl;

test1(infantry);

cout << endl;

test2(infantry);

cout << endl;

test3(&infantry);

system("pause");

return0;

}

运行一览：

程序 2：多继承

Farmer.h：

#include

using namespacestd;

classFarmer

{

public:

Farmer(string name = "Jack");

virtual~Farmer();//虚析构函数

voidsow();

protected:

string m_strName;

};

Farmer.cpp：

#include"Farmer.h"

#include

using namespacestd;

Farmer::Farmer(string name)

{

m_strName = name;

cout << "Farmer()"<< endl;

}

Farmer::~Farmer()

{

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

}

voidFarmer::sow()

{

cout << "Farmer--sow()"<< endl;

cout << m_strName << endl;

}

Worker.h：

#include

using namespacestd;

classWorker

{

public:

Worker(string code = "001");

virtual~Worker();//虚析构函数

voidwork();

protected:

string m_strCode;

};

Worker.cpp：

#include"Worker.h"

#include

using namespacestd;

Worker::Worker(string code)

{

m_strCode = code;

cout << "Worker()"<< endl;

}

Worker::~Worker()

{

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

}

voidWorker::work()

{

cout << "Worker--work()"<< endl;

cout << m_strCode << endl;

}

MigrantWorker.h：

#include"Farmer.h"

#include"Worker.h"

classMigrantWorker :publicFarmer, publicWorker

{

public:

MigrantWorker(string name, string code);

virtual~MigrantWorker();

};

MigrantWorker.cpp：

#include"MigrantWorker.h"

#include

using namespacestd;

//使用初始化列表初始化

MigrantWorker::MigrantWorker(string name, string code) :Farmer(name), Worker(code)

{

cout << "MigrantWorker()"<< endl;

}

MigrantWorker::~MigrantWorker()

{

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

}

main.cpp：

#include

#include"MigrantWorker.h"

#include

using namespacestd;

intmain(void)

{

//从堆中实例化子类对象，先调用父类构造函数再调用子类构造函数

//调用父类构造函数的顺序和初始化列表中的顺序一样

//析构函数的调用顺序则相反

MigrantWorker *p = newMigrantWorker("Merry", "100");

cout << endl;

p->sow();

p->work();

cout << endl;

deletep;

p = NULL;

system("pause");

return0;

}

运行一览：

【made by siwuxie095】