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构造函数的方法。

©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页