继承（一）

目录

1. 继承的概念和意义

类之间的关系

在c++中，类之间可以有直接的关联关系，包括组合关系和继承关系。

• 组合关系：整体与部分的关系
• 继承关系：父子关系

组合关系

组合关系描述的是类之间整体与部分的关系，具有以下特点

• 将其他类的对象作为当前类的成员变量使用
• 当前类的对象与成员对象的生命期相同
• 成员对象在用法上与普通对象完全一致，具有等同地位

/*描述class的组合关系*/

#include <iostream>
#include <string>

using namespace std;

class memory
{
public:
    memory()
    {
        cout << "memory()" << endl;
    }
    ~memory()
    {
        cout << "~memory()" << endl;
    }
};

class disk
{
public:
    disk()
    {
        cout << "disk()" << endl;
    }
    ~disk()
    {
        cout << "~disk()" << endl;
    }
};

class cpu
{
public:
    cpu()
    {
        cout << "cpu()" << endl;
    }
    ~cpu()
    {
        cout << "~cpu()" << endl;
    }
};

class mainboard
{
public:
    mainboard()
    {
        cout << "mainboard()" << endl;
    }
    ~mainboard()
    {
        cout << "~mainboard()" << endl;
    }
};

class computer
{
private:
    /*必须是其他类的对象，不能是指针，否则无法构成组合关系*/
    memory mmem;
    disk mdisk;
    cpu mcpu;
    mainboard mmainboard;
public:
    computer()
    {
        cout << "computer()" << endl;
    }
    void power()
    {
        cout << "power()" << endl;
    }
    void reset()
    {
        cout << "reset()" << endl;
    }
    ~computer()
    {
        cout << "~computer()" << endl;
    }
};

int main()
{
    computer c;

    return 0;
}

继承关系

继承关系描述的是类之间的父子关系，父类为基类，子类为派生类。

• 子类拥有父类的所有属性和方法，还可以添加父类没有的属性和方法
• 子类是一种特殊的父类，子类对象可以当作父类对象使用，可以初始化父类对象，也可以给父类对象赋值
• 继承是c++中代码复用的重要手段，通过继承，可以获得父类的所有功能，还可以在子类中重写已有功能，或者添加新功能

#include <iostream>
#include <string>

using namespace std;

class hpbook : public computer  //computer是组合关系示例代码中实现的类
{
    string mos;
public:
    hpbook()
    {
        mos = "windows 8";
    }
    void install(string os)
    {
        mos = os;
    }
    void os()
    {
        cout << mos << endl;
    }
};

class macbook : public computer
{
public:
    void os()
    {
        cout << "mac os" << endl;
    }
};

int main()
{
    hpbook hp;

    hp.power();
    hp.install("ubuntu 16.04 lts");
    hp.os();

    cout << endl;

    macbook mac;

    hp.power();
    mac.os();

    cout << endl;

    return 0;
}

建议：作为类设计的一般原则，能用组合关系的，就不要用继承关系，前提是组合关系可以实现所需功能和较好的架构设计。

2. 继承中的访问级别

• 面向对象中的访问级别包括public、private和protected
• protected是专门为了继承而设计的
• protected成员变量不能被外界直接访问，但可以被子类直接访问
• 在设计类的时候，需要根据具体需求来规划不同的访问级别

#include <iostream>
#include <string>

using namespace std;

class parent
{
protected:
    int mv;
public:
    parent()
    {
        mv = 100;
    }

    int value()
    {
        return mv;
    }
};

class child : public parent
{
public:
    int addvalue(int v)
    {
        mv = mv + v;
    }
};

int main()
{
    parent p;
    child c;

    // p.mv = 1000;   // error
    // c.mv = 10000;  // error

    c.addvalue(50);
    cout << "c.mv = " << c.value() << endl;

    return 0;
}

