继承、重载与多态

继承

继承是C++中的一个重要特性，它可以让我们从一个类的部分成员继承并新建立一个类，

class <派生类名> : <继承方式(public/protected/private)> <基类名>

例如：

//基类
class Animal{
    eat(); 
    sleep();
}

//派生类
class Dog : public Animal{
    bark(); //此时Dog类就继承了Animal类的eat和sleep两个成员函数
}

派生类可以访问基类的所有非私有成员，因此如果不想被派生类访问某些成员，应该在基类中将这部分成员私有。
派生类可以继承所有基类的成员函数，但不包括以下几种情况：
- 基类的构造函数、析构函数和拷贝构造函数
- 基类的重载运算符
- 基类的友元函数

继承的分类

当一个类派生自基类，该类的访问修饰符有三种类型： public, protected, private。通常情况下，我们不使用protected和private继承，而是采用public来继承。当不同类型的继承时，其继承情况如下：

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

多继承

C++中，一个子类可以有多个父类，即多继承。多继承的格式如下所示，基类之间用逗号隔开：

class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,...
{
    <派生类体>
}

运算符重载

C++内大部分运算符都可以被重载，其为一种特殊的函数，函数名为operator后紧跟被重载的运算符，例如对A类重载加号运算符：

A operator+(const A&); //可以用this指针节省一个加运算过程中调用的输入

完整实例：

#include <iostream>
using namespace std;

class Box
{
    public:
        double getVolume(void){
            return length*breadth*height;
        }

        void setSize(double l, double b, double h){
            length = l;
            breadth = b;
            height = h;
        }

        // 重载 + 运算符，用于把两个BoX对象相加
        Box operator+(const Box& b){
            Box box;
            box.length = this->length + b.length;
            box.breadth = this->breadth + b.breadth;
            box.height = this->height + b.height
            return box;
        }
    private:
        double length;
        double breadth;
        double height;
}

int main(){
    Box box1, box2, box3;
    box1.setSize(5.0, 6.0, 7.0);
    box2.setSize(1.0, 2.0, 3.0);

    box3 = box1 + box2;

    return 0;
}

注意事项：

运算符重载不可以改变语法结构
运算符重载不可以改变操作数的个数
运算符重载不可以改变优先级
运算符重载不可以改变结合性

可重载的运算符：

双目算术运算符：+, -, *, /**
关系运算符： ==, !=, >=, <=, >, <
逻辑运算符： ||, &&, !
单目运算符： +(正), -(负), *(指针), &(取地址)
自增自减运算符： ++, --
位运算符： |, &, ~(按位取反), ^(按位异或), <<, >>
赋值运算符： =, +=, -=, *= , /=, %=, &=, |=, ^=, <<=, >>=
空间申请与释放：new, delete, new[], delete[]
其他运算符: ()(函数调用), ->(成员访问), ,(逗号), [](下标)

不可重载运算符：

成员访问运算符：.
成员指针访问运算符： .* , -> *
域运算符: ::
长度运算符：sizeof
条件运算符：?
预处理运算符：#

C++的多态

C++的多态按字面意思理解就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。C++的多态意味着在调用成员函数是，会根据调用函数的对象的类型不同执行不同的函数。简而言之就是“一种接口，多种方法”。 C++运行时的多态性是通过虚函数实现的。即虚函数允许子类重新定义成员函数，而子类重新定义父类的做法成为覆盖(Override)。

程序实例如下：

#include <iostream>
using namespace std;

class Shape{
    protected:
        int width, height;
    public:
        Shape(int a=0, int b=0){
            width = a;
            height = b;
        }
        virtual int area(){
            cout << "Parent class area:" << endl;
            return 0;
        }
};

class Rectangle: public Shape{
    public:
        Rectangle(int a=0, int b=0):Shape(a, b){ }
        int area(){
            cout << "Rectangle class area:" << endl;
            return (width*height);
        }
};

class Triangle: public Shape{
    public:
        Triangle(int a=0, int b=0):Shape(a, b){ }
        int area(){
            cout << "Triangle class area" << endl;
            return (width*height/2);
        }
};

int main(){
    Shape *shape;
    Retctangle rec(10, 7);
    Triangle tri(10, 5);

    //存储矩形的地址
    shape = &rec;
    shape->area();

    //存储三角形的地址
    shape =  &tri;
    shape->area();
    return 0;
}

纯虚函数

纯虚函数的函数定义部分采用= 0代替，=0 告诉编译器，函数没有主体，上面的虚函数是纯虚函数。纯虚函数的实例如下：

class Shape {
   protected:
      int width, height;
   public:
      Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      // pure virtual function
      virtual int area() = 0;
};

多态总结

C++的多态继承基函数的成员虚函数，一定是依赖于虚函数，如果基类中没有将被继承的成员函数声明为virtual，那么同名函数在被继承的过程中，派生类的同名成员函数会直接被基成员的同名成员函数覆盖！

部分内容引用自https://www.runoob.com/cplusplus/cpp-overloading.html

posted @ 2025-06-23 22:14 英俊潇洒鲜辣猪阅读(123) 评论(0) 收藏举报

刷新页面返回顶部

spi4pig