c++中的类的派生和虚拟函数

在C++中，类的派生和虚拟函数是面向对象编程的重要特性，下面将详细介绍这两个概念。

一、类的派生（Inheritance）

1. ​基本概念

派生是通过从一个现有类（基类/父类）派生出新类（派生类/子类）的过程，子类继承基类的属性和行为，并扩展新的功能。

class Base {    // 基类
public:
    void show() { cout << "Base::show()" << endl; }
};

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

2. ​访问控制

cpp

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

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

// 创建对象时输出顺序：
// Base Constructor → Derived Constructor → Derived Destructor → Base Destructor

4. ​成员覆盖与隐藏

cpp

class Base {
public:
    void func(int x) { cout << "Base::func(int)" << endl; }
};

class Derived : public Base {
public:
    void func(double x) { cout << "Derived::func(double)" << endl; } // 隐藏基类func
};

二、虚函数（Virtual Functions）

1. ​目的

虚函数允许通过基类指针或引用调用派生类的重写函数，实现运行时多态​（Run-Time Polymorphism）。

2. ​语法

cpp

• public：派生类可以直接访问基类的 public 成员。
• protected：派生类可以访问基类的 protected 成员，但不能被外部直接访问。
• private：派生类不能直接访问基类的 private 成员（除非使用友元）。

  1. 基类成员为 public

  基类的 public 成员可以被派生类直接访问，并且可以通过派生类的对象在外部直接访问。

• #include <iostream>
  using namespace std;

  class Base {
  public:
      int publicVar = 10;
  };

  class Derived : public Base {
  public:
      void accessPublic() {
          cout << "Derived accessing Base's publicVar: " << publicVar << endl; // ✔️ 可以访问
      }
  };

  int main() {
      Derived d;
      d.accessPublic(); // 输出: Derived accessing Base's publicVar: 10
      cout << "External access to publicVar: " << d.publicVar << endl; // ✔️ 外部也可以直接访问
      return 0;
  }

• 2. 基类成员为 protected

  基类的 protected 成员可以被派生类访问，但不能通过派生类的对象在外部直接访问。

• #include <iostream>
  using namespace std;

  class Base {
  protected:
      int protectedVar = 20;
  };

  class Derived : public Base {
  public:
      void accessProtected() {
          cout << "Derived accessing Base's protectedVar: " << protectedVar << endl; // ✔️ 可以访问
      }
  };

  int main() {
      Derived d;
      d.accessProtected(); // 输出: Derived accessing Base's protectedVar: 20
      cout << "External access to publicVar: " << d.publicVar << endl;// ❌ 下面这行会报错：'protectedVar' is a protected member of 'Base'
      // cout << d.protectedVar << endl;
      return 0;
  }

• 3. 基类成员为 private

  基类的 private 成员不能被派生类直接访问，除非派生类是基类的友元类。

  ​情况一：普通派生类无法访问 private 成员

• #include <iostream>
  using namespace std;

  class Base {
  private:
      int privateVar = 30;
  };

  class Derived : public Base {
  public:
      void accessPrivate() {
          cout << "Derived accessing Base's protectedVar: " << protectedVar << endl;// ❌ 下面这行会报错：'privateVar' is a private member of 'Base'
          cout << privateVar << endl;
      }
  };

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

• 情况二：通过友元类访问 private 成员

  如果派生类声明为基类的友元，则可以访问基类的 private 成员：

• #include <iostream>
  using namespace std;

  class Base {
  private:
      int privateVar = 30;
      friend class Derived; // 声明Derived为友元类
  };

  class Derived : public Base {
  public:
      void accessPrivate() {
          cout << "Derived accessing Base's privateVar: " << privateVar << endl; // ✔️ 可以访问
      }
  };

  int main() {
      Derived d;
      d.accessPrivate(); // 输出: Derived accessing Base's privateVar: 30
      return 0;
  }

• 

  3. ​构造函数与析构函数

• ​构造函数调用顺序：基类构造函数先于派生类执行。
• ​析构函数调用顺序：派生类析构函数先于基类执行。
• ​重写（Override）​：派生类重新定义基类的虚函数（需相同签名）。
• ​隐藏（Hide）​：派生类定义与基类同名的非虚函数（即使参数不同也会隐藏基类函数）。

cpp

class Base {
public:
    virtual void show() { /* 基类实现 */ }
};

class Derived : public Base {
public:
    virtual void show() override { /* 派生类实现 */ } // C++11 强制覆盖检查
};

3. ​多态示例

cpp

Base* ptr;
ptr = new Base();     ptr->show(); // 调用 Base::show()
ptr = new Derived();  ptr->show(); // 调用 Derived::show()
delete ptr;

4. ​关键特性

cpp

class Abstract {
public:
    virtual void doSomething() = 0; // 纯虚函数
};
// 抽象类不能直接实例化

5. ​注意事项

三、派生与虚函数的结合

通过虚函数，派生类可以扩展或重写基类的行为，实现灵活的设计：

cpp

class Animal {
public:
    virtual void makeSound() { cout << "Animal sound" << endl; }
};

class Dog : public Animal {
public:
    void makeSound() override { cout << "Woof!" << endl; }
};

class Cat : public Animal {
public:
    void makeSound() override { cout << "Meow!" << endl; }
};

void playSound(Animal& animal) {
    animal.makeSound(); // 根据具体类型调用
}

int main() {
    Dog dog;   playSound(dog); // 输出 "Woof!"
    Cat cat;   playSound(cat); // 输出 "Meow!"
    return 0;
}

• ​动态绑定：函数调用在运行时根据对象的实际类型决定。
• ​虚函数表（vtable）​：编译器为每个包含虚函数的类生成一个虚函数表，存储函数指针。
• ​纯虚函数：声明为 virtual void func() = 0，强制派生类重写，基类成为抽象类。
• ​构造函数和析构函数：不能是虚函数（因为对象在构造/析构时类型明确）。
• ​友元函数：无法被声明为虚函数。
• ​静态成员函数：不能是虚函数（与对象无关）。

•