不能被声明为虚函数的几个函数以及为何析构函数最好被声明为虚函数

一、什么函数不能被声明为虚函数？

1. 不能被继承的函数
2. 不能被重写的函数

---

总的来说，不能被定义为虚函数的函数有五种：构造函数、普通函数、友元函数、内联函数、静态成员函数

---

① 构造函数

原因： 构造函数是在C++编译阶段，系统自动调用的一个进行初始化的函数。假如子类可以继承基类的构造函数，那么子类对象的构造将使用基类的构造函数，但是基类并不知道子类对象有哪些成员。所以语义上这个说法不合理。

---

从另一个角度来说：多态是通过基类指针指向子类对象实现的。还没有构造成功，没有虚函数表，自然也没有虚表指针，自然也就无法实现对它的调用。

② 普通函数

原因： 普通函数不属于成员函数，是不能被继承的，声明成虚函数也根本没有意义。
并且编译器会在编译时绑定函数，而多态是在运行时绑定的。

③ 友元函数

原因：友元函数不是类的成员函数，不能被继承。既然都不能被继承了，又如何被声明为虚函数呢？

④ 内联函数

原因：内联函数是在函数调用时直接将汇编代码展开，减少函数调用花费的代价，而属于在编译时展开，而虚函数是为了实现多态的存在，是在运行时绑定的，与语义不符。

⑤ 静态成员函数

原因：静态函数是可继承的函数
但是，静态函数是在编译时确定的，与虚函数实现多态在运行时绑定不符。

---

---

二、继承时基类的析构函数最好被声明为虚函数

代码实现：

//1. 当基类的指针或引用指向基类对象时（基类析构函数不是虚函数的情况下）

#include<iostream>
using namespace std;
#include<stdlib.h>

class A {
public:
    A()
    {
        cout << "基类的构造函数：A()" << endl;
    };

    ~A()
    {
        cout << "基类的析构函数：~A()" << endl;
    }
};


class B:public A
{
public:
    B()
    {
        cout << "派生类的构造函数：B()" << endl;
    }

    ~B()
    {
        cout << "派生类的析构函数：~B()" << endl;
    }
};

void test()
{
    A A1;
    A &a = A1;//基类的指针或引用指向基类对象
}

int main()
{
    test();
    printf("\n");
    system("pause");
    return 0;
}

---

// 2. 当基类的指针或引用指向派生类对象时（基类的析构函数不是虚函数的情况下）

#include<iostream>
using namespace std;
#include<stdlib.h>

class A {
public:
    A()
    {
        cout << "基类的构造函数：A()" << endl;
    };

    ~A()
    {
        cout << "基类的析构函数：~A()" << endl;
    }
};


class B:public A
{
public:
    B()
    {
        cout << "派生类的构造函数：B()" << endl;
    }

    ~B()
    {
        cout << "派生类的析构函数：~B()" << endl;
    }
};

void test()
{

    A *a = new B();//基类的指针或引用指向派生类对象
    delete a;
}

int main()
{
    test();
    printf("\n");
    system("pause");
    return 0;
}

-由打印结果可以看出： 只调用了派生类的构造函数，没有调派生类的析构函数，有可能导致内存泄漏。

---

// 3. 当基类的指针或引用指向派生类对象时（基类的析构函数是虚函数的情况下）

#include<iostream>
using namespace std;
#include<stdlib.h>

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;
    }
};

void test()
{

    A *a = new B();//基类的指针或引用指向派生对象
    delete a;
}

int main()
{
    test();
    printf("\n");
    system("pause");
    return 0;
}

-由打印结果可以看出：将基类的析构函数声明成虚函数，析构时，就会先调用派生类的析构函数，再调用基类的析构函数，不会造成内存泄漏的风险。

结论：继承时，我们最好将基类的析构函数声明为虚函数，可以通过虚函数的指针或引用去调用派生类的析构函数，避免派生类中有资源未释放、造成内存泄漏。

---

---

---

三、当我们定义一个抽象类的时候，不知道抽象类的哪些成员是纯虚函数，因此可以将抽象类的析构函数声明为纯虚函数

代码实现：

#include<iostream>
using namespace std;
#include<stdlib.h>

class A {//抽象类
public:
    virtual ~A() = 0;
};


class B:public A
{
public:
    B()
    {
        cout << "派生类的构造函数：B()" << endl;
    }

    ~B()
    {
        cout << "派生类的析构函数：~B()" << endl;
    }
};

void test()
{

    B b;

}

int main()
{
    test();
    printf("\n");
    system("pause");
    return 0;
}

我们来看一下报错情况：当我们定义派生类对象的时候，会先调用基类的构造函数（这里没有声明，就会调系统默认的），再调用派生类的构造函数。
然后，会调用派生类的析构函数，进而调用基类的析构函数（基类的析构函数我们有在基类中声明，所以会调程序员自己写的，而不是系统默认的）
但是，基类（抽象类）的析构函数没有函数体，会编译报错——给抽象类的析构函数定义即可。（代码如下：）

---

#include<iostream>
using namespace std;
#include<stdlib.h>

class A {//抽象类
public:
    virtual ~A() = 0;
};

A:: ~A()
{
    cout << "基类的析构函数：~A()" << endl;
}

class B:public A
{
public:
    B()
    {
        cout << "派生类的构造函数：B()" << endl;
    }

    ~B()
    {
        cout << "派生类的析构函数：~B()" << endl;
    }
};

void test()
{

    B b;

}

int main()
{
    test();
    printf("\n");
    system("pause");
    return 0;
}