多继承和多重继承

时间：2022-09-07 19:08:24

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

   

   

   

   

   

   

   

   

   

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

   

   

多重继承

   

   

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

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

   

多继承和多重继承

   

   

   

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

存在着以下的关系：

   

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

   

多继承和多重继承

   

   

   

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

   

多继承和多重继承

   

   

   

   

   

多继承

   

   

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

称之为 农民工类

   

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

关系称之为 多继承

   

多继承和多重继承

   

   

   

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

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

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

   

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

   

多继承和多重继承

   

   

   

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

   

多继承和多重继承

   

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

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

   

   

   

   

   

程序 1：多重继承

   

Person.h：

   

#include <string>

using namespace std;

   

   

class Person

{

public:

Person(string name = "Jim");

~Person();

void play();

protected:

string m_strName;

};

   

   

   

Person.cpp：

   

#include "Person.h"

#include <iostream>

using namespace std;

   

   

Person::Person(string name)

{

m_strName = name;

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

}

   

Person::~Person()

{

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

}

   

void Person::play()

{

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

cout << m_strName << endl;

}

   

   

   

Soldier.h：

   

#include "Person.h"

class Soldier:public Person

{

public:

Soldier(string name = "James", int age = 20);

~Soldier();

void work();

protected:

int m_iAge;

};

   

   

   

Soldier.cpp：

   

#include "Soldier.h"

#include <iostream>

using namespace std;

   

   

Soldier::Soldier(string name, int age)

{

m_strName = name;

m_iAge = age;

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

}

   

Soldier::~Soldier()

{

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

}

   

void Soldier::work()

{

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

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

}

   

   

   

Infantry.h：

   

#include "Soldier.h"

   

class Infantry:public Soldier

{

public:

Infantry(string name = "Jack", int age = 30);

~Infantry();

void attack();

   

};

   

   

   

Infantry.cpp：

   

#include "Infantry.h"

#include <iostream>

using namespace std;

   

   

Infantry::Infantry(string name, int age)

{

m_strName = name;

m_iAge = age;

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

}

   

Infantry::~Infantry()

{

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

}

   

void Infantry::attack()

{

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

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

}

   

   

   

main.cpp：

   

#include <stdlib.h>

#include "Infantry.h"

#include <iostream>

using namespace std;

   

   

void test1(Person p)

{

p.play();

}

   

void test2(Person &p)

{

p.play();

}

   

void test3(Person *p)

{

p->play();

}

   

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

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

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

int main(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");

return 0;

}

   

   

运行一览：

   

多继承和多重继承

   

   

   

   

   

程序 2：多继承

   

Farmer.h：

   

#include <string>

using namespace std;

   

   

class Farmer

{

public:

Farmer(string name = "Jack");

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

void sow();

protected:

string m_strName;

};

   

   

   

Farmer.cpp：

   

#include "Farmer.h"

#include <iostream>

using namespace std;

   

   

Farmer::Farmer(string name)

{

m_strName = name;

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

}

   

Farmer::~Farmer()

{

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

}

   

void Farmer::sow()

{

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

cout << m_strName << endl;

}

   

   

   

Worker.h：

   

#include <string>

using namespace std;

   

   

class Worker

{

public:

Worker(string code = "001");

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

void work();

protected:

string m_strCode;

};

   

   

   

Worker.cpp：

   

#include "Worker.h"

#include <iostream>

using namespace std;

   

   

Worker::Worker(string code)

{

m_strCode = code;

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

}

   

Worker::~Worker()

{

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

}

   

void Worker::work()

{

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

cout << m_strCode << endl;

}

   

   

   

MigrantWorker.h：

   

#include "Farmer.h"

#include "Worker.h"

   

class MigrantWorker :public Farmer, public Worker

{

public:

MigrantWorker(string name, string code);

virtual ~MigrantWorker();

};

   

   

   

MigrantWorker.cpp：

   

#include "MigrantWorker.h"

#include <iostream>

using namespace std;

   

   

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

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

{

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

}

   

MigrantWorker::~MigrantWorker()

{

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

}

   

   

   

main.cpp：

   

#include <stdlib.h>

#include "MigrantWorker.h"

#include <iostream>

using namespace std;

   

   

int main(void)

{

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

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

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

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

cout << endl;

p->sow();

p->work();

cout << endl;

delete p;

p = NULL;

system("pause");

return 0;

}

   

   

运行一览：

   

多继承和多重继承

   

   

   

   

   

   

   

   

【made by siwuxie095】

标签：

相关文章