C++ 中的惰性/多阶段构造

Question

对于 C++ 中对象的多阶段构造/初始化，现有的良好类/设计模式是什么？

我有一个类，其中包含一些数据成员，这些数据成员应该在程序流程中的不同点进行初始化，因此必须延迟它们的初始化。例如，一个参数可以从文件中读取，另一个参数可以从网络中读取。

目前，我正在使用 boost::Optional 来延迟构造数据成员，但令我困扰的是，可选在语义上与延迟构造不同。

我需要的是 boost::bind 和 lambda 部分函数应用程序的功能，并且使用这些库我可能可以设计多阶段构造 - 但我更喜欢使用现有的、经过测试的类。 （或者也许还有另一种我不熟悉的多阶段构建模式）。

Answer 1

关键问题是是否应该在类型级别区分完全填充的对象和不完全填充的对象。如果您决定不做区分，那么只需使用 boost::Optional 或类似的方法即可：这样可以轻松快速地进行编码。 OTOH，您无法让编译器强制执行特定函数需要完全填充的对象的要求；您每次都需要对字段执行运行时检查。

参数组类型

如果确实在类型级别区分完全填充的对象和不完全填充的对象，则可以强制要求向函数传递完整的对象。为此，我建议为每个相关类型 X 创建相应的类型 XParams。 XParams 具有 boost::optional 成员和每个参数的 setter 函数，可以在初始构造后设置。然后，您可以强制 X 仅具有一个（非复制）构造函数，该构造函数将 XParams 作为其唯一参数，并检查每个必要的参数是否已在该 X 中设置。代码>XParams 对象。 （不确定这个模式是否有名称——有人喜欢编辑它来填充我们吗？）

“部分对象”类型

如果您实际上不需要对对象做任何事情，那么这会非常有用。在它完全填充之前（也许除了像取回字段值这样的琐碎事情之外）。如果有时确实必须将未完全填充的 X 视为“完整”X，则可以使 X 从类型 派生>XPartial，其中包含所有逻辑，以及用于执行前提条件测试的受保护的虚拟方法，以测试是否填充了所有必需的字段。然后，如果 X 确保它只能在完全填充的状态下构造，它可以通过始终返回 true 的简单检查来覆盖那些受保护的方法：

class XPartial {
    optional<string> name_;

public:
    void setName(string x) { name_.reset(x); }  // Can add getters and/or ctors
    string makeGreeting(string title) {
        if (checkMakeGreeting_()) {             // Is it safe?
            return string("Hello, ") + title + " " + *name_;
        } else {
            throw domain_error("ZOINKS");       // Or similar
        }
    }
    bool isComplete() const { return checkMakeGreeting_(); }  // All tests here

protected:
    virtual bool checkMakeGreeting_() const { return name_; }   // Populated?
};

class X : public XPartial {
    X();     // Forbid default-construction; or, you could supply a "full" ctor

public:
    explicit X(XPartial const& x) : XPartial(x) {  // Avoid implicit conversion
        if (!x.isComplete()) throw domain_error("ZOINKS");
    }

    X& operator=(XPartial const& x) {
        if (!x.isComplete()) throw domain_error("ZOINKS");
        return static_cast<X&>(XPartial::operator=(x));
    }

protected:
    virtual bool checkMakeGreeting_() { return true; }   // No checking needed!
};

尽管看起来可能这里的继承是“从后到前”，这样做意味着可以在任何需要 XPartial& 的地方安全地提供 X，因此这种方法遵循 < a href="http://en.wikipedia.org/wiki/Liskov_substitution_principle" rel="nofollow noreferrer">里氏替换原理。这意味着函数可以使用 X& 参数类型来指示它需要一个完整的 X 对象，或使用 XPartial& 来指示它可以处理部分填充的对象——在这种情况下，可以传递 XPartial 对象或完整的 X 对象。

最初我将 isComplete() 作为 protected，但发现这不起作用，因为 X 的复制构造函数和赋值运算符必须调用此函数他们的 XPartial& 参数，并且他们没有足够的访问权限。经过反思，公开公开此功能更有意义。

Answer 2

我一定错过了一些东西——我一直在做这种事情。在所有情况下，类都不需要很大的对象和/或不需要的对象是很常见的。所以动态地创建它们！

struct Big {
    char a[1000000];
};

class A {
  public: 
    A() : big(0) {}
   ~A() { delete big; }

