如何使用本QA中描述的技术？
Prevent calls to default constructor for an array inside class

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

或者，您也可以考虑使用union。AFAIK，unions will be initialized only with first named member's constructor.
比如说

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

根据QA中提到的标准，c将被零初始化，并且其构造函数不会被调用。

你不能
当进入construcotr代码块时，所有成员变量都被完全构造。这意味着必须调用这些构造函数。
但是你可以绕过这个限制。

// 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有一个初始化方法，使类可用
• C跟踪它是否被正确初始化，如果没有初始化就使用它，它会返回相应的错误。

只需使用逗号表达式：

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

显然，正如其他人所解释的那样，m_B最好在m_C之前声明，否则m_B.doSomething()会调用未定义的行为。

指针听起来像是唯一干净的解决方案。我看到的唯一其他解决方案是为C设置一个默认的构造函数，它什么也不做，并在C中设置一个初始化方法，稍后您自己调用。
int n.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，使其具有两步初始化过程。然后，构造函数将构造一个“僵尸”对象，您必须在该m_C示例上调用Initialize方法来完成初始化。这与您发现的现有情况类似，您可以将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的方法中。

这里我们有构建块：

#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();
  }
};

现在使用从B派生的类B1：

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()