Question

在虚构造函数中，有虚函数，它使用虚函数返回对象的新对象或副本。但是，要以多态方式调用这些虚函数，必须使用实际构造函数创建该类的对象。

在设计模式上下文中，它意味着客户端在使用多态对象创建方式之前是否知道对象的类型？

Answer 1

客户不一定要了解具体类型。例如，请考虑以下层次结构：

struct Base
{
    virtual ~Base();
    virtual Base * clone() const = 0;
    static Base * create(std::string const &);
    // ...
};

struct A : Base { A * clone() const { return new A(*this); } /* ... */ };
struct B : Base { B * clone() const { return new B(*this); } /* ... */ };
struct C : Base { C * clone() const { return new C(*this); } /* ... */ };

Base * Base::create(std::string const & id)
{
    if (id == "MakeA") return new A;
    else return new C;
};

在这种情况下，客户端可以像这样制作和复制现有对象：

Base * p = Base::create("IWantB");  // or std::unique_ptr<Base> !
Base * q = p->clone();

在任何情况下，客户都不知道*p或*q的动态类型。

Answer 2

class Base
{
public:
    Base() { }

    virtual ~Base() { }

    // The "Virtual Constructor"
    static Base *Create(int id);

    // The "Virtual Copy Constructor"
    virtual Base *Clone() = 0;
};

Base *Base::Create(int id)
{

    if( id == 1 )
    {
        return new Derived1;
    }
}

class Derived1 : public Base
{
public:
    Derived1()
    {
        cout << "Derived1 created" << endl;
    }

    Derived1(const Derived1& rhs)
    {
        cout << "Derived1 created by deep copy" << endl;
    }

    ~Derived1()
    {
        cout << "~Derived1 destroyed" << endl;
    }

    Base *Clone()
    {
        return new Derived1(*this);
    }
};

当你做

时，现在在Main

void main()
{
        cout << "Enter ID (1, 2 or 3): ";
        cin >> input;
        Base *pBase = Base::Create(input);
        Base *pCopy = CreateCopy(pBase);

        //Dont know what object is created but still access functions thru base pointer
}

Base *CreateCopy(Base *pBase)
{
  return pBase->Clone();
}

客户端不需要知道它继承的类的类型，但仍然会调用某个函数。

Answer 3

最终某处必须知道对象的具体类型。隐藏该细节的想法会产生一种称为inversion of control的模式，或者最近的dependency injection模式。

我们的想法是在整个程序中提名一个组件，它知道所使用的具体类型。然后由此组件负责组装对象图;其他组件将它们的依赖关系仅作为接口，它们在构造或方法中传递。

C ++有一些依赖注入器实现：spring-cpp，autumnframework和dicpp。我自己编写了一个名为sauce的文件，它模仿了名为guice的java框架的样式。

Answer 4

客户端不知道派生类型的虚拟构造函数。这个习惯用法的全部目的是通过基指针克隆一个对象。这是一个例子：

class base
{
public:
   base* clone()
   {
       // NVI: implemented by derived classes.
       do_clone();
   }

 protected:
   virtual base* do_clone = 0;
};

class derived : public base
{
protected:
    virtual derived* do_clone()
    {
        // Implementation. Note the return value is not base*.
    }
 };

有关详细信息，请参阅此ACCU文章：http://accu.org/index.php/journals/522

虚拟构造函数成语和工厂设计

4 个答案: