一、继承
继承方式有三种，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;
纯虚函数不能被继承，当基类是抽象类时，在派生类中必须给出基类中纯虚函数的定义，或在该类中再声明其为纯虚函数。只有在派生类中给出基类所有纯虚函数的实现时，该派生类才不再为抽象类。
