【C/C++】 虚函数 纯虚函数

虚函数

虚函数的使用需要注意以下几点：

1. 虚函数必须是类的成员函数，因为只有类的成员函数才能被声明为虚函数。
2. 虚函数可以被子类重写，但是子类重写虚函数时，必须与父类的虚函数具有相同的名称、参数列表和返回类型。
3. 如果父类中的虚函数没有实现，那么子类可以选择不实现该虚函数，这样子类就会继承父类中的虚函数。
4. 如果父类中的虚函数有实现，那么子类必须实现该虚函数，否则编译器会报错。
5. 如果一个类中包含了虚函数，那么该类的对象中就会包含一个指向虚函数表的指针。这个指针指向了一个包含了所有虚函数地址的数组

虚函数的作用：

当把基类的某个成员函数声明为虚函数后，允许在其派生类中对该函数重新定义，赋予它新的功能，并且可以通过指向基类的指针指向同一类族中不同类的对象，从而调用其中的同名函数（动态多态）。（重写做不到）

纯虚函数

纯虚函数是一种特殊的虚函数，它在基类中没有定义，只有声明。纯虚函数的声明以 = 0 结尾

class Shape {
public:
    virtual void draw() = 0;
};

使用纯虚函数时，有几点需要注意：

1. 如果一个类中包含纯虚函数，那么这个类就成为抽象类。抽象类不能被实例化，只能作为基类被继承。
2. 派生类必须重写抽象类中的所有纯虚函数，否则派生类也将成为抽象类。
3. 纯虚函数只能在类的内部声明，不能在类的外部定义。例如，下面的代码是错误的：

class Shape {
public:
    virtual void draw() = 0;
};

void Shape::draw() { // 错误：不能在类的外部定义纯虚函数
    std::cout << "Drawing a shape." << std::endl;
}

​ 4. 构造函数不能是纯虚函数。析构函数可以是纯虚函数，但必须在类的内部定义。例如：

class Shape {
public:
    virtual ~Shape() = 0; // 纯虚析构函数
};

Shape::~Shape() {} // 必须在类的内部定义纯虚析构函数

整体的示意代码：

#include <iostream>
class Base {//如果一个类中包含纯虚函数，那么这个类就成为抽象类。
    //抽象类不能被实例化，只能作为基类被继承。
    //派生类必须重写抽象类中的所有纯虚函数，否则派生类也将成为抽象类。
public:
    virtual void vir() = 0; //纯虚函数，它在基类中没有定义，只有声明
    virtual void foo() { //虚函数
        std::cout << "Base::foo()" << std::endl;
    }
    void bar(int i) {
        std::cout << "Base::bar()" << std::endl;
    }
    //当你使用一个基类类型的指针或引用来删除一个派生类对象时，如果基类的析构函数不是虚函数，那么只有基类的析构函数会被调用，而派生类的析构函数不会被调用。这可能会导致资源泄漏或其他问题。
    virtual ~Base() {//虚析构函数
        std::cout << "Base::destroy()" << std::endl;
    }
};
/*
void Base::vir(){ // 错误：不能在类的外部定义纯虚函数
    std::cout << "Base::vir()" << std::endl;
}
*/
class Derived : public Base {//继承
public:
    void vir() override {
        std::cout << "Derived::vir()" << std::endl;
    }
    void foo() override {//override用于显式地声明一个成员函数重写了基类中的虚函数。
        std::cout << "Derived::foo()" << std::endl;
    }
    void bar(int i) {
        std::cout << "Derived::bar()" << std::endl;
    }
    ~Derived() {
        std::cout << "Derived::destroy()" << std::endl;
    }
};

int main() {
    Base* b = new Derived();
    b->foo(); // 输出 Derived::foo()
    b->bar(1); // 输出 Base::foo() 重写做不到通过指向基类的指针调用子类的同名函数
    delete b; // 通过父类指针释放之类对象, 输出 Derived::destroy() 和 Base::destroy()
}

常见题目：

#include <iostream>
using namespace std;
class A {
public:
	A() { 
		cout << "A" << endl; 
	}
	virtual ~A() { 
		cout << "~A" << endl; 
	}
};
class B :public A {
public:
	B() {
		cout << "B" << endl;
	}
	~B() {
		cout << "~B" << endl;
	}
};
int main() {
	A* a = new B(); // A B
	//A c; // A ~A
	//B d; // A B ~B ~A
	delete a; // ~B ~A
	return 0;
}