【C++进阶】继承

C++中的继承

在C++中，继承是面向对象编程的一个核心特性，它使得我们能够基于已有类创建新类，实现代码的重用和扩展。继承通过允许一个类（派生类）继承另一个类（基类）的属性和行为，使得程序的设计更加模块化和可维护。

1. 继承的基本语法

C++中的继承可以通过关键字public、protected或private来实现，分别对应不同的访问控制：

class Base {
public:
    void display() {
        std::cout << "Base class display" << std::endl;
    }
};

class Derived : public Base {
public:
    void show() {
        std::cout << "Derived class show" << std::endl;
    }
};

在上述代码中，Derived类继承了Base类。通过public继承，Base类的公共成员可以在Derived类中直接访问。

2. 继承的类型

继承有三种主要类型：

• 公有继承（public inheritance）：基类的公共和保护成员在派生类中仍然是公共和保护的。

• 保护继承（protected inheritance）：基类的公共和保护成员在派生类中变成保护成员。

• 私有继承（private inheritance）：基类的公共和保护成员在派生类中都变成私有成员。

以下是一个示例，展示不同类型的继承：

class Base {
public:
    int pubVal;
protected:
    int protVal;
private:
    int privVal;
};

class PublicDerived : public Base {
public:
    void accessMembers() {
        pubVal = 1;    // 可以访问
        protVal = 2;   // 可以访问
        // privVal = 3; // 错误，无法访问
    }
};

class ProtectedDerived : protected Base {
public:
    void accessMembers() {
        pubVal = 1;    // 可以访问
        protVal = 2;   // 可以访问
        // privVal = 3; // 错误，无法访问
    }
};

class PrivateDerived : private Base {
public:
    void accessMembers() {
        pubVal = 1;    // 可以访问
        protVal = 2;   // 可以访问
        // privVal = 3; // 错误，无法访问
    }
};

3. 继承的特性

3.1 构造函数与析构函数

派生类会调用基类的构造函数，确保基类的成员得到初始化。在析构时，会先调用派生类的析构函数，再调用基类的析构函数。

class Base {
public:
    Base() {
        std::cout << "Base Constructor" << std::endl;
    }
    ~Base() {
        std::cout << "Base Destructor" << std::endl;
    }
};

class Derived : public Base {
public:
    Derived() {
        std::cout << "Derived Constructor" << std::endl;
    }
    ~Derived() {
        std::cout << "Derived Destructor" << std::endl;
    }
};

int main() {
    Derived d;
    return 0;
}

输出结果将是：

Base Constructor
Derived Constructor
Derived Destructor
Base Destructor

3.2 多重继承

C++允许一个类有多个基类，这称为多重继承，这可以导致复杂的情况，如菱形继承问题。

class A {
public:
    void display() {
        std::cout << "Class A" << std::endl;
    }
};

class B : public A {
public:
    void display() {
        std::cout << "Class B" << std::endl;
    }
};

class C : public A {
public:
    void display() {
        std::cout << "Class C" << std::endl;
    }
};

class D : public B, public C {
public:
    void show() {
        B::display(); // 调用B的方法
        C::display(); // 调用C的方法
    }
};

int main() {
    D d;
    d.show();
    return 0;
}

以上示例展示了如何使用多重继承来访问不同基类的方法。

结论

通过继承，我们能够方便地构建复杂的类层次结构，重用代码并增强程序的可维护性。但是，在使用继承时，也需要注意访问权限、构造函数的调用顺序以及多重继承带来的复杂性和潜在问题，合理设计类的继承关系，以便让代码更加清晰易懂。