Ленивая конструкция / конструкция мультиэтапа в C++

Я не знаю, есть ли формальный шаблон для этого. В местах, где я его видел, мы назвали это «ленивым», «спросом» или «по требованию».

Использование 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

Я не знаю никаких моделей для решения этой конкретной проблемы. Это сложный дизайн вопроса, и один несколько уникальный для языков, таких как C ++. Другой проблемой состоит в том, что ответ на этот вопрос тесно связан с вашим индивидуальным (или корпоративным) стилем кодирования.

Я бы использовал указатели для этих членов, и когда они должны быть построены, выделите их одновременно. Вы можете использовать AUTO_PTR для них и проверять против NULL, чтобы увидеть, инициализируются ли они. (Я думаю, что указатели представляют собой встроенный «дополнительный» тип в C / C ++ / Java, есть другие языки, где NULL не является действительным указателем).

Одной из проблем в стиле является то, что вы можете полагаться на своих конструкторов, чтобы сделать слишком много работы. Когда я кодирую oO, у меня есть конструкторы, достаточно работа, чтобы получить объект в согласованном состоянии. Например, если у меня есть изображение класса , и я хочу прочитать из файла, я мог бы сделать это:

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

или, я мог бы сделать это:

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

Может быть трудно расследуться о том, как Программа C ++ работает, если у конструкторов есть много кода в них, особенно если вы задаете вопрос: «Что произойдет, если конструктор не удается?» Это основное преимущество движущегося кода из конструкторов.

Я бы больше сказал, но я не знаю, что вы пытаетесь сделать с отсроченным строительством.

Редактировать: Я вспомнил, что есть (несколько извращенный) способ вызвать конструктор на объекте в любое произвольное время. Вот пример:

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
}

Обратите внимание, что делает что-то безрассудное, так как это может заработать вам презрение ваших товарищей по программистам, если только у вас есть солидные причины использования этой техники. Это также не задерживает конструктор, просто позволяет вам позвонить позже.

Самый простой способ, который я знаю, похож на технику, предложенную Дитрихом Эппом, за исключением того, что он позволяет по-настоящему отложить строительство объекта до момента выбора.

В принципе: резервируйте объект с помощью 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++. Как предлагает Дитрих, вы должны спросить, действительно ли вы должны задерживать вызов конструктора. Конструктор base должен выполнять минимум, чтобы привести ваш объект в работоспособное состояние, в то время как другие перегруженные конструкторы могут выполнять больше работы по мере необходимости.

Я должен пропустить что-то здесь - я делаю такого рода вещей все время. Очень распространено, чтобы иметь объекты, которые большие и / или не нуждаются в классе при любых обстоятельствах. Так что создайте их динамически!

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 (и, возможно, встроенный), а большой указатель, вероятно, должен быть изменен. И, конечно, должен быть в состоянии построить большую, что может в других случаях, что означает кэширование параметров конструктора класса класса. Вам также нужно будет определиться с политикой копирования / назначения - я бы, вероятно, запретил как для такого класса.