C++继承

C++继承

面向对象程序设计中最重要的一个概念就是继承，继承允许我们以及另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易，这样做也可以达到重用代码功能和提高执行时间的效果。

当创建一个类时，不需要重新编写新的数据成员和成员函数，只需要指定新建的类继承一个已有的类的成员即可，这个已有的类被称为基类，新建的类被称为派生类。

 

一个类可以派生自多个类，这意味着它可以从多个基类继承数据和函数。定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名。形式如下：

class derived-class ： access-specifier base-calss

 

其中，访问修饰符access-specifier是public、protected、或private其中一个base-class是之前定义多的某个基类的名称，如果未使用访问修饰符access-specifier，则默认private。

 

假设有一个基类Shape，Rectangle是它的派生类

#include<iostream>
using namespace std;

class Shape
{
    public:
        void setWidth(int w)
        {
            width = w;
        }
        void setHeight(int h)
        {
            height = h;
        }

    protected:
        int width;
        int height;
};

class Rectangle: public Shape
{
    public:
        int getArea()
        {
            return (width*height);
        }
};
int main()
{
    Rectangle Rect;
    Rect.setWidth(5);
    Rect.setHeight(7);
    cout << "Total area: " << Rect.getArea() << endl;
    return 0;
}

运行结果：

exbot@ubuntu:~/Camera/Dali/20190731$ ./inherit

Total area: 35

 

访问控制和继承：

派生类可以访问基类中所有的非私有成员。因此基类成员如果不想被派生类成员函数访问，应该在基类中声明为private，我们可以根据访问权限总结访问类型，如下：

访问	Public	Protected	Private
同一个类	Yes	Yes	Yes
派生类	Yes	Yes	No
外部类	Yes	No	No

一个派生类继承了所有的基类方法，但下面情况除外：

l  基类的构造函数、析构函数、和拷贝构造函数

l  基类的重载运算

l  基类的友元函数

 

继承类型：

当一个类派生自基类，该基类可以被继承为public、protected或private几种类型。继承类型是通过上面讲解的访问修饰符access-specifier来指定的。

我们几乎不使用protected或private继承，通常使用public继承。当使用不同类型继承时，遵循以下几个规则：

公有继承： 当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。

保护继承： 当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。

私有继承：当一个类派生自私有基类时，基类的公有和保护成员都将成为派生类的私有成员。

 

多继承

多继承即一个子类可以有多个父类，它继承了多个父类的特性。

class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>…

{

       <派生类类体>

};

其中访问修饰符继承方式时public、protected、private的一种，用来修饰每个基类，各个基类之间用都好隔开。

#include<iostream>
using namespace std;

class Shape
{
    public:
        void setWidth(int w)
        {
            width = w;
        }
        void setHeight(int h)
        {
            height = h;
        }
    protected:
        int width;
        int height;
};

class PaintCost
{
    public:
        int getCost(int area)
        {
            return area*70;
        }
};

class Rectangle: public Shape, public PaintCost
{
    public:
        int getArea()
        {
            return (width*height);
        }
};

int main()
{
    Rectangle Rect;
    int area;

    Rect.setWidth(5);
    Rect.setHeight(7);

    area = Rect.getArea();

    cout << "Total area: " << Rect.getArea() << endl;

    cout << "Total paint cost : $" << Rect.getCost(area) << endl;
        
    return 0;
}

exbot@ubuntu:~/Camera/Dali/20190731$ ./moreInherit

Total area: 35

Total paint cost : $2450

 

另外多继承（环状继承），A->D,B->D,C->(A,B)

class D{…};
class B: public D{…};
class A: public D{…};
class C: public B,public,A{…};

这个继承会使D创建两个对象，要解决上面问题就是要用虚拟继承格式

格式：calss 类名: virtual 继承方式 父类名

class D{…};
class B: virtual public D{…};
class A: virtual public D{…};
class C: public B,public,A{…};

虚继承 --- 会在创建对象时创建一个虚表

A:virtual public D
B:virtual public D

#include<iostream>
using namespace std;

class D
{
    public:
        D()
        {
            cout << "D()" << endl;
        }
        ~D()    
        {
            cout << "~D()" << endl;
        }
    protected:
        int d;
};

class B : virtual public D
{
    public:
        B()
        {
            cout << "B()" << endl;
        }
        ~B()    
        {
            cout << "~B()" << endl;
        }
    protected:
        int b;        
};

class A : virtual public D
{
    public:
        A()
        {
            cout << "A()" << endl;
        }
        ~A()    
        {
            cout << "~A()" << endl;
        }
    protected:
        int a;        
};

class C :  public B, public A
{
    public:
        C()
        {
            cout << "c()" << endl;
        }
        ~C()    
        {
            cout << "~C()" << endl;
        }
    protected:
        int c;        
};

int main()
{
    cout << "hello world " << endl;
    C c;
    D d;
    B b;
    A a;
    cout << "sizeof(d) = "<< sizeof(d) << endl;
    cout << "sizeof(b) = "<< sizeof(b) << endl;
    cout << "sizeof(a) = "<< sizeof(a) << endl;
    cout << "sizeof(c) = "<< sizeof(c) << endl;
    return 0;
}