构造函数和析构函数可以是虚函数吗，在里面能调用虚函数吗

复盘

构造函数作为虚函数？

先说构造函数，构造函数作为虚函数是不可以的，首先c++编译器上不会让你通过

在内存上，我们知道，一个对象会有一个虚函数表，虚函数表在构造函数中初始化，可是一个对象还没有完成实例化，他的虚函数表是不存在的，一个对象需要调用构造函数完成实例化，这里形成了一个悖论

在意义上，将构造函数声明为虚函数没有意义，虚函数主要是实现多态，c++的多态是在运行时构建基类基类来调用不同函数，而不是根据情况动态调用构造函数。构造函数作为虚函数让人觉得是你的构造函数可能是动态的，那我觉得这可能是另一个设计模式，对象固定，构建方法动态来达到多态的目的，后面这段是我自己的看法

析构函数作为虚函数？

构造函数是不行的，但是析构函数作为虚函数确实常用的，特别是基类的析构函数一定要声明为虚函数。首先既然对象存在，那么虚函数表肯定存在，所以析构函数作为虚函数是合理的。

那么析构函数作为虚函数在什么场景下会用到呢，看看下面这段代码

#include <iostream>
using namespace std;

class Father
{
public:
    Father() { cout << "contructor Father!" << endl; };
    ~Father() { cout << "destructor Father!" << endl; };
};

class Son :public Father
{
public:
    Son() { cout << "contructor Son!" << endl; };
    ~Son() { cout << "destructor Son!" << endl; };
};

int main()
{
    Father *pfather=new Son;
    delete pfather;
    pfather = NULL;

    return 0;
}

//ontructor Father!
//contructor Son!
//destructor Father!

这时候如果是基类指针指向子类对象，那么删除指针，只会调用基类的析构函数，因为这时候对象类型是基类对象，析构函数没有动态绑定，只会调用当前对象类型的析构。但是如果将基类析构函数声明为虚函数，则能成功调用子类的析构函数

#include <iostream>
using namespace std;

class Father
{
public:
    Father() { cout << "contructor Father!" << endl; };
    virtual ~Father() { cout << "destructor Father!" << endl; };
};

class Son :public Father
{
public:
    Son() { cout << "contructor Son!" << endl; };
    ~Son() { cout << "destructor Son!" << endl; };
};

int main()
{
    Father *pfather=new Son;
    delete pfather;
    pfather = NULL;

    return 0;
}

//ontructor Father!
//contructor Son!
//destructor Son!
//destructor Father!

那在构造函数里能调用虚函数吗

这个问题之前腾讯后端一面出现过，我当时有点蒙

首先编译器是允许你这么做的，但是在构造函数里调用虚函数，可能达不到你想要的效果，我们看看下面的代码

class Father
{
public:
    Father() { 
        cout << "contructor Father!" << endl; 
        f();
    };
    virtual void f() { cout << "Father f"<<endl; }
};

class Son :public Father
{
public:
    virtual void f() { cout << "Son f"<<endl; }
};

int main()
{
    Son *s=new Son;

    return 0;
}

//contructor Father!
//Father f

代码运行后，构造函数只调用了父类的虚函数，我们本来想要调用子类的虚函数。那么如果我们在子类中重新定义构造函数，那么程序如我们所愿

#include <iostream>
using namespace std;

class Father
{
public:
    Father() { 
        cout << "contructor Father!" << endl; 
        f();
    };
    virtual void f() { cout << "Father f"<<endl; }
};

class Son :public Father
{
public:
    Son() {
        cout << "contructor Son!" << endl;
        f();
    };
    virtual void f() { cout << "Son f"<<endl; }
};

int main()
{
    Son *s=new Son;

    return 0;
}

//contructor Father!
//Father f
//contructor Son!
//Son f

可是如果基类的f函数是一个纯虚函数呢，那么编译会不通过

#include <iostream>
using namespace std;

class Father
{
public:
    Father() { 
        cout << "contructor Father!" << endl; 
        f();
    };
    //virtual void f() { cout << "Father f"<<endl; }
    virtual void f() const = 0;
};

class Son :public Father
{
public:
    Son() {
        cout << "contructor Son!" << endl;
        f();
    };
    virtual void f() { cout << "Son f"<<endl; }
};

int main()
{
    Son *s=new Son; //编译不通过

    return 0;
}

析构函数里调用也是如此