如何在 C++ 中正确实现工厂方法模式

首先，在某些情况下，对象构造是一项复杂到足以证明将其提取到另一个类的任务。

我认为这一点是不正确的。复杂性并不重要。相关性是什么。如果一个对象可以一步构建（不像在构建器模式中），那么构造器就是正确的地方。如果你真的需要另一个类来执行这项工作，那么它应该是一个辅助类，无论如何都可以从构造函数中使用。

Vec2(float x, float y);
Vec2(float angle, float magnitude); // not a valid overload!

有一个简单的解决方法：

struct Cartesian {
  inline Cartesian(float x, float y): x(x), y(y) {}
  float x, y;
};
struct Polar {
  inline Polar(float angle, float magnitude): angle(angle), magnitude(magnitude) {}
  float angle, magnitude;
};
Vec2(const Cartesian &cartesian);
Vec2(const Polar &polar);

唯一的缺点是它看起来有点冗长：

Vec2 v2(Vec2::Cartesian(3.0f, 4.0f));

但好在你可以立即看到你正在使用的坐标类型，同时你不必担心复制。如果您想要复制，而且成本高昂（当然，正如分析所证明的那样），您可能希望使用 Qt's shared classes 之类的东西来避免复制开销。

至于分配类型，使用工厂模式的主要原因通常是多态性。构造函数不能是虚拟的，即使可以，也没有多大意义。使用静态或堆栈分配时，您不能以多态方式创建对象，因为编译器需要知道确切的大小。所以它只适用于指针和引用。从工厂返回引用也不起作用，因为虽然从技术上讲，对象可以通过引用删除，但它可能相当混乱且容易出错，例如 Is the practice of returning a C++ reference variable, evil?。所以指针是唯一剩下的东西，这也包括智能指针。换句话说，工厂在与动态分配一起使用时最有用，因此您可以执行以下操作：

class Abstract {
  public:
    virtual void do() = 0;
};

class Factory {
  public:
    Abstract *create();
};

Factory f;
Abstract *a = f.create();
a->do();

在其他情况下，工厂只是帮助解决您提到的过载问题。如果可以以统一的方式使用它们会很好，但它可能是不可能的并没有太大的伤害。

简单工厂示例：

// Factory returns object and ownership
// Caller responsible for deletion.
#include <memory>
class FactoryReleaseOwnership{
  public:
    std::unique_ptr<Foo> createFooInSomeWay(){
      return std::unique_ptr<Foo>(new Foo(some, args));
    }
};

// Factory retains object ownership
// Thus returning a reference.
#include <boost/ptr_container/ptr_vector.hpp>
class FactoryRetainOwnership{
  boost::ptr_vector<Foo>  myFoo;
  public:
    Foo& createFooInSomeWay(){
      // Must take care that factory last longer than all references.
      // Could make myFoo static so it last as long as the application.
      myFoo.push_back(new Foo(some, args));
      return myFoo.back();
    }
};

你有没有想过完全不使用工厂，而是很好地使用类型系统？我可以想到两种不同的方法来做这种事情：

选项1：

struct linear {
    linear(float x, float y) : x_(x), y_(y){}
    float x_;
    float y_;
};

struct polar {
    polar(float angle, float magnitude) : angle_(angle),  magnitude_(magnitude) {}
    float angle_;
    float magnitude_;
};


struct Vec2 {
    explicit Vec2(const linear &l) { /* ... */ }
    explicit Vec2(const polar &p) { /* ... */ }
};

这使您可以编写以下内容：

Vec2 v(linear(1.0, 2.0));

选项 2：

您可以像 STL 对迭代器等使用“标签”。例如：

struct linear_coord_tag linear_coord {}; // declare type and a global
struct polar_coord_tag polar_coord {};

struct Vec2 {
    Vec2(float x, float y, const linear_coord_tag &) { /* ... */ }
    Vec2(float angle, float magnitude, const polar_coord_tag &) { /* ... */ }
};

第二种方法使您可以编写如下所示的代码：

Vec2 v(1.0, 2.0, linear_coord);

这也很好并且富有表现力，同时允许您为每个构造函数拥有独特的原型。

您可以在以下位置阅读一个非常好的解决方案：http://www.codeproject.com/Articles/363338/Factory-Pattern-in-Cplusplus

最好的解决方案是关于“评论和讨论”，请参阅“无需静态创建方法”。

从这个想法，我做了一个工厂。请注意，我使用的是 Qt，但您可以将 QMap 和 QString 更改为 std 等效项。

#ifndef FACTORY_H
#define FACTORY_H

#include <QMap>
#include <QString>

template <typename T>
class Factory
{
public:
    template <typename TDerived>
    void registerType(QString name)
    {
        static_assert(std::is_base_of<T, TDerived>::value, "Factory::registerType doesn't accept this type because doesn't derive from base class");
        _createFuncs[name] = &createFunc<TDerived>;
    }

    T* create(QString name) {
        typename QMap<QString,PCreateFunc>::const_iterator it = _createFuncs.find(name);
        if (it != _createFuncs.end()) {
            return it.value()();
        }
        return nullptr;
    }

private:
    template <typename TDerived>
    static T* createFunc()
    {
        return new TDerived();
    }

    typedef T* (*PCreateFunc)();
    QMap<QString,PCreateFunc> _createFuncs;
};

#endif // FACTORY_H

