------------------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】
