欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

继承(一)

程序员文章站 2023-11-21 22:44:46
[TOC] 1. 继承的概念和意义 类之间的关系 在C++中,类之间可以有直接的关联关系,包括组合关系和继承关系。 组合关系:整体与部分的关系 继承关系:父子关系 组合关系 组合关系描述的是类之间整体与部分的关系,具有以下特点 将其他类的对象作为当前类的成员变量使用 当前类的对象与成员对象的生命期相 ......

目录

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;
}

继承(一)