面向对象（四）——继承

1.类之间的继承

类的一个重要的特征是继承，这使得我们可以基于一个类生成另外一个类的对象，以便使后者拥有前者的某些成员，再加上自己的一些成员。

由其他类引申而来的子类继承基类的所有可视成员。意思是说，如果一个基类包含成员A，而我们将它引申为另一个包含成员B的类，这个子类同时包含A和B
定义一个子类，必须在子类的申明中使用冒号操作符“：”，如下所示：
class derived_class : public base_class
子类名称：访问权限（可以是public、protected、private）基类名称，但是一般的继承访问权限一般是public

#include <iostream>
using namespace std;
class Cfather{
protected:
    int wigth,height;
public:
    void get_vaule(int,int);
};
class Triangle:public Cfather{  //继承
private:
        int x, y;
public:
    int area1(void);
    Triangle operator +(Triangle);  //运算符重载
    friend class Rectangle;
};
class Rectangle:public Cfather
{
public:
    int area(void);
};
void Cfather::get_vaule(int a, int b)
{
    wigth=a;
    height=b;
}
int Rectangle::area(void)
{
    return (wigth*height);
}

int Triangle::area1(void)
{
    return (wigth*height/2);
}
Triangle Triangle::operator +(Triangle param){
    Triangle overload;
    overload.wigth=wigth+param.wigth;
    overload.height=height+param.height;
    return (overload);
}
int main()
{
   Rectangle rec;
   rec.get_vaule(4,5);
   Triangle tri,tri1,tri2;
   tri1.get_vaule(2,2);
   tri.get_vaule(3,4);
   tri.get_vaule_d(4,5);
   tri2=tri1+tri;
   cout<<tri.area1()<<" "<<rec.area()<<'\n'
      <<tri2.area1()<<endl;
}

如上代码所示，Rectangle和Triangle的每一个对象都包含了Cfather的成员，即width，height和get_value
标识符protected和private类似，唯一区别在于继承。当定义一个子类的时候，基类的protected成员可以被子类的其它成员所使用，然而private成员就不可以。

不同访问权限类型：
一个类的：public，protected，private；该类里面的成员可以访问所有成员；子类可以访问public和protected；而外部成员只能访问public（所以这是接口的问题）

对于继承访问权限的问题，在上面我们使用的是 class Triangle：public class Cfather，就是说当类Triangle从Cfather继承来的成员相当于在Triangle的public中增加了这些成员，则外部可以访问到从基类继承下来的成员，如果不想使外部访问子类从基类继承下来的成员的话，可以适当改成 class Triangle：protected/private Cfather 这样子。

一般而言，如果没有申明，那么通过class申明的默认为private，通过struct申明的默认为public。

2.什么是从基类继承

理论上讲，子类继承了基类的所有成员，除了：
1.构造函数和析构函数（）；
2.operator = （）；操作符重载，重载函数
3.friends ； 友元类

实际上，子类中的一个对象被创建或者销毁的时候，都会自动调用基类的默认构造函数和析构函数。
如果基类没有默认构造函数，或你希望当子类生成新的对象时，调用基类的某个重载函数，则可以指定它：
Triangle（参数）：base （参数）{}

3.多重继承

在C++中，一个class可以从多个class中继承属性或函数，只需要在子类的申明中用逗号将不同基类分开就可以了。
如果我们有一个特殊的class Coutput可以实现向屏幕打印的功能，同时希望类CRectangle和CTriangle在又从CPolygon之外继承一些成员，那么我们有：
class CRectangle：class Couput，class CPolygon {}
class CTriangle：class Couput，class CPolygon {}

如下代码所示，并附上解释：

#include <iostream>
using namespace std;
class Cfather{    //申明Cfather类
protected:
    int wigth,height;
public:
    void get_value(int,int);
};

void Cfather::get_value(int i, int j)   //对函数进行定义
{
    wigth=i;
    height=j;
}
 
class Coutput{    //申明Coutput类
public:
    void output(int a){cout<<a<<endl;}   //内联函数
};

class Ctriangle:public Cfather,public Coutput{      //类Ctriangle既继承了Cfather类也继承了Coutput类
public:
    int area(void){return(wigth*height/2);}  //内联函数
};

class Crectangle:public Cfather,public Coutput{
public:
    int area1(void){return(wigth*height);}  //内联函数
};

int main()
{
    Ctriangle tri;
    tri.get_value(3,4);
    Crectangle rect;
    rect.get_value(3,2);
   tri.output(tri.area());
   rect.output(rect.area1());
    return 0;
}
输出 6 ， 6

4.公有继承、保护继承和私有继承

1) public继承方式

基类中所有public成员在派生类中为public属性；
基类中所有protected成员在派生类中为protected属性；
基类中所有private成员在派生类中不可访问。

2) protected继承方式

基类中的所有public成员在派生类中为protected属性；
基类中的所有protected成员在派生类中为protected属性；
基类中的所有private成员在派生类中仍然不可访问。

3) private继承方式

基类中的所有public成员在派生类中均为private属性；
基类中的所有protected成员在派生类中均为private属性；
基类中的所有private成员在派生类中均不可访问。