C++ 静态工厂构造函数

Question

我正在进行模拟，它需要创建多个相当相似的模型。我的想法是有一个名为 Model 的类并使用静态工厂方法来构造模型。例如; Model::createTriangle 或 Model::createFromFile。我从以前的 java 代码中获得了这个想法，并正在寻找在 C++ 中实现它的方法。

这是我到目前为止的想法：

#include <iostream>

class Object {
    int id;

public:
    void print() { std::cout << id << std::endl; }

    static Object &createWithID(int id) {
        Object *obj = new Object();

        obj->id = id;

        return *obj; 
    }
};

int main() {
    Object obj = Object::createWithID(3);

    obj.print();

    return 0;
}

关于这个的一些问题：

• 这是一种可接受且干净的制作对象的方式吗？
• 返回的引用是否始终确保正确移除对象？
• 没有指针有没有办法做到这一点？

Answer 1

您的代码当前包含内存泄漏：使用new 创建的任何对象都必须使用delete 清理。 createWithID 方法最好不要使用 new，看起来像这样：

static Object createWithID(int id) 
{
    Object obj;
    obj.id = id;
    return obj; 
}

这似乎需要额外的对象副本，但实际上return value optimization 通常会导致该副本被优化掉。

Answer 2

为了记录，下面是这个程序在适当的 C++ 中的样子：

class Object
{
    int id;

    // private constructor, not for general use
    explicit Object(int i) : id(i) { }

public:
    static Object createWithID(int id)
    {
        return Object(id);
    }
};

int main()
{
    Object obj1 = Object::createWithID(1);
    auto obj2 = Object::createWithID(2);   // DRY

    // return 0 is implied
}

这可能不是人们通常所说的“工厂”，因为工厂通常涉及一些动态类型选择。但是，有时使用术语“命名构造函数”来指代返回类实例的静态成员函数。

Answer 3

这是一种可接受且干净的制作对象的方式吗？

它（不幸地）被接受了，但它不干净。

使用构造函数代替工厂函数。

这就是他们的目的。

返回的引用是否始终确保正确删除对象？

该引用无关紧要，除非它误导函数的用户。

在您的示例中，引用显然误导了您自己不破坏动态分配的对象，而只是复制它。

最好返回一个智能指针。

但如前所述，最好放弃工厂函数的想法。

这里完全没有必要。

有没有什么方法可以在没有指针的情况下做到这一点？

不，如果“this”指的是动态分配，则不是，但您可以并且应该使用构造函数而不是工厂函数。

---

例子：

#include <iostream>

namespace better {
    using std::ostream;

    class Object
    {
    public:
        auto id() const -> int { return id_; }
        explicit Object( int const id): id_( id ) {}
    private:
        int id_;
    };

    auto operator<<( ostream& stream, Object const& o )
        -> ostream&
    { return (stream << o.id()); }
}  // namespace better

auto main()
    -> int
{
    using namespace std;
    cout << better::Object( 3 ) << endl;
}

Answer 4

通过调用Object *obj = new Object();，您确实在堆上分配了内存。在该语句后面的行中，您确实返回了对该对象的引用。到目前为止，一切都很好，但您永远不会删除您创建的对象以实际释放内存。通过多次调用该函数，您将在内存泄漏中运行。

有两种可能的解决方法：

1. static Object createWithID(int id); 将返回您创建的对象的副本，因此使用

   在堆栈上分配它就足够了

   Object tmp;
   tmp.id = id;
   

2. 使用 c++11 智能指针让它们处理内存。

   #include <memory>
   static std::unique_ptr<Object> createWithID(int id)
   {
       std::unique_ptr<Object> tmp(new Object());
       tmp->id = id;
       return std::move(tmp);
   }
   

Answer 5

这是一种绝对糟糕的创建对象的方式。每次调用createWithID，都会在永远无法销毁的免费存储上构建一个新的Object。

您应该将createWithID 重写为：

static Object createWithID(int id) {
    Object obj;
    obj.id = id;
    return obj; 
}

或者更好的是，您可以只为您的 Object 对象提供一个构造函数。

如果你想启用多态对象，你应该使用wheels::value_ptr之类的东西。

Answer 6

除非您使用多态性，否则您的工厂函数没有理由返回任何类型的指针，它们可以按值返回对象。任何现代编译器都会做return value optimization，所以没有副本。

如果你追求的是一种“被接受和干净”的方式，那么这听起来很基于意见，并且取决于这个类的使用方式，但我要做的是将Model 的定义尽可能小。仅包含正常使用所需的最少构造函数来完成其工作所需的内容：

namespace Simulation {
  class Model {
   private: 
    int id_;
   public:
    explicit Model(int id) : id_(id) {}

    // minimum required to do the job...
  };
}

然后，我将定义函数以分别创建各种风格的Model。例如，作为命名空间中的非成员、非友元函数：

namespace Simulation {  
  Model createTriangle(int id) {
    Model model(id);
    // do whatever you need to do to make it a triangle...
    return model;
  }

  Model createSquare(int id) {
    Model model(id);
    // do whatever you need to do to make it a square...
    return model;
  }  
}

这样，如果您发现需要另一种风格的 Model，则无需更改 Model 类。如果需要，您的创建函数甚至可以分布在多个文件中，或者成为 Builder 或 Factory 类的一部分。用法如下：

int main() {
  Simulation::Model m1(0);
  Simulation::Model m2 = Simulation::createTriangle(1);
  Simulation::Model m3 = Simulation::createSquare(2);
}