C++构造与析构(16) - virtual构造函数

C++能否定义构造函数为virtual来创建多态的对象？

答案是不行！C++是一门静态类型的语言(RTTI的目的与这里的动态创建对象不同)，多态地创建对象没有什么意义。编译器必须知道类的确切类型，才能创建对象。
换言之，对象的类型是什么，是在C++编译期间就已经决定了的。如果用户将构造函数定义为virtual, 则编译器会报错。
实际上，除了inline，其它所有关键字都不能用来声明构造函数。
 

在下面的演示例子中，我们需要创建一个继承类，基于一些输入条件。换句话说，对象的创建和对象的类型是紧密地耦合一起，这样强制地实现扩展。而virtual构造函数的目的是解耦对象创建与对象类型。

如何在运行时创建特定类型的对象？参考下面例子：

#include <iostream>
using namespace std;

class Base
{
public:
    Base() { }
    virtual ~Base() { } // 确保能够调用实际操作对象的析构函数
    virtual void DisplayAction() = 0;  // 做为一个接口
};

class Derived1 : public Base
{
public:
    Derived1() { cout << "Derived1 created" << endl; }
    ~Derived1() { cout << "Derived1 destroyed" << endl; }
    void DisplayAction() { cout << "Action from Derived1" << endl; }
};

class Derived2 : public Base
{
public:
    Derived2() { cout << "Derived2 created" << endl; }
    ~Derived2() { cout << "Derived2 destroyed" << endl; }
    void DisplayAction() { cout << "Action from Derived2" << endl; }
};

class User
{
public:
    // 创建Drived1
    User() : pBase(NULL) {
        // 如果需要Derived2，如何处理？常规方式是添加if-else。参考下一个例子。
        pBase = new Derived1();
    }
    ~User() {
        if (pBase) {
            delete pBase;
            pBase = NULL;
        }
    }
    // 委托给实际对象
    void Action(){ pBase->DisplayAction(); }
private:
    Base* pBase;
};

int main()
{
    User* user = new User();
    // 当前仅需要Derive1.下一个例子会使用更多类型。
    user->Action();
    delete user;
}

运行结果：
Derived1 created
Action from Derived1
Derived1 destroyed

上面程序中，假设继承体系Base，Derived1和Derived2做为library code。 User类是library code的使用者。main函数通过User class来使用Base继承体系。
User class的构造函数中创建了Derived1的对象。如果需要使用Derived2，则必须调用new Derived2()并且需要重新编译。重新编译是一个坏的设计实践。所以调整为下面的方法。
在深入细节前，先回答一下，是谁决定创建Derived1还是Derived2对象？很明显，是User类。User类可以利用if-else来实现创建Derived1还是Derived2，如下面例子所示：

#include <iostream>
using namespace std;

class Base
{
public:
    Base() { }
    virtual ~Base() { } // 确保能够调用实际操作对象的析构函数
    virtual void DisplayAction() = 0;  // 做为一个接口
};

class Derived1 : public Base
{
public:
    Derived1() { cout << "Derived1 created" << endl; }
    ~Derived1() { cout << "Derived1 destroyed" << endl; }
    void DisplayAction() { cout << "Action from Derived1" << endl; }
};

class Derived2 : public Base
{
public:
    Derived2() { cout << "Derived2 created" << endl; }
    ~Derived2() { cout << "Derived2 destroyed" << endl; }
    void DisplayAction() { cout << "Action from Derived2" << endl; }
};

class User
{
public:
    // 基于输入的条件，决定创建Derived1还是Derived2
    User() : pBase(0) {
        int input; // ID用来区分Derived1和Derived2
        cout << "Enter ID (1 or 2): ";
        cin >> input;
        while ((input != 1) && (input != 2)) {
            cout << "Enter ID (1 or 2 only): ";
            cin >> input;
        }
        if (input == 1) {
            pBase = new Derived1;
        } else {
            pBase = new Derived2;
        }
        // 如果类继承体系中加入了Derived3，怎么办？
    }
    ~User() {
        if (pBase) {
            delete pBase;
            pBase = NULL;
        }
    }
    // 委托给实际对象
    void Action(){ pBase->DisplayAction(); }
private:
    Base* pBase;
};

