CPP语法(五)——类的继承

参考链接
系列链接: CPP语法(一)——数组/字符串
系列链接: CPP语法(二)——指针
系列链接: CPP语法(三)——结构体/共用体
系列链接: CPP语法(四)——类的声明和定义
系列链接: CPP语法(五)——类的继承

一、继承

继承方式有三种，public、private、protected

不管是什么继承方式，父类中的私有属性都无法直接访问，只能通过get、set访问

使用public继承，那么父类中的public、private、protected在子类中维持原来的修饰符；

使用protected继承，那么父类中的public、protected在子类中变为protected修饰，让子类的子类可以继续访问，无限向下传播；

使用private继承，那么父类中的public和protected在派生类中可以访问，父类中private数据成员不能访问。

1.1 子类显示调用父类构造函数

当父类只有带参数的构造函数时，子类才能以显示方法调用父类带参数的构造函数，否则编译将出现错误。

#include <iostream>
using namespace std;
class CEmployee										//定义CEmployee类
{
public:
	int m_ID;											//定义数据成员
	char m_Name[128];									//定义数据成员
	char m_Depart[128];									//定义数据成员
	CEmployee(char name[])								//带参数的构造函数
	{
		strcpy(m_Name,name);
		cout << m_Name<<"调用了CEmployee类带参数的构造函数"<< endl;	
	}
	CEmployee()										//无参构造函数
	{
		strcpy(m_Name,"MR");
		cout << m_Name<<"CEmployee类无参构造函数被调用"<< endl;		
	}
	~CEmployee()										//析构函数
	{
		cout << "CEmployee类析构函数被调用"<< endl;		//输出信息
	}
};
class COperator :public CEmployee							//从CEmployee类派生一个子类
{
public:
	char m_Password[128];								//定义数据成员
	COperator(char name[ ]):CEmployee(name)				//显示调用父类带参数的构造函数
	{		//设置数据成员
		cout << "COperator类构造函数被调用"<< endl;			//输出信息
	}
	COperator():CEmployee("JACK")						//显示调用父类带参数的构造函数
	{		//设置数据成员
		cout << "COperator类构造函数被调用"<< endl;			//输出信息
	}
	~COperator()										//析构函数
	{
		cout << "COperator类析构函数被调用"<< endl;			//输出信息
	}
};
int main(int argc, char* argv[])								//主函数
{
	COperator optr1;						//定义一个COperator对象，调用自身无参构造函数
	COperator optr2("LaoZhang");           //定义一个COperator对象，调用自身带参数构造函数
	return 0;
}

1.2 子类显示调用父类成员函数

如果子类中的成员函数与父类的名字一样，子类调用时会默认调用子类自己的成员函数，要想调用父类的该同名函数，则需要在调用时，方法前面添加父类作用域。

如果子类重载父类函数，既子类中有父类的同名函数，子类将屏蔽所有的父类同名函数不管父类重载了几次，父类中所有重名函数都被屏蔽，无法通过子类显示调用。

class Fu
{
    public:
    void test();
};
class Zi :public Fu
{
    public:
    void test();
};

void main()
{
    Zi z1;
    z1.test();		//默认调用子类的成员函数
    z1.Fu::test();	//显示调用父类的成员函数
}

1.3 重载运算符

运算符实际上是一个函数，运算符的重载是函数的重载。

operator 类型名();

重载 + 号运算符

#include <iostream>
using namespace std;
class CBook
{
public:
	CBook (int iPage)
	{
		m_iPage=iPage;
	}
	CBook operator+( CBook b)
	{
		return CBook (m_iPage+b.m_iPage);
	}
	void display()
	{
		cout << m_iPage << endl;
	}
protected:
	int m_iPage;
};

void main()
{
	CBook bk1(10);
	CBook bk2(20);
	CBook tmp(0);
	tmp= bk1+bk2;
	tmp.display();
}

上面案例中的 + 号左右两边因为是相同的类型，所以可以交换左右的顺序。

operator + () 没有参数代表前置运算，要求前面的值，

operator + (int) 有参数代表后置运算，要求后面的值。

operator ++ () 没有参数代表前置运算，要求前面的值，

operator ++ (int) 有参数代表后置运算，要求后面的值。

下方的案例交换左右顺序是错误的：

