Избегайте вызова конструктора переменной-члена

То, что вы просите, запрещено - и это правильно. Это гарантирует, что каждый элемент будет правильно инициализирован. Не пытайтесь обойти это — постарайтесь структурировать свои классы, чтобы они с этим работали.

Идея:

• C имеет конструктор, который ничего не делает
• C имеет метод инициализации, который делает класс пригодным для использования
• C отслеживает, правильно ли он был инициализирован, и возвращает соответствующие ошибки, если используется без инициализации.

Как насчет использования техники, описанной в этом QA?

Запретить вызовы конструктора по умолчанию для массива внутри класса

std::aligned_storage<sizeof(T[n]), alignof(T)>::type

Или вы также можете рассмотреть возможность использования union. Насколько я знаю, союзы будут инициализированы только с помощью конструктора первого именованного члена. < /а>

union
{
   uint8_t _nothing = 0; 
   C c;
};

Вы не можете.

Все переменные-члены полностью создаются при вводе блока кода конструктора. Это означает, что должны быть вызваны конструкторы.

Но вы можете обойти это ограничение.

// Header-File
class A
{
    struct Initer
    {
         Initer(B& b)
             : m_b(b)
         {
             m_b.doSomething();
             m_b.doMore();
         }
         operator int()  // assuming getSomeValue() returns int.
         {
             return m_b.getSomeValue();
         }
         B& m_b;
    };
    public:
    A();

    private:   // order important.
    B m_B;
    C m_C;
};


// cpp-File
A::A()
: m_B(1)
, m_C(Initer(m_B))
{
}

Я не вижу хорошего способа добиться того, чего вы хотите. Это должно быть обходным путем:

// Header-File
class A
{
    public:
    A();

    private:
    B m_B;
    C m_C;
    static int prepareC(B& b);
};

// cpp-File
A::A()
: m_B(1)
, m_C(prepareC(m_B))
{
}

int A::prepareC(B& b)
{
    b.doSomething();
    b.doMore();
    return b.getSomeValue();
}

Убедитесь, что m_B.doSomething(), m_B.doMore() и m_B.getSomeValue() не касаются m_C (прямо или косвенно).

Как правильно отмечает @Tobias, это решение зависит от порядка инициализации. Вы должны убедиться, что определения m_B и m_C находятся в этом порядке.

Обновил код по идее @Loki.

Указатель звучит как единственное чистое решение для меня. Единственное другое решение, которое я вижу, - это иметь конструктор по умолчанию для C, который ничего не делает, и иметь метод инициализации в C, который вы позже вызовете сами.

m_C.Initialise( m_B.getSomeValue());

Проще всего хранить указатели на B и C. Они могут быть инициализированы до 0, опуская любую конструкцию. Будьте осторожны, чтобы не разыменовать нулевой указатель и не удалить его в деструкторе A (или использовать std::unique_ptr/boost::scoped_ptr).

Но почему бы не инициализировать сначала m_B (с помощью надлежащего вызова конструктора, а не в A::A(), а затем использовать этот инициализированный экземпляр B для инициализации m_C? Это потребует небольшой перезаписи, но я уверен, что это будет стоить очистки кода.

Если вы не хотите выделять его динамически, используя new из соображений безопасности кода/исключений, вы можете использовать std::unique_ptr или std::auto_ptr для решения этой проблемы.

Решение, позволяющее избежать new, состоит в том, чтобы отредактировать C, чтобы иметь двухэтапный процесс инициализации. Затем конструктор создаст объект «зомби», и вам нужно будет вызвать метод Initialize для этого экземпляра m_C, чтобы завершить инициализацию. Это похоже на существующие случаи, когда вы могли передать NULL конструктору, а затем вернуться к инициализации объекта.

Изменить:

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

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

Просто используйте статический метод в качестве посредника при инициализации:

class A
{
public:
    A();

private:
    static int InitFromB(B& b)
    {
        b.doSomething();
        b.doMore();
        return b.getSomeValue();
    }

    // m_B must be initialized before m_C
    B m_B;
    C m_C;
};

A::A()
    : m_B(1)
    , m_C(InitFromB(m_B))
{
}

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

Просто используйте запятые:

A::A()
  : m_B(1)
  , m_c(m_B.doSomething(), m_B.doMore(), m_B.getSomeValue())
{
}

Очевидно, как объяснили другие, m_B лучше объявить до m_C, иначе m_B.doSomething() вызовет неопределенное поведение.

Здесь у нас есть строительные блоки:

#include <iostream>

class C
{
public:
  C(int i){std::cout << "C::C(" << i << ")" << std::endl;}
};

class B
{
public:
  B(int i){std::cout << "B::B(" << i << ")" << std::endl;}
  void doSomething(){std::cout << "B::doSomething()" << std::endl;}
  void doMore(){std::cout << "B::doMore()" << std::endl;}
  int getSomeValue(){return 42;}
};

Если вы хотите создать новый тип конструкции для B, рассмотрите возможность создания производного класса:

class B1 : public B
{
public:
  B1() : B(1)
  {
    doSomething();
    doMore();
  }
};

Теперь используйте класс B1, производный от B:

class A
{
private:
  B1 _b;
  C _c;
public:
  A() : _c(_b.getSomeValue()){std::cout << "A::A()" << std::endl;}
};

А потом:

int main()
{
  A a;
}

Выход:

B::B(1)
B::doSomething()
B::doMore()
C::C(42)
A::A()