int main()
{
    User* user = new User();
    // 调用Derived1或Derived2功能
    user->Action();
    delete user;
}

运行结果：
Enter ID (1 or 2): 1
Derived1 created
Action from Derived1
Derived1 destroyed
或者
Enter ID (1 or 2): 2
Derived2 created
Action from Derived2
Derived2 destroyed

上面的代码不具备灵活性。如果继承体系中加入了新的类Derived3，则User的构造函数也得跟着修改，会有更多的if-else。
此类代码会导致User 类需要重新编译，很糟糕的设计。并且将来Base扩展了，User还得跟着变。

问题在哪里？在于对象的创建上面。继承体系中每加入一个新的类，导致User类需要重新修改，编译。
能否将创建对象的这个动作委托给继承体系自身，或是某个拥有"虚行为"的函数呢？ 依靠将创建对象的动作委托给类继承本身(或是一个静态函数)，我们可以避免User与Base之间太多的耦合。
参考下面例子：

#include <iostream>
using namespace std;

class Base
{
public:
    // 这就是那个"虚函数"
    static Base* Create(int id);
    Base() { }
    virtual ~Base() { } // 确保能够调用实际操作对象的析构函数
    virtual void DisplayAction() = 0;  // 做为一个接口
};

class Derived1 : public Base
{
public:
    Derived1() { cout << "Derived1 created" << endl; }
    ~Derived1() { cout << "Derived1 destroyed" << endl; }
    void DisplayAction() { cout << "Action from Derived1" << endl; }
};

class Derived2 : public Base
{
public:
    Derived2() { cout << "Derived2 created" << endl; }
    ~Derived2() { cout << "Derived2 destroyed" << endl; }
    void DisplayAction() { cout << "Action from Derived2" << endl; }
};

class Derived3 : public Base
{
public:
    Derived3(){ cout << "Derived3 created" << endl; }
    ~Derived3() { cout << "Derived3 destroyed" << endl; }
    void DisplayAction() { cout << "Action from Derived3" << endl; }
};

// 也可以在Base类的外边声明Create，但是因为此函数与Base相关，所以还是限定作用域在Base中。
Base* Base::Create(int id)
{
    // 只需要扩展if-else分支即可。如果有新的Derived类加入，User类的代码不需要重新编译就可以
    //创建新增加的类对象。
    if (id == 1){
        return new Derived1;
    }
    else if (id == 2){
        return new Derived2;
    }
    else{
        return new Derived3;
    }
}

class User
{
public:
    // 基于输入的条件，决定创建Derived1还是Derived2
    User() : pBase(0) {
        int input; // ID用来区分Derived1和Derived2
        cout << "Enter ID (1, 2 or 3): ";
        cin >> input;
        while ((input != 1) && (input != 2) && (input != 3))
        {
            cout << "Enter ID (1, 2 or 3 only): ";
            cin >> input;
        }
        // 从"Virtual Constructor"中获取类型
        pBase = Base::Create(input);
    }
    ~User() {
        if (pBase) {
            delete pBase;
            pBase = NULL;
        }
    }
    // 委托给实际对象
    void Action() { pBase->DisplayAction(); }
private:
    Base* pBase;
};

int main()
{
    User* user = new User();
    user->Action();
    delete user;
}

此时，User类独立于对象创建。将责任委托给了Base类，并且提供了ID的一个input。如果有新的类Derived4加入，只需要在函数Create()中扩展if-else分支即可，从而返回合适的对象。Base的扩展变化，不会导致User需要重新编译。

注意：函数Create()在Base对象的运行期间返回不同的类型。它的行为像是"virtual构造函数"，或是设计模式中的工厂方法，可以参考本人的这篇文章--《设计模式(1) - Factory工厂模式》。

设计模式中有很多方法可以实现本文的概念。上面的代码可能存在一些问题，只是为了简单的说明一些实现virtual构造函数的方法。