上面的demo简单地展示了protecded成员变量的特性和使用方式，下面再看一个复杂一些的综合示例，uml类图如下所示，
polint和line都继承自object，同时line还组合使用了point。

#include <iostream>
#include <sstream>
#include <string>

using namespace std;

class object
{
protected:
    string mname;
    string minfo;
public:
    object()
    {
        mname = "object";
        minfo = "null";
    }

    string name()
    {
        return mname;
    }

    string info()
    {
        return minfo;
    }
};

class point : public object
{
private:
    int mx;
    int my;
public:
    point(int x = 0, int y = 0)
    {
        ostringstream s;

        mx = x;
        my = y;
        mname = "point";

        s << "p(" << mx << ", " << my << ")";

        minfo = s.str();
    }

    int x()
    {
        return mx;
    }

    int y()
    {
        return my;
    }
};

class line : public object
{
private:
    point mstart;
    point mend;
public:
    line(point start, point end)
    {
        ostringstream s;

        mstart = start;
        mend = end;
        mname = "line";

        s << "line from " << mstart.info() << " to " << mend.info();

        minfo = s.str();
    }

    point &begin()
    {
        return mstart;
    }

    point &end()
    {
        return mend;
    }
};

int main()
{
    object o;

    cout << o.name() << endl;
    cout << o.info() << endl;
    cout << endl;

    point p(1, 2);

    cout << p.name() << endl;
    cout << p.info() << endl;
    cout << endl;

    point start(3, 4);
    point end(5, 6);
    line l(start, end);

    cout << l.name() << endl;
    cout << l.info() << endl;

    return 0;
}

3. 不同的继承方式

类似于成员变量有三种访问级别，c++也支持三种不同的继承方式

• public继承：父类成员变量在子类中保持原有访问级别
• private继承：父类成员变量在子类中全部变为private
• protecded继承：父类public成员变量在子类中变为protected，其余成员变量访问级别保持不变

虽然c++支持三种不同的继承方式，但private和protected继承带来的复杂性远大于实用性，因此在工程中一般推荐使用public继承。
实际上，c++的派生语言（如java、c#）都只支持public继承这一种方式，也变相说明了这一点。

4. 继承中的构造与析构

父类和子类都可以定义构造函数，其中子类构造函数必须对继承而来的成员变量进行初始化，初始化的方法有两种：

• 直接使用赋值的方式进行初始化，仅适用于父类public和protected成员
• 调用父类构造函数进行初始化，这里也有两种调用方式
  • 隐式调用：适用于父类无参构造函数和默认参数构造函数
  • 显式调用：通过初始化列表进行调用，适用于所有父类构造函数

继承中的构造与析构顺序，在“对象的构造与析构（二）”中已经讲过，不再赘述。

#include <iostream>
#include <string>

using namespace std;

class parent
{
protected:
    string ps;
    int mv;
public:
    parent()
    {
        cout << "parent()" << endl;
        ps = "default";
        mv = 0;
    }

    parent(string s, int v)
    {
        cout << "parent(string s, int v) : " << s << ", " << v << endl;
        ps = s;
        mv = v;
    }

    ~parent()
    {
        cout << "~parent() : " << ps << ", " << mv << endl;
    }
};

class child : public parent
{
private:
    string cs;
public:
    /*
     * 进入child()前，隐式调用parent()，初始化父类成员;
     * 进入child()后，使用赋值方式，初始化父类成员.
    */
    child()
    {
        cout << "child()" << endl;
        ps = "parent default";
        mv = 100;
        cs = "default";
    }

    /*
     * 进入child()前，使用初始化列表，显式调用parent(string s, int v)，初始化父类成员.
    */
    child(string s) : parent(s, 200)
    {
        cout << "child(string s) : " << s << endl;
        cs = s;
    }

    ~child()
    {
        cout << "~child() : " << cs << endl;
    }
};

int main()
{
    child c1;
    child c2("child");

    cout << endl;

    return 0;
}