C++基类与派生类

继承的基本概念

• 基类（Base Class）：也称为父类或超类，是被继承的类。
• 派生类（Derived Class）：也称为子类，是从基类继承而来的类。

继承的语法

继承的基本语法如下：

class 基类名 {
    // 基类成员
};

class 派生类名 : 访问修饰符 基类名 {
    // 派生类成员
};

其中，访问修饰符可以是 public、protected 或 private，它们决定了基类成员在派生类中的访问权限。

访问修饰符

• public 继承：基类的 public 成员在派生类中仍然是 public，基类的 protected 成员在派生类中仍然是 protected。
• protected 继承：基类的 public 和 protected 成员在派生类中都变成 protected。
• private 继承：基类的 public 和 protected 成员在派生类中都变成 private。

公有继承 (public Inheritance)

• 规则：基类的 public 成员在派生类中仍然是 public，基类的 protected 成员在派生类中仍然是 protected，基类的 private 成员在派生类中不可访问。

#include <iostream>
using namespace std;

class Base {
public:
    int publicVar;
protected:
    int protectedVar;
private:
    int privateVar;

public:
    Base() : publicVar(1), protectedVar(2), privateVar(3) {}

    void show() {
        cout << "Base publicVar: " << publicVar << endl;
        cout << "Base protectedVar: " << protectedVar << endl;
        cout << "Base privateVar: " << privateVar << endl;
    }
};

class DerivedPublic : public Base {
public:
    void show() {
        cout << "DerivedPublic publicVar: " << publicVar << endl;         // 可以访问
        cout << "DerivedPublic protectedVar: " << protectedVar << endl;   // 可以访问
        // cout << "DerivedPublic privateVar: " << privateVar << endl;   // 不可访问，编译错误
    }
};

int main() {
    DerivedPublic obj;
    obj.show();
    cout << "Accessing from main: " << obj.publicVar << endl;  // 可以访问
    // cout << "Accessing from main: " << obj.protectedVar << endl; // 不可访问，编译错误
    return 0;
}

私有继承 (private Inheritance)

• 规则：基类的 public 成员和 protected 成员在派生类中都变为 private，基类的 private 成员在派生类中不可访问。

#include <iostream>
using namespace std;

class Base {
public:
    int publicVar;
protected:
    int protectedVar;
private:
    int privateVar;

public:
    Base() : publicVar(1), protectedVar(2), privateVar(3) {}

    void show() {
        cout << "Base publicVar: " << publicVar << endl;
        cout << "Base protectedVar: " << protectedVar << endl;
        cout << "Base privateVar: " << privateVar << endl;
    }
};

class DerivedPrivate : private Base {
public:
    void show() {
        cout << "DerivedPrivate publicVar: " << publicVar << endl;        // 可以访问，但在 DerivedPrivate 中是 private
        cout << "DerivedPrivate protectedVar: " << protectedVar << endl;  // 可以访问，但在 DerivedPrivate 中是 private
        // cout << "DerivedPrivate privateVar: " << privateVar << endl;   // 不可访问，编译错误
    }
};

int main() {
    DerivedPrivate obj;
    obj.show();
    // cout << "Accessing from main: " << obj.publicVar << endl; // 不可访问，编译错误
    // cout << "Accessing from main: " << obj.protectedVar << endl; // 不可访问，编译错误
    return 0;
}

 

示例代码

基类和派生类

#include <iostream>
using namespace std;

// 基类
class Animal {
public:
    void eat() {
        cout << "I can eat!" << endl;
    }
};

// 派生类
class Dog : public Animal {
public:
    void bark() {
        cout << "I can bark! Woof woof!" << endl;
    }
};

int main() {
    Dog myDog;
    myDog.eat(); // 调用基类的方法
    myDog.bark(); // 调用派生类的方法
    return 0;
}

在这个例子中，Dog 类继承自 Animal 类，因此 Dog 类对象可以调用 Animal 类的 eat 方法。

继承的类型

单继承

一个派生类继承自一个基类。

class A {
    // 基类成员
};

class B : public A {
    // 派生类成员
};

多重继承

一个派生类继承自多个基类。

class A {
    // 基类成员
};

class B {
    // 基类成员
};

class C : public A, public B {
    // 派生类成员
};

构造函数与析构函数

派生类的构造函数在执行前会先调用基类的构造函数，析构函数的调用顺序则相反。

#include <iostream>
using namespace std;

class Base {
public:
    Base() {
        cout << "Base class constructor called." << endl;
    }
    ~Base() {
        cout << "Base class destructor called." << endl;
    }
};

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

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

运行结果：

Base class constructor called.
Derived class constructor called.
Derived class destructor called.
Base class destructor called.