【C++ Primer】第十三章 类继承

一，类继承

        定义：从已有的类派生出新的类，而派生类继承了原有类的特征，包括方法。

        目标：提供可重用的代码

二，一个简单的基类

<strong><span style="font-size:18px;">#include <iostream>

#include <cstring>

using namespace std;

class student      //基类

{

private:

char name[20];

int num;

int age;

public:

student(const char *m_name,const int m_num,const int m_age);

~student();

virtual void display();//派生类有重载 故采用虚函数形式

};

class graduate:public student  //派生类    注意写法

char major[20];

int thesis;

graduate(const char *m_major,const int m_thesis,student &st);

~graduate();

void display();

void setThesis(int i);  

student::student(const char *m_name,const int m_num,const int m_age)

strcpy(name,m_name);

num=m_num;

age=m_age;

}

student::~student()

cout<<"student is over"<<endl;

void student::display()

cout<<"name:"<<name<<"\nnum:"<<num<<"\nage"<<age<<endl;

graduate::graduate(const char* m_major, const int m_thesis, student& st):student(st)

{ //特别注意：由于派生类不能直接使用基类私有成员，所以必须使用基类构造函数

st.display();

strcpy(major,m_major);

thesis=m_thesis;

graduate::~graduate()

cout<<"graduate is over"<<endl;

void graduate::display()

cout<<"major:"<<major<<"\nthesis:"<<thesis<<endl;

void graduate::setThesis(int i)

thesis=i;

int main()

student st("tianshuai",1,18);

cout<<"**************\n";

graduate gd("compuater",5,st);

gd.display();

return 0;

</span></strong>输出：<strong><span style="font-size:18px;">name:tianshuainum:1

age18

**************

name:tianshuai

num:1

major:compuater

thesis:5

graduate is over

student is over

</span></strong>

【简介】1）继承类 继承了基类的私有成员，但是不能通过继承类的对象直接访问私有成员

               2）派生类不能直接访问基类私有成员，派生类构造函数必须使用基类构造函数

               3）派生类构造函数特点：基类对象首先被创建  创建graduate   gd(); student 对象先被创建

                                                           创建派生类对象时，先调用基类构造函数，再调用派生类构造函数

                                                            派生类对象过期时，先析构派生类，再析构基类

              4）不能讲基类对象和地址赋给派生类 

                        student st;

                        graduate  &gd=st;  //  Not  Allow

                        graduate  *gd=st;   //  Not  Allow

                    如果允许的话，则基类可以访问派生类成员，但访问基类没有的成员，对于基类对象来说是没有意义的

                        st.setThesis(int i)   //因为基类没有该方法

三，继承----- is-a 关系

        继承方式：共有继承、私有继承、保护继承

        共有继承建立一种is-a关系:派生类对象也是一个基类对象，可以对基类对象执行的任何操作，也可以对派生类对象执行

        例如：Fruit 是水果类，有重量和热量。Banana是派生类，包含重量和热量外，还添加专门香蕉成员，这些成员通常不用于Fruit.

四，多态共有继承

        两种实现机制：1>在派生类中重新定义基类方法。2>使用虚方法

        不存在虚拟构造函数，但基类的虚拟析构函数是必要的。请看下例：<strong><span style="font-size:18px;">class ClxBase{public:

ClxBase(){cout << "Output from the con ClxBase!" << endl;};

virtual ~ClxBase(){cout << "Output from the destructor of class ClxBase!" << endl;};

virtual void DoSomething(){ cout << "Do something in class ClxBase!" << endl; };

class ClxDerived : public ClxBase{

ClxDerived() {cout << "Output from the con ClxDerived!" << endl;};

~ClxDerived() { cout << "Output from the destructor of class ClxDerived!" << endl; };

void DoSomething() { cout << "Do something in class ClxDerived!" << endl; };

void main()

<span style="color:#ff0000;">ClxBase</span> *pTest = new <span style="color:#ff0000;">ClxDerived</span>; //基类的指针 引用派生类对象

pTest->DoSomething(); //调用派生类的方法

delete pTest;

}</span></strong>

输出：Do something in class ClxDerived!

           Output from the destructor of class ClxDerived!

这个很简单，非常好理解。

但是，如果把类ClxBase析构函数前的virtual去掉，那输出结果就是下面的样子了：

           Do something in class ClxDerived!

    也就是说，类ClxDerived的析构函数根本没有被调用！一般情况下类的析构函数里面都是释放内存资源，而析构函数不被调用的话就会造成内存泄漏。我想所有的C++程序员都知道这样的危险性。当然，如果在析构函数中做了其他工作的话，那你的所有努力也都是白费力气。

    当然，并不是要把所有类的析构函数都写成虚函数。因为当类里面有虚函数的时候，编译器会给类添加一个虚函数表，里面来存放虚函数指针，这样就会增加类的存储空间。所以，只有当一个类被用来作为基类的时候，才把析构函数写成虚函数。

五，静态联编和动态联编

        函数名联编：将源代码中函数调用解释为执行特定的函数代码块

        但是在C++中由于函数重载，编译器必须查看函数参数以及函数名才能确定使用哪个函数

        静态联编：在编译过程中进行联编

        但是虚函数使这项工作变得更困难，使用哪一个函数不能在编译时确定

        动态联编：程序运行时选择正确虚方法的代码

        1）为什么有两种类型联编，为什么 静态联编为默认

              动态联编让您能够重新定义类方法，而静态联编则很差，但静态联编效率高。

              如果派生类不重新定义基类任何方法，则不需要动态联编。仅仅将那些派生类需要重新定义的函数定义为虚拟的

        2）虚函数工作原理

              编译器给每个对象添加一个隐藏成员，其中保存一个该函数地址的指针，这种数组成为虚函数表。

              调用虚函数时，查看存储在对象中虚拟函数表地址，然后转向相应函数地址表，如果使用类声明中定义的第一个虚函数，则程序将使用数组中的第一个函数地址，并执行具有该地址的函数。

       3）注意事项

              如果重新定义继承的方法，则应确保与原来的原型完全相同。

              如果基类声明被重载了，则应在派生类中重新定义所有基类版本

六，抽象基类ABC(abstract base class)

        说明：某几个子类的所公有的数据和方法抽象出来组成一个抽象基类，然后从抽象基类中派生出这几个子类，可以通过基类指针数组同时管理这几个子类。对于每个子类中的不同方法，可以将该方法在抽象基类中定义为纯虚函数的方式，同时在各子类中将该方法定义为虚函数。     

         #include <iostream>using namespace std;

const double pi=3.14;

class BaseEllipse //抽象基类 含有圆跟椭圆的公共成员

double x;

double y;

BaseEllipse(double t_x=0,double t_y=0)

{

x=t_x;

y=t_y;

}

virtual ~BaseEllipse(){}

void Move(int nx,int ny)

x=nx;

y=ny;

cout<<"中心坐标为:"<<"("<<x<<","<<y<<")"<<endl;

<strong><span style="font-size:18px;"></span></strong><pre name="code" ><span style="color:#ff0000;">virtual void Area()const=0;//纯虚函数结尾处为 “=0” 在类中可以只定义，不用实现</span>};class Circle:public BaseEllipse //圆{private: double r;public: Circle(double t_x=0,double

t_y=0,double t_r=0); //半径和中心坐标 Circle(const BaseEllipse & ba,double t_r=0); void Area()const;};class Ellipse:public BaseEllipse //椭圆{private: double a; double b;public: Ellipse(double t_x=0,double t_y=0,double t_a=0,double t_b=0); Ellipse(const BaseEllipse

& p,double t_a=0,double t_b=0); void Area()const;};/*圆*/Circle::Circle(double t_x,double t_y,double t_r):BaseEllipse(t_x,t_y){ r=t_r;}Circle::Circle(const BaseEllipse & ba,double t_r):BaseEllipse(ba){ r=t_r;}void Circle::Area()const{ cout<<pi*r*r<<endl;}/*椭圆*/Ellipse::Ellipse(double

t_x,double t_y,double t_a,double t_b):BaseEllipse(t_x,t_y){ a=t_a; b=t_b;}Ellipse::Ellipse(const BaseEllipse & ba,double t_a,double t_b):BaseEllipse(ba){ a=t_a; b=t_b;}void Ellipse::Area()const{ cout<<0.5*a*b<<endl;}int main(){ Circle c1(0,0,5); c1.Move(1,2);

c1.Area(); Ellipse e1(0,0,7,8); e1.Move(3,4); e1.Area(); return 0;}