C++继承与派生解析（继承、重载/转换运算符、多重继承、多态、虚函数/纯虚函数、抽象类）

文末附有测试源码 如需自取

1:继承 是面向对象编程的三大特性之一 它使得一个类可以从另一个类中派生，减少代码量。

class 类名 : 继承方式 基类名标识符
实例如下
class rectangle :public figure

不同的继承方式那么访问基类中变量的权限也不同

子类与父类的构造函数访问顺序是：先访问父类构造函数，再访问子类构造函数

2：重载运算符

重载运算符可以将你想要的运算符重载成你想要的计算方法

语法如下

operator 类型名()；
实例如下
 cbook operator+(cbook b);
return cbook(m_ipage+b.m_ipage);

此处重载了+运算符，使得两个对象可以像两个整型变量一样相加

3：转换运算符

即可以强制转换数据类型  下面将double类型强制转换为int类型

double i=52.052;
int d;
d=int(i);

4：多重继承

顾名思义，一个类可以继承多个类，但实际操作容易出问题，不建议用，主流的语言如java就不支持多继承

语法如下

class 类名:继承方式 基类名,继承方式 基类名...

5：多态 多态也是面向对象编程三大特性之一，其特点是同样的消息被不同类型对象接收时可以有不同的实现

多态主要用虚函数实现 虚函数用virtual关键字来声明 一般在基类中定义虚函数，然后在派生类中具体实现虚函数

纯虚函数 是指被表明不具体实现的虚成员函数 起到一个接口的作用

声明如下 virtual 类型 函数名(参数)=0;

纯虚函数不可以被继承，派生类必须给出基类中纯虚函数的定义

6：抽象类 包含有纯虚函数的类称为抽象类 抽象类一般只作为基类派生出其他的子类 并且不可以实例化，但是可以使用指向抽象类的指针

下面是一些测试源码 如需自取

#include<iostream>
using namespace std;
class employee {
public:
	int id;
	char name[128];
	char depart[128];
	virtual void outputname() = 0;//纯虚函数 后面有个=0

};
class copreator :public employee {
public:
	char password[128];
	void outputname() {
		cout << "操作员姓名：" << name << endl;
	}
	copreator() {
		strcpy_s(name, "玫瑰少年");
	}
};
class systemmananger :public employee {
public:
	char passwordp[128];
	void outputname()
	{
		cout << "系统管理员姓名:" << name << endl;
	}
	systemmananger() {
		strcpy_s(name, "张三");
	}

};
class figure {
public:
	virtual double getarea() = 0;//纯虚函数 不具体实现 其实现留给派生类去做 提供一个接口的作用
	//因为图形类面积计算方法不确定 所以定义为纯虚函数
};
const double pi = 3.14;
class circle :public figure {
private:
	double radius;
public:
	circle(double dr) { radius = dr; }
	double getarea() {
		return radius * radius * pi;
	}
};
class rectangle :public figure {
protected:
	double height, width;
public:
	rectangle(double dheight, double dwidth) {
		height = dheight;
		width = dwidth;
	}
	double getarea() {
		return height * width;
	}

};
int main() {
	figure* fg1;
	fg1 = new rectangle(4.3, 5.2);
	cout << fg1->getarea() << endl;
	delete fg1;
	figure* fg2;
	fg2 = new circle(4.6);
	cout << fg2->getarea() << endl;
	delete fg2;
	employee* pworker;//定义指针对象
	pworker = new copreator();//调用它的构造函数为pworker赋值
	pworker->outputname();//调用coperator类的成员函数
	delete pworker;//释放且设置为空
	pworker = NULL;
	pworker = new systemmananger();//调用另一个子类的构造函数为它赋值
	pworker->outputname();//调用这个子类的成员函数
	delete pworker;//释放且设置为空
	pworker = NULL;
	return 0;
	//同样的语句 pworker->outputname（）由于pworker指向的对象不同 所以其行为也不同 这实际上就是多态

}