【C++】06 继承、多态、文件与流

dabaicong_

于 2024-07-20 19:31:22 发布

阅读量315

点赞数 18

文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/m0_46250943/article/details/140564908

版权

1.1 继承

1.1.1 基类和派生类

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

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

基类有的成员函数，派生类也会有

继承代表了 is a 关系。例如，哺乳动物是动物，狗是哺乳动物，因此，狗是动物，等等。

1.1.2 继承的语法

class 子类 : 继承方式父类

class A : public B;

A 类称为子类或派生类

B 类称为父类或基类

1.1.3 公有继承、私有继承、保护继承

公有继承：基类的公有成员和保护成员在派生类中保持原有访问属性，其私有成员仍为基类私有。故基类的私有成员不能被派生类访问，但是可以通过基类的公有和保护成员访问
私有继承：基类的公用成员和保护成员在派生类中成了私有成员。其私有成员仍为基类私有
保护继承：基类的公用成员和保护成员在派生类中成了保护成员，其私有成员仍为基类私有。

1.1.4 多继承

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

派生类类体：类体函数，成员编写

C++ 类可以从多个类继承成员，语法如下：

其中，访问修饰符继承方式是 public、protected 或 private 其中的一个，用来修饰每个基类，各个基类之间用逗号分隔。

示例代码

// 基类Shape
class Shape
{
    // 公有成员
    public:
        // 函数设定宽度，传入一个参数w
        void setWidth(int w)
        {
            width = w;
        }
        void setHeight(int h)
        {
            height = h;
        }
    // 将这两个参数的值赋给了保护成员
    protected:
        int width;
        int height;
};

// 基类 PaintCost
class PaintCost
{
    public:
        // 公有成员函数getCost, 参数area
        int getCost(int area)
        {
            return area * 70;
        }
};

// 继承了派生类Rectangle，有两个父类，都是公有继承
class Rectangle: public Shape, public PaintCost
{
    public:
        // 公有成员函数getArea,返回高度乘宽度，这里的宽度和高度是从基类Shape中来的
        int getArea()
        {
            return (width * height);
        }
};

// 主函数
int main(void)
{
    // 定义Rectangle 类的对象 Rect
    Rectangle Rect;
    // 定义整型变量area
    int area;

    // 初始化Rect对象，setWidth和setHeight这两个函数也来自于基类Shape
    // 派生类Rect这个对象调用基类shape中的两个成员函数，设定宽度为5，高度为7
    Rect.setWidth(5);
    Rect.setHeight(7);

    // 整型变量area  调用的是派生类自己的成员函数
    area = Rect.getArea();

    // 输出对象的面积
    cout << "Total area: " << Rect.getArea() << end1;
    
    // 输出总花费
    cout << "Total paint cost:$" <<  Rect.getCost(area) << end1;

    return 0;
}

1.1.5 要点

派生类是不能继承基类的析构函数，也需要通过派生类的析构函数去调用基类的析构函数。
继承中先调用父类构造函数，再调用子类构造函数，析构函数的调用顺序与构造相反。
C++中，不能被派生类继承的是：构造函数，析构函数。
单继承：一个派生类只从一个基类派生。
多继承：一个派生类有两个或多个基类的称为多重继承。

1.2 多态

多态按字面的意思就是多种形态，指具有不同功能的函数可以用同一个函数名，C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。

多态分为两类

静态多态：函数重载和运算符重载属于静态多态，复用函数名。

动态多态：派生类和虚函数（virtual function）实现运行时多态。

1.2.1 静态多态（函数重载和运算符重载）

函数重载：

C++ 允许在同一作用域中的某个函数和运算符指定多个定义，分别称为函数重载和运算符重载。

重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明，但是它们的参数列表和定义（实现）不相同。

当您调用一个重载函数或重载运算符时，编译器通过把您所使用的参数类型与定义中的参数类型进行比较，决定选用最合适的定义。选择最合适的重载函数或重载运算符的过程，称为重载决策。

在同一个作用域内，可以声明几个功能类似的同名函数，但是这些同名函数的形式参数（指参数的个数、类型或者顺序）必须不同。您不能仅通过返回类型的不同来重载函数。

下面的实例中，同名函数 print() 被用于输出不同的数据类型：

在选择print时，它会根据输入进去的参数的数据类型的不同，选择不同的print函数，实现函数的重载。

class printData
{
    // 有多个公有的成员函数，函数名都是print，区别在于参数不同，一个是整形变量，一个是double型，一个是字符串型，他就会分别输出这个参数内传进去的内容
    public:
        void print(int i){
            cout << "整数为："<< i << endl;
        }
        void print(double f){
            cout << "浮点数为:"<< f << endl;
        }
        void print(char c[]){
            cout << "字符串为："<< c << endl;
        }
};

int main(void)
{
    // 定义了一个printdata类的对象是pd
    printData pd;
    
    // 输出整数
    pd.print(5);
    // 输出浮点数
    pd.print(500.263);
    // 输出字符串
    char c[] = "Hello C++";
    pd.print(c);

    return 0;
}

运算符重载

我们可以重定义或重载大部分 C++ 内置的运算符，使用自定义类型的运算符。

重载的运算符是带有特殊名称的函数，函数名是由关键字 operator 和其后要重载的运算符符号构成的。与其他函数一样，重载运算符有一个返回类型和一个参数列表。

Box是一个类，函数名由关键字operator和其后要重载的运算符+，括号里是参数，即要实现两个Box类型的相加，同时这个相加是我们自己去定义的，返回最终的box对象。

Box operator+(const Box&);

声明加法运算符用于把两个 Box 对象相加，返回最终的 Box 对象。大多数的重载运算符可被定义为普通的非成员函数或者被定义为类成员函数。如果我们定义上面的函数为类的非成员函数，那么我们需要为每次操作传递两个参数，因为它不能调用类本身的成员，所以传递两个参数，即两个box。如下所示：

Box operator+(const Box&, const Box&);

class Box
{
    public:
        double getVolume(void)
        {
            return length * breadth * height;
        }
        void setlength(double len )
        {
            length = len;
        } 
        void setBreadth(double bre )
        {
            breadth = bre;
        }
        void setHeight( double hei )
        {
            height = hei;
        }
        //重载 + 运算符， 用于把两个Box对象相加
        Box operator + (const Box& b)