#include <iostream>
using namespace std;
class CBook
{
public:
    int m_Pages;
    void OutputPages()
    {
        cout<<m_Pages<<endl;
    }
    CBook()
    {
        m_Pages = 0;
    }
    CBook operator + (const int page)
    {
        CBook bk;
        bk.m_Pages = m_Pages + page;
        return bk;
    }
};

void main()
{
	CBook vbBook,vfBook;
    vfBook =  vbBook + 10;		//这里交换为 10 + vbBook 是错误的
    vfBook.OutputPages();
}

1.4 转换运算符

c++语言中普通的数据类型可以进行强制类型转换。

int i= 10;
double d;
d =(double) i;
//等同于下面的
d = double(i);

1.4.1 自定义类的强制转换重载

#include "stdafx.h"
#include <iostream>

/*
  设计鸟类和动物类，创建一个鸟对象，将鸟对象强制转换为动物对象。
*/

using namespace std;

class CAnimal
{
public:
  CAnimal(const char * name) {
    strcpy(this->name, name);
  }
  CAnimal(const CAnimal& other) {
    if(this != &other) {
      strcpy(this->name, other.name);
    }
  }
  char name[64];
};


class CBird{
public:
  CBird(const char * name)
  {
    strcpy(this->name, name);
  }
  operator CAnimal() const
  {
    cout << this->name << "张张！" << endl;
    return CAnimal(this->name);
  }
  char name[64];
};
 
int main(int argc, char* argv[])
{
  CBird bid("张伟");
  CAnimal ani = (CAnimal)bid;
  return 0;
}

1.5 多继承

#include <iostream>
using namespace std;
class CBicycle
{
public:
	CBicycle()
	{
		cout << "Bicycle Construct" << endl;
	}
	CBicycle(int iWeight)
	{
		m_iWeight=iWeight;
	}
	void Run()
	{
		cout << "Bicycle Run" << endl;
	}

protected:
	int m_iWeight;
};

class CAirplane
{
public:
	CAirplane()
	{
		cout << "Airplane Construct " << endl;
	};
	CAirplane(int iWeight)
	{
		m_iWeight=iWeight;
	}
	void Fly()
	{
		cout << "Airplane Fly " << endl;
	}

protected:
	int m_iWeight;
};

class CAirBicycle : public CBicycle, public CAirplane
{
public:
	CAirBicycle()
	{
		cout << "CAirBicycle Construct" << endl;
	}
	void RunFly()
	{
		cout << "Run and Fly" << endl;
	}
};
void main()
{
	CAirBicycle ab;
	ab.RunFly();
}

1.6 多态

多态性是指具有不同功能的函数可以用同一个函数名。

多态性通过联编实现。

联编是指一个计算机程序自身彼此关联的过程。

按照进行的阶段不同，联编可以分为静态联编和动态联编。

在c++中，根据联编的时刻不同，存在两种类型的多态性，即函数重载和虚函数。

1.6.1 虚函数

重写虚函数时，函数原型必须保持一致。例如，基类为int类型，子类重写时也必须为int类型

虚函数有以下几方面的限制：

1.只有类的成员函数才能成为虚函数

2.静态成员函数不能是虚函数，因为静态成员函数不受限与某个对象

3.内联函数不能是虚函数，因为内联函数不能在运行中动态确定其位置

4.构造函数不能是虚函数，析构函数通常是虚函数

1.6.2 虚继承

虚继承解决菱形继承问题

1.7 抽象类

包含有纯虚函数的类称为抽象类，一个抽象类至少具有一个纯虚函数。

抽象类只能作为基类派生出新的子类，而不能在程序中被实例化，但是可以使用指向抽象类的指针。

一名软件构造师可以通过纯虚函数建立接口，让程序员填写代码实现接口，而自己主要负责建立抽象类。

1.7.1 纯虚函数

pure virtual function 纯虚函数是被标明为不具体实现的虚成员函数，它不具备函数的功能。

纯虚函数声明

virtual 类型 函数名(参数表列) = 0;

纯虚函数不能被继承，当基类是抽象类时，在派生类中必须给出基类中纯虚函数的定义，或在该类中再声明其为纯虚函数。只有在派生类中给出基类所有纯虚函数的实现时，该派生类才不再为抽象类。

参考链接
系列链接: CPP语法(一)——数组/字符串
系列链接: CPP语法(二)——指针
系列链接: CPP语法(三)——结构体/共用体
系列链接: CPP语法(四)——类的声明和定义
系列链接: CPP语法(五)——类的继承