示例用法：

Factory<BaseClass> f;
f.registerType<Descendant1>("Descendant1");
f.registerType<Descendant2>("Descendant2");
Descendant1* d1 = static_cast<Descendant1*>(f.create("Descendant1"));
Descendant2* d2 = static_cast<Descendant2*>(f.create("Descendant2"));
BaseClass *b1 = f.create("Descendant1");
BaseClass *b2 = f.create("Descendant2");

我大多同意接受的答案，但现有答案中没有涵盖 C++11 选项：

按值返回工厂方法结果，以及

提供一个廉价的移动构造函数。

例子：

struct sandwich {
  // Factory methods.
  static sandwich ham();
  static sandwich spam();
  // Move constructor.
  sandwich(sandwich &&);
  // etc.
};

然后就可以在栈上构造对象了：

sandwich mine{sandwich::ham()};

作为其他事物的子对象：

auto lunch = std::make_pair(sandwich::spam(), apple{});

或动态分配：

auto ptr = std::make_shared<sandwich>(sandwich::ham());

我什么时候可以使用这个？

如果在公共构造函数上，如果没有一些初步计算就不可能为所有类成员提供有意义的初始化器，那么我可能会将该构造函数转换为静态方法。静态方法执行初步计算，然后通过私有构造函数返回一个值结果，该构造函数只进行成员初始化。

我说“可能”是因为它取决于哪种方法可以提供最清晰的代码，而不会不必要地低效。

Loki 有一个 Factory Method 和一个 Abstract Factory。两者都在 Andei Alexandrescu 的 Modern C++ Design 中（广泛地）记录在案。工厂方法可能更接近您所追求的，尽管它仍然有点不同（至少如果内存服务，它需要您在工厂创建该类型的对象之前注册一个类型）。

我不会试图回答我所有的问题，因为我认为它太宽泛了。只是几个注意事项：

在某些情况下，对象构造是一项复杂到足以证明将其提取到另一个类的任务。

该类实际上是 Builder，而不是工厂。

在一般情况下，我不想强制工厂的用户被限制为动态分配。

然后你可以让你的工厂将它封装在一个智能指针中。我相信这样你也可以吃蛋糕。

这也消除了与按值返回有关的问题。

结论：通过返回对象来制造工厂确实是某些情况下的解决方案（例如前面提到的二维向量），但仍然不是构造函数的一般替代品。

的确。所有设计模式都有其（特定于语言的）约束和缺点。建议仅在它们帮助您解决问题时使用它们，而不是为了它们自己。

如果你在“完美”的工厂实施之后，那么，祝你好运。

这是我的 c++11 风格的解决方案。参数“base”是所有子类的基类。创建者是用于创建子类实例的 std::function 对象，可能是对您的子类的静态成员函数“create(some args)”的绑定。这可能并不完美，但对我有用。这是一种“通用”的解决方案。

template <class base, class... params> class factory {
public:
  factory() {}
  factory(const factory &) = delete;
  factory &operator=(const factory &) = delete;

  auto create(const std::string name, params... args) {
    auto key = your_hash_func(name.c_str(), name.size());
    return std::move(create(key, args...));
  }

  auto create(key_t key, params... args) {
    std::unique_ptr<base> obj{creators_[key](args...)};
    return obj;
  }

  void register_creator(const std::string name,
                        std::function<base *(params...)> &&creator) {
    auto key = your_hash_func(name.c_str(), name.size());
    creators_[key] = std::move(creator);
  }

protected:
  std::unordered_map<key_t, std::function<base *(params...)>> creators_;
};

使用示例。

class base {
public:
  base(int val) : val_(val) {}

  virtual ~base() { std::cout << "base destroyed\n"; }

protected:
  int val_ = 0;
};

class foo : public base {
public:
  foo(int val) : base(val) { std::cout << "foo " << val << " \n"; }

  static foo *create(int val) { return new foo(val); }

  virtual ~foo() { std::cout << "foo destroyed\n"; }
};

class bar : public base {
public:
  bar(int val) : base(val) { std::cout << "bar " << val << "\n"; }

  static bar *create(int val) { return new bar(val); }

  virtual ~bar() { std::cout << "bar destroyed\n"; }
};

int main() {
  common::factory<base, int> factory;

  auto foo_creator = std::bind(&foo::create, std::placeholders::_1);
  auto bar_creator = std::bind(&bar::create, std::placeholders::_1);

  factory.register_creator("foo", foo_creator);
  factory.register_creator("bar", bar_creator);

  {
    auto foo_obj = std::move(factory.create("foo", 80));
    foo_obj.reset();
  }

  {
    auto bar_obj = std::move(factory.create("bar", 90));
    bar_obj.reset();
  }
}

工厂模式

class Point
{
public:
  static Point Cartesian(double x, double y);
private:
};

如果你的编译器不支持返回值优化，放弃它，它可能根本不包含太多优化......

extern std::pair<std::string_view, Base*(*)()> const factories[2];

decltype(factories) factories{
  {"blah", []() -> Base*{return new Blah;}},
  {"foo", []() -> Base*{return new Foo;}}
};

我知道这个问题已在 3 年前得到回答，但这可能是您正在寻找的。

谷歌几周前发布了一个库，允许简单灵活的动态对象分配。这是：http://google-opensource.blogspot.fr/2014/01/introducing-infact-library.html