C++ 类：是否可以在构造函数体中选择成员的构造函数？ （没有双重初始化成员）

Question

考虑一下：

class Foo {
    private:
        Bar x;

    public:
        Foo(int a) { // no initialization here since constructor is dependent on a following if-block
            if (a==0) x=Bar(12,'a', 34);  // some (int, char, int) constructor of Bar
            else x=Bar(13); // (int) constructor of Bar
      }
}

这应该做的是检查参数a的值，并根据a的值使用某个构造函数和某些参数初始化Bar x。然而问题是，这当然被编译器读取为

        Foo(int a): Bar() { // !
            if (a==0) x=Bar(12,'a', 34);  // some Bar(int, char, int) constructor of Bar
            else x=Bar(13); // Bar(int) constructor of Bar
        }

编译器将 Bar() 添加到初始化列表中，因为我省略了它。它现在被双重初始化，一次使用它的 () 构造函数，一次在函数体中。但是如果初始化 Bar（即使使用它的默认构造函数）非常昂贵（关于性能）并且我不能或不想要这种双重初始化呢？

在实际的构造函数体中之前，我如何才能不初始化 Bar x？ 如果不可能，我将如何最好地解决这个问题？

补充：为什么 C++ 是这样设计的？为什么它在实际的构造函数体之前强制初始化成员？

Answer 1

我认为你问错了问题，而不是试图禁止初始化，你应该这样做，即将你的 ctor 拼写为：

Foo(int a) : x((a==0) ? Bar(12,'a', 34) : Bar(13)) {}

这不会导致任何复制或移动（请参阅here），并且是惯用的。

Answer 2

不，你不能。当在 ctor 主体中时，成员保证会被初始化。

整个初始化顺序很好地定义为：

• 首先，最派生类的构造函数调用虚拟基类子对象的构造函数。虚拟基类按深度优先、从左到右的顺序初始化。
• 接下来，直接基类子对象按照它们在类定义中声明的顺序构造。
• 接下来，（非静态）成员子对象按照它们的顺序构造 在类定义中声明。
• 最后，构造函数的主体被执行。

Answer 3

您可以将x 设为std::unique_ptr<Bar>，然后在ctor 中根据需要分配它。

Answer 4

C++ 是这样设计的，因此构造函数实际上是在构造和初始化事物，而不是让你在脚下开枪。

尽管如此，从 C++11 开始，您现在可以使用一种后门踢脚技术：除非您明确构造匿名联合的成员，否则它们不会被构造。代码是：

class Foo
{
    union 
    {
        Bar x;
    };

public:
    Foo(int a)
    {
        if (a==0) 
            new(&x) Bar(12,'a', 34);
        else
            new(&x) Bar(13);
    }

    ~Foo()
    {
         x.~Bar();
    }
};

要明确，这应该是最后的手段。编译器生成的复制构造函数、移动构造函数等被定义为已删除，因此如果您希望这些操作可用，您也需要实现它们。

Answer 5

在内存方面比匿名联合解决方案稍微贵一些，但更不容易出错并且不会产生额外的复制/移动或动态分配。

class Foo {
    private:
        std::experimental::optional<Bar> x;

    public:
        Foo(int a) {
            if (a==0) x.emplace(12,'a', 34);  // some (int, char, int) constructor of Bar
            else x.emplace(13); // (int) constructor of Bar
      }
};

此外，在这种情况下，x 将用作指针：x->some_Bar_function() 和 some_function_taking_a_Bar(*x)。

Answer 6

这是使用委托构造函数的解决方案：

class Foo
{
    Bar b;
    Foo( Bar b ): b(std::move(b)) { }

public:
    Foo(int a): Foo( a ? Bar(13) : Bar(12, 'a', 34) ) {}
};

在委托期间创建所需的对象，然后调用采用Bar 的构造函数。如果您想允许任何人从 Bar 构造 Foo ，那么您可以公开该构造函数。