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

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

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

#include <iostream>
using namespace std;

//// LIBRARY START
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;
}
};

//// LIBRARY END

class User
{
public:

// 创建Drived1
User() : pBase(0)
{
// 如果需要Derived2，如何处理？常规方式是添加if-else。参考下一个例子。
pBase = new Derived1();
}

~User()
{
if( pBase )
{
delete pBase;
pBase = 0;
}
}

// 委托给实际对象
void Action()
{
pBase->DisplayAction();
}

private:
Base *pBase;
};

int main()
{
User *user = new User();

// 当前仅需要Derive1.下一个例子会使用更多类型。
user->Action();

delete user;
}

上面程序中，假设继承体系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;

//// LIBRARY START
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;
}
};

//// LIBRARY END

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

void Action()
{
pBase->DisplayAction();
}

private:
Base *pBase;
};

int main()
{
User *user = new User();

// 调用Derived1或Derived2功能
user->Action();

delete user;
}

上面的代码不具备灵活性。如果继承体系中加入了新的类Derived3, 则User的构造函数也得跟着修改，会有更多的if-else。如下所示：

#include <iostream>
using namespace std;

class User
{
public:
User() : pBase(0)
{
int input; // ID来决定创建Derived1, Derived2或者Derived3

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 if( input == 2 )
{
pBase = new Derived2;
}
else
{
pBase = new Derived3;
}
}

~User()
{
if( pBase )
{
delete pBase;
pBase = 0;
}
}

void Action()
{
pBase->DisplayAction();
}

private:
Base *pBase;
};

上面代码会导致User 类需要重新编译，糟糕的设计(不灵活)! 并且将来Base扩展了，User还得跟着变。

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

#include <iostream>
using namespace std;

//// LIBRARY START
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;
}
}
//// LIBRARY END

class User
{
public:
User() : pBase(0)
{
int input;

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

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构造函数", 或是设计模式中的工厂方法。
设计模式中有很多方法可以实现本文的概念。上面的代码可能存在一些问题，只是为了简单的提供一些实现virtual构造函数的方法。