   void f() {
      makebig();
      big->a[42] = 66;
   }
  private:
    Big * big;
    void makebig() {
      if ( ! big ) {
         big = new Big;
      }
    }
};

我不认为需要任何比这更奇特的东西，除了 makebig() 可能应该是 const （并且可能是内联），并且 Big 指针可能应该是可变的。当然，A 必须能够构造 Big，这在其他情况下可能意味着缓存所包含的类的构造函数参数。您还需要决定复制/作业策略 - 对于此类课程，我可能会禁止这两种策略。

Answer 3

我不知道有什么模式可以处理这个特定问题。这是一个棘手的设计问题，对于 C++ 等语言来说有些独特。另一个问题是，这个问题的答案与您的个人（或公司）编码风格密切相关。

我会为这些成员使用指针，当需要构造它们时，同时分配它们。您可以对它们使用 auto_ptr，并检查 NULL 以查看它们是否已初始化。 （我认为指针是 C/C++/Java 中内置的“可选”类型，还有其他语言，其中 NULL 不是有效的指针）。

风格方面的一个问题是您可能依赖构造函数来完成太多工作。当我编写面向对象的代码时，我让构造函数完成足够的工作以使对象处于一致状态。例如，如果我有一个 Image 类，并且我想从文件中读取数据，我可以这样做：

image = new Image("unicorn.jpeg"); /* I'm not fond of this style */

或者，我可以这样做： 如果

image = new Image(); /* I like this better */
image->read("unicorn.jpeg");

如果构造函数中有很多代码，特别是如果您问“如果构造函数失败会发生什么？”的问题。这是将代码移出构造函数的主要好处。

我还有更多话要说，但我不知道你想对延迟施工做什么。

编辑：我记得有一种（有点反常的）方法可以在任意时间调用对象的构造函数。这里有一个例子：

class Counter {
public:
    Counter(int &cref) : c(cref) { }
    void incr(int x) { c += x; }
private:
    int &c;
};

void dontTryThisAtHome() {
    int i = 0, j = 0;
    Counter c(i);       // Call constructor first time on c
    c.incr(5);          // now i = 5
    new(&c) Counter(j); // Call the constructor AGAIN on c
    c.incr(3);          // now j = 3
}

请注意，做这样鲁莽的事情可能会招致其他程序员的蔑视，除非你有充分的理由使用这种技术。这也不会延迟构造函数，只是让您稍后再次调用它。

Answer 4

对于某些用例来说，使用 boost.Optional 看起来是一个很好的解决方案。我没玩过太多，所以不能发表太多评论。在处理此类功能时，我要记住的一件事是我是否可以使用重载构造函数而不是默认构造函数和复制构造函数。

当我需要这样的功能时，我只需使用指向必要字段类型的指针，如下所示：

public:
  MyClass() : field_(0) { } // constructor, additional initializers and code omitted
  ~MyClass() {
    if (field_)
      delete field_; // free the constructed object only if initialized
  }
  ...
private:
  ...
  field_type* field_;

接下来，我将通过以下方法访问该字段，而不是使用指针：

private:
  ...
  field_type& field() {
    if (!field_)
      field_ = new field_type(...);
    return field_;
  }

我省略了 const-access 语义

Answer 5

我所知道的最简单的方法类似于 Dietrich Epp 建议的技术，只不过它允许您真正延迟对象的构造，直到您选择的时刻。

基本上：使用 malloc 而不是 new 保留对象（从而绕过构造函数），然后当您真正想要通过放置 new 构造对象时调用重载的 new 运算符。

示例：

Object *x = (Object *) malloc(sizeof(Object));
//Use the object member items here. Be careful: no constructors have been called!
//This means you can assign values to ints, structs, etc... but nested objects can wreak havoc!

//Now we want to call the constructor of the object
new(x) Object(params);

//However, you must remember to also manually call the destructor!
x.~Object();
free(x);

//Note: if you're the malloc and new calls in your development stack 
//store in the same heap, you can just call delete(x) instead of the 
//destructor followed by free, but the above is the  correct way of 
//doing it

就我个人而言，我唯一一次使用此语法是当我必须为 C++ 对象使用基于 C 的自定义分配器时。正如 Dietrich 所建议的，您应该质疑是否真的必须延迟构造函数调用。 base 构造函数应该执行最低限度的操作以使对象进入可用状态，而其他重载构造函数可能会根据需要执行更多工作。

Answer 6

我不知道这是否有正式的模式。在我见过的地方，我们称之为“惰性”、“需求”或“按需”。