当前位置：首页 > article >正文

C++--------继承

article 2025/3/1 23:05:04

一、继承的基本概念

继承是 C++ 中的一个重要特性，它允许一个类（派生类或子类）继承另一个类（基类或父类）的属性和方法。这样可以实现代码的重用和建立类之间的层次关系。

#include <iostream>

// 基类
class Base {
public:
    void show() {
        std::cout << "This is the Base class." << std::endl;
    }
};

// 派生类
class Derived : public Base {
public:
    void display() {
        std::cout << "This is the Derived class." << std::endl;
    }
};

int main() {
    Derived d;
    d.show(); // 调用基类的方法
    d.display(); // 调用派生类的方法
    return 0;
}

解释：

基类：Base 类包含一个公共成员函数 show()。
派生类：Derived 类继承自 Base 类，使用 public 继承。它不仅可以访问自己的成员函数 display()，还可以访问基类的 show() 函数。

二、图形对象的继承层次

假设我们要创建一个图形对象的继承层次，可以从一个基类 Shape 开始，然后派生出具体的形状类，如 Circle、Rectangle 等。

#include <iostream>
#include <cmath>

class Shape {
public:
    virtual double area() = 0; // 纯虚函数，使 Shape 成为抽象类
    virtual void display() {
        std::cout << "This is a shape." << std::endl;
    }
};

class Circle : public Shape {
private:
    double radius;
public:
    Circle(double r) : radius(r) {}
    double area() override {
        return 3.14159 * radius * radius;
    }
    void display() override {
        std::cout << "This is a circle with radius " << radius << std::endl;
    }
};

class Rectangle : public Shape {
private:
    double length, width;
public:
    Rectangle(double l, double w) : length(l), width(w) {}
    double area() override {
        return length * width;
    }
    void display() override {
        std::cout << "This is a rectangle with length " << length << " and width " << width << std::endl;
    }
};

int main() {
    Circle c(5.0);
    Rectangle r(4.0, 6.0);

    Shape* s1 = &c;
    Shape* s2 = &r;

    s1->display();
    std::cout << "Area of circle: " << s1->area() << std::endl;
    s2->display();
    std::cout << "Area of rectangle: " << s2->area() << std::endl;
    return 0;
}

解释：

抽象类：Shape 类包含一个纯虚函数 area()，使其成为抽象类，不能被实例化。
派生类：Circle 和 Rectangle 继承自 Shape，并实现了 area() 和 display() 函数。
多态性：通过基类指针指向派生类对象，可以调用派生类的 display() 和 area() 函数，实现多态性。

三、表达式的类层次

对于表达式的类层次，可以创建一个基类 Expression，然后派生出不同类型的表达式类，如 BinaryExpression、UnaryExpression 等。

#include <iostream>

class Expression {
public:
    virtual double evaluate() = 0; // 纯虚函数
    virtual void display() = 0;
};

class Constant : public Expression {
private:
    double value;
public:
    Constant(double v) : value(v) {}
    double evaluate() override {
        return value;
    }
    void display() override {
        std::cout << value;
    }
};

class BinaryExpression : public Expression {
protected:
    Expression* left;
    Expression* right;
public:
    BinaryExpression(Expression* l, Expression* r) : left(l), right(r) {}
    ~BinaryExpression() {
        delete left;
        delete right;
    }
};

class Addition : public BinaryExpression {
public:
    Addition(Expression* l, Expression* r) : BinaryExpression(l, r) {}
    double evaluate() override {
        return left->evaluate() + right->evaluate();
    }
    void display() override {
        left->display();
        std::cout << " + ";
        right->display();
    }
};

int main() {
    Expression* e1 = new Constant(5);
    Expression* e2 = new Constant(3);
    Expression* sum = new Addition(e1, e2);

    sum->display();
    std::cout << " = " << sum->evaluate() << std::endl;

    delete sum;
    return 0;
}

解释：

基类：Expression 是一个抽象类，包含纯虚函数 evaluate() 和 display()。
派生类：
- Constant 表示常量表达式，存储一个值。
- BinaryExpression 是一个抽象类，包含左右操作数。
- Addition 是 BinaryExpression 的派生类，实现加法操作。

四、解析表达式

解析表达式可以使用递归下降解析器，结合表达式的类层次结构。例如，解析 3 + 5 这样的表达式：

可以先创建 Constant 对象表示 3 和 5，然后创建 Addition 对象表示 3 + 5。

五、多重继承

多重继承允许一个类继承自多个基类。

#include <iostream>

class Base1 {
public:
    void show1() {
        std::cout << "This is Base1." << std::endl;
    }
};

class Base2 {
public:
    void show2() {
        std::cout << "This is Base2." << std::endl;
    }
};

class Derived : public Base1, public Base2 {
public:
    void display() {
        std::cout << "This is Derived." << std::endl;
    }
};

int main() {
    Derived d;
    d.show1();
    d.show2();
    d.display();
    return 0;
}

解释：

多重继承：Derived 类继承自 Base1 和 Base2，因此可以访问 Base1 和 Base2 的成员函数，以及自己的成员函数。

注意事项

多重继承的二义性：当多个基类有相同的成员函数或变量时，可能会产生二义性问题。可以使用作用域解析运算符 :: 来消除二义性。
虚继承：在菱形继承结构中，使用虚继承可以避免重复继承相同基类的问题。

#include <iostream>

class GrandParent {
public:
    void show() {
        std::cout << "This is GrandParent." << std::endl;
    }
};

class Parent1 : virtual public GrandParent {};
class Parent2 : virtual public GrandParent {};
class Child : public Parent1, public Parent2 {};

int main() {
    Child c;
    c.show(); // 不会产生二义性
    return 0;
}