c++类的继承详解

继承是面向对象编程的重要特性之一，允许一个类（派生类）继承另一个类（基类）的属性和方法。C++ 支持多种类型的继承，包括公共继承、私有继承和保护继承。下面详细介绍 C++ 类的继承。

1. 基本继承概念
   继承使得派生类能够重用基类的代码。派生类不仅可以拥有自己的成员变量和成员函数，还可以继承基类的成员。

基类和派生类的基本语法

class Base {
public:
    int baseValue;

    Base(int val) : baseValue(val) {}

    void baseFunction() {
        std::cout << "Base function" << std::endl;
    }
};

class Derived : public Base { // 使用 public 关键字实现公共继承
public:
    int derivedValue;

    Derived(int baseVal, int derivedVal) : Base(baseVal), derivedValue(derivedVal) {}

    void derivedFunction() {
        std::cout << "Derived function" << std::endl;
    }
};

2. 继承类型
   C++ 支持三种继承类型：公共继承（public inheritance）、保护继承（protected inheritance）和私有继承（private inheritance）。

公共继承
公共继承是最常用的继承方式。基类的公共和保护成员在派生类中保持其访问级别。

class Base {
public:
    int publicValue;

protected:
    int protectedValue;

private:
    int privateValue;
};

class Derived : public Base {
public:
    void accessMembers() {
        publicValue = 1;    // 可访问
        protectedValue = 2; // 可访问
        // privateValue = 3; // 不可访问
    }
};

保护继承
在保护继承中，基类的公共和保护成员在派生类中变为保护成员。

class Base {
public:
    int publicValue;

protected:
    int protectedValue;

private:
    int privateValue;
};

class Derived : protected Base {
public:
    void accessMembers() {
        publicValue = 1;    // 可访问
        protectedValue = 2; // 可访问
        // privateValue = 3; // 不可访问
    }
};

私有继承
在私有继承中，基类的公共和保护成员在派生类中变为私有成员。

class Base {
public:
    int publicValue;

protected:
    int protectedValue;

private:
    int privateValue;
};

class Derived : private Base {
public:
    void accessMembers() {
        publicValue = 1;    // 可访问
        protectedValue = 2; // 可访问
        // privateValue = 3; // 不可访问
    }
};

3. 构造函数和析构函数
   派生类的构造函数和基类构造函数
   派生类的构造函数在创建对象时会首先调用基类的构造函数，然后再执行自己的构造函数。派生类可以在其构造函数的初始化列表中调用基类的构造函数。

class Base {
public:
    int baseValue;

    Base(int val) : baseValue(val) {
        std::cout << "Base constructor called" << std::endl;
    }
};

class Derived : public Base {
public:
    int derivedValue;

    Derived(int baseVal, int derivedVal) : Base(baseVal), derivedValue(derivedVal) {
        std::cout << "Derived constructor called" << std::endl;
    }
};

int main() {
    Derived obj(10, 20);
    return 0;
}

派生类的析构函数和基类析构函数
派生类的析构函数在销毁对象时会首先执行，然后才会调用基类的析构函数。

class Base {
public:
    Base() {
        std::cout << "Base constructor called" << std::endl;
    }

    ~Base() {
        std::cout << "Base destructor called" << std::endl;
    }
};

class Derived : public Base {
public:
    Derived() {
        std::cout << "Derived constructor called" << std::endl;
    }

    ~Derived() {
        std::cout << "Derived destructor called" << std::endl;
    }
};

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

4. 虚函数和多态
   虚函数允许派生类重写基类的函数。通过基类指针或引用调用虚函数时，会调用派生类的实现。这种机制称为多态。

基类中的虚函数

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

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

int main() {
    Base* ptr;
    Derived obj;
    ptr = &obj;

    ptr->show(); // 调用的是 Derived 类的 show 函数
    return 0;
}

5. 纯虚函数和抽象类
   纯虚函数是没有实现的虚函数，使用 = 0 语法声明。包含纯虚函数的类称为抽象类，不能实例化对象。抽象类用于定义接口，派生类必须实现纯虚函数。

抽象类示例

class AbstractBase {
public:
    virtual void pureVirtualFunction() = 0; // 纯虚函数
};

class Derived : public AbstractBase {
public:
    void pureVirtualFunction() override {
        std::cout << "Implementation of pure virtual function" << std::endl;
    }
};

int main() {
    // AbstractBase obj; // 错误：不能实例化抽象类
    Derived obj; // 可以实例化派生类
    obj.pureVirtualFunction();

    return 0;
}

6. 多重继承
   C++ 支持多重继承，一个派生类可以同时继承多个基类。这种继承方式需要特别小心，以避免命名冲突和菱形继承问题。

多重继承示例

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

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

class Derived : public Base1, public Base2 {
};

int main() {
    Derived obj;
    obj.show();    // 调用 Base1 的 show 函数
    obj.display(); // 调用 Base2 的 display 函数

    return 0;
}

菱形继承及虚基类
菱形继承问题发生在一个派生类通过不同路径继承同一个基类时，造成基类成员的多份拷贝。通过使用虚基类，可以避免这种问题。

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

class Derived1 : virtual public Base {
};

class Derived2 : virtual public Base {
};

class FinalDerived : public Derived1, public Derived2 {
};

int main() {
    FinalDerived obj;
    obj.show(); // 只有一个 Base 子对象
    return 0;
}

总结
C++ 中的继承机制强大且灵活，主要包括以下几个方面：

基本继承：实现代码重用。
继承类型：公共继承、保护继承和私有继承，控制基类成员在派生类中的访问权限。
构造函数和析构函数：派生类的构造函数和析构函数调用顺序。
虚函数和多态：实现运行时多态，派生类可以重写基类的虚函数。
纯虚函数和抽象类：定义接口，派生类必须实现纯虚函数。
多重继承：一个派生类可以同时继承多个基类，需小心命名冲突和菱形继承问题。
理解和掌握这些继承机制，可以帮助开发者更好地设计和实现复杂的类结构。