构造函数可以在c ++中调用另一个构造函数吗？

Question

class A{
  A(int a = 5){
    DoSomething();
    A();
  }
  A(){...}
}

第一个构造函数可以调用第二个构造函数吗？

Answer 1

不是在C ++ 11之前 。

将常用功能提取到单独的功能中。 我通常将此函数命名为construct（） 。

“所谓的”第二次调用将编译，但在C ++中具有不同的含义：它将构造一个新对象，一个临时对象，然后在语句结束时立即删除。 所以不行。

但是，可以毫无问题地调用析构函数。

Answer 2

不是在C++0x之前，没有。

但是， 出于学术兴趣，我想出了一个非常可怕的方法*使用贴片操作员“new”来做这件事（有人想指出这是多么便携？）

#include <new>
#include <iostream>

class A
{
public:
    A(int i, int j)
        : i_(i), j_(j) { }

    A(int i)
    { new (this) A(i, 13); }

    int i_,j_;
};

int
main() {
    A a1(10,11), a2(10);
    std::cout
        << a1.i_ << ", "
        << a1.j_ << std::endl
        << a2.i_ << ", "
        << a2.j_ << std::endl;
    return 0;
}

*不，不，我不在生产代码中写这个。

Answer 3

答案实际上是“是”，但正如其他人所建议的那样，它并不能满足您的需求。 您当然可以隐式或显式地使用基类的构造函数：

struct B {
    B() {}
    B( int x ) {}
};

struct A : public B {
    A() {}    // calls B() implicitly
    A( int a, int b ) : B( b ) {} // calls B(int) explicitly
};

Answer 4

不是直接的。 有几种方法可以解决这个问题。

从类的构造函数的初始化列表中，您可以在任何基类和所有成员变量上调用构造函数。

因此，您通常可以重构您的类并将其拆分为几个较小的类来解决问题。 通常执行的代码可以放在成员对象中，也可以放在基类中。 然后每个主类的构造函数只需要决定使用哪个构造函数来初始化该成员。

class B {
  B() {  }
  B(int b) { DoSomething(); }
}
class A{
  A(int a = 5) : b(a) { } // call B's constructor which does something
  A() : b() {} // call B's constructor which does nothing

  B b;
};

Answer 5

正如Pavel Radzivilovsky在他的回答中指出的那样，自C ++ 11以来，它是可能的。 它与从子类中明确调用父类的构造函数的语法相同。 当一个类需要有多个构造函数（比如一个默认构造函数和一个带属性初始化的构造函数）时，这很有用，但是在所有情况下都必须完成一些操作。 这允许避免代码重复。

这是一个例子：

class A
{
public:

    A()
    {
         foo();
    }

    A(Attribute attribute) : A()
    {
         this->attribute = attribute;
    }

    //------ some other code --------

private:

    Attribute attribute;
    void foo()
    {...}

    //------ some other code -------
};

在这个简单的例子中，我假设在所有情况下都需要调用函数foo（）才能正确初始化对象。 使用此语法，如果调用第二个构造函数（具有属性初始化），它将在执行属性初始化构造函数中的指令之前首先在默认构造函数中执行操作。

它也可以通过其他方式完成：默认构造函数可以使用默认参数调用另一个构造函数。

在C ++ 11之前，有必要复制所有构造函数的公共指令或定义执行实际对象初始化的方法。

Answer 6

这是一个老问题; 然而，

class A{
  A(int a = 5){
    DoSomething();
    A();
  }
  A(){...}
}

可能

class A{
  A(int a = 5){
    *this = A();
    DoSomething();
  }
  A(){...}
}