作为C# 开发人员，我习惯于通过构造函数运行：
class Test {
public Test() {
DoSomething();
}
public Test(int count) : this() {
DoSomethingWithCount(count);
}
public Test(int count, string name) : this(count) {
DoSomethingWithName(name);
}
}
有没有办法在 C++ 中做到这一点？
我尝试调用类名并使用“this”关键字，但都失败了。
【问题讨论】：
this 或 auto 将是未来重构目的的有趣关键字。
标签： c++ constructor
C++11：是的！
C++11 及更高版本具有相同的功能（称为delegating constructors）。
语法与C#略有不同：
class Foo {
public:
Foo(char x, int y) {}
Foo(int y) : Foo('a', y) {}
};
C++03：否
不幸的是，在 C++03 中没有办法做到这一点，但是有两种方法可以模拟这个：
您可以通过默认参数组合两个（或多个）构造函数：
class Foo {
public:
Foo(char x, int y=0); // combines two constructors (char) and (char, int)
// ...
};
使用init方法共享通用代码：
class Foo {
public:
Foo(char x);
Foo(char x, int y);
// ...
private:
void init(char x, int y);
};
Foo::Foo(char x)
{
init(x, int(x) + 7);
// ...
}
Foo::Foo(char x, int y)
{
init(x, y);
// ...
}
void Foo::init(char x, int y)
{
// ...
}
【讨论】：
是和否，取决于 C++ 的版本。
在 C++03 中，不能从另一个构造函数调用一个构造函数（称为委托构造函数）。
这在 C++11（又名 C++0x）中发生了变化，增加了对以下语法的支持：
（示例取自Wikipedia）
class SomeType
{
int number;
public:
SomeType(int newNumber) : number(newNumber) {}
SomeType() : SomeType(42) {}
};
【讨论】：
SomeType(string const &s) { /*...*/ } SomeType(char const *pc) : SomeType(string(pc)) { /*...*/ }
我相信你可以从构造函数中调用构造函数。它将编译并运行。我最近看到有人这样做，它可以在 Windows 和 Linux 上运行。
它只是没有做你想做的事。内部构造函数将构造一个临时本地对象，一旦外部构造函数返回，该对象就会被删除。它们也必须是不同的构造函数，否则您将创建递归调用。
【讨论】：
new 语法。不过，这通常不是您想要的。 （而且它没有做任何事情来允许您显式提供模板参数。）
new 仍会创建一个 new 对象，尽管它位于相同的内存位置。但是，尽管是不同的对象，并且可以将证明这一点的代码放在一起。
C++11：是的！
C++11 及更高版本具有相同的功能（称为delegating constructors）。
语法与C#略有不同：
class Foo {
public:
Foo(char x, int y) {}
Foo(int y) : Foo('a', y) {}
};
C++03：否
值得指出的是，您可以在您的构造函数中调用父类的构造函数，例如：
class A { /* ... */ };
class B : public A
{
B() : A()
{
// ...
}
};
但是，不，在 C++03 之前，您不能调用同一类的另一个构造函数。
【讨论】：
在C++11，constructor can call another constructor overload：
class Foo {
int d;
public:
Foo (int i) : d(i) {}
Foo () : Foo(42) {} //New to C++11
};
此外，成员也可以像这样初始化。
class Foo {
int d = 5;
public:
Foo (int i) : d(i) {}
};
这应该消除创建初始化辅助方法的需要。并且仍然建议不要在构造函数或析构函数中调用任何虚函数，以避免使用任何可能未初始化的成员。
【讨论】：
如果你想作恶，你可以使用就地“new”操作符：
class Foo() {
Foo() { /* default constructor deliciousness */ }
Foo(Bar myParam) {
new (this) Foo();
/* bar your param all night long */
}
};
似乎对我有用。
编辑
正如@ElvedinHamzagic 指出的那样，如果 Foo 包含一个分配内存的对象，则该对象可能不会被释放。这让事情变得更加复杂。
一个更一般的例子：
class Foo() {
private:
std::vector<int> Stuff;
public:
Foo()
: Stuff(42)
{
/* default constructor deliciousness */
}
Foo(Bar myParam)
{
this->~Foo();
new (this) Foo();
/* bar your param all night long */
}
};
看起来有点不优雅，当然。 @JohnIdol 的解决方案要好得多。
【讨论】：
this->~Foo();，在new (this) Foo();之前
简单地说，在 C++11 之前你不能。
C++11 引入delegating constructors：
委托构造函数
如果类本身的名称在 成员初始值设定项列表，则该列表必须由该成员组成 仅初始化器；这样的构造函数被称为委托 构造函数，以及由唯一成员选择的构造函数 初始化列表是目标构造函数
在这种情况下，目标构造函数是通过重载选择的 解决并首先执行，然后控制返回到 委托构造函数及其主体被执行。
委托构造函数不能递归。
class Foo { public: Foo(char x, int y) {} Foo(int y) : Foo('a', y) {} // Foo(int) delegates to Foo(char,int) };
请注意，委托构造函数是一个全有或全无的提议；如果一个构造函数委托给另一个构造函数，则调用构造函数的初始化列表中不允许有任何其他成员。如果您考虑将 const/reference 成员初始化一次，并且只初始化一次，这是有道理的。
【讨论】：
不，在 C++ 中，您不能从构造函数调用构造函数。正如沃伦指出的那样，您可以做的是：
请注意，在第一种情况下，您不能通过从另一个构造函数调用一个构造函数来减少代码重复。您当然可以有一个单独的、私有/受保护的方法来完成所有初始化，并让构造函数主要处理参数处理。
【讨论】：
另一个尚未展示的选项是将您的类拆分为两个，在您的原始类周围包装一个轻量级接口类，以实现您正在寻找的效果：
class Test_Base {
public Test_Base() {
DoSomething();
}
};
class Test : public Test_Base {
public Test() : Test_Base() {
}
public Test(int count) : Test_Base() {
DoSomethingWithCount(count);
}
};
如果您有许多必须调用其“下一级”对应项的构造函数，这可能会变得一团糟，但对于少数构造函数，它应该是可行的。
【讨论】：
在 Visual C++ 中，您还可以在构造函数中使用此表示法：this->Classname::Classname（另一个构造函数的参数）。请参阅下面的示例：
class Vertex
{
private:
int x, y;
public:
Vertex(int xCoo, int yCoo): x(xCoo), y(yCoo) {}
Vertex()
{
this->Vertex::Vertex(-1, -1);
}
};
我不知道它是否可以在其他地方工作，我只在 Visual C++ 2003 和 2008 中测试过。我想你也可以这样调用 几个 构造函数，就像在 Java 和 C# 中一样.
P.S.：坦率地说，我很惊讶之前没有提到这一点。
【讨论】：
我建议使用private friend 方法，该方法实现构造函数的应用程序逻辑，并被各种构造函数调用。这是一个例子：
假设我们有一个名为 StreamArrayReader 的类，其中包含一些私有字段：
private:
istream * in;
// More private fields
我们要定义两个构造函数：
public:
StreamArrayReader(istream * in_stream);
StreamArrayReader(char * filepath);
// More constructors...
第二个简单地利用了第一个（当然我们不想重复前者的实现）。理想情况下，一个人想做这样的事情：
StreamArrayReader::StreamArrayReader(istream * in_stream){
// Implementation
}
StreamArrayReader::StreamArrayReader(char * filepath) {
ifstream instream;
instream.open(filepath);
StreamArrayReader(&instream);
instream.close();
}
但是，这在 C++ 中是不允许的。出于这个原因，我们可以如下定义一个私有友元方法，它实现了第一个构造函数应该做的事情：
private:
friend void init_stream_array_reader(StreamArrayReader *o, istream * is);
现在这个方法（因为它是一个朋友）可以访问o 的私有字段。那么，第一个构造函数就变成了：
StreamArrayReader::StreamArrayReader(istream * is) {
init_stream_array_reader(this, is);
}
请注意，这不会为新创建的副本创建多个副本。第二个变成：
StreamArrayReader::StreamArrayReader(char * filepath) {
ifstream instream;
instream.open(filepath);
init_stream_array_reader(this, &instream);
instream.close();
}
也就是说，不是让一个构造函数调用另一个构造函数，而是调用一个私人朋友！
【讨论】：
这种方法可能适用于某些类型的类（当赋值运算符表现良好时）：
Foo::Foo()
{
// do what every Foo is needing
...
}
Foo::Foo(char x)
{
*this = Foo();
// do the special things for a Foo with char
...
}
【讨论】：
如果我正确理解您的问题，您是在问是否可以在 C++ 中调用多个构造函数？
如果那是您正在寻找的东西，那么不，那是不可能的。
你当然可以有多个构造函数，每个构造函数都有唯一的参数签名，然后在你实例化一个新对象时调用你想要的那个。
你甚至可以有一个带有默认参数的构造函数。
但你可能没有多个构造函数，然后分别调用它们。
【讨论】：
当调用构造函数时，它实际上是从堆栈或堆中分配内存。因此，在另一个构造函数中调用构造函数会创建一个本地副本。所以我们正在修改另一个对象，而不是我们关注的对象。
【讨论】：
比决定更容易测试:) 试试这个：
#include <iostream>
class A {
public:
A( int a) : m_a(a) {
std::cout << "A::Ctor" << std::endl;
}
~A() {
std::cout << "A::dtor" << std::endl;
}
public:
int m_a;
};
class B : public A {
public:
B( int a, int b) : m_b(b), A(a) {}
public:
int m_b;
};
int main() {
B b(9, 6);
std::cout << "Test constructor delegation a = " << b.m_a << "; b = " << b.m_b << std::endl;
return 0;
}
并用 98 std 编译它： g++ main.cpp -std=c++98 -o test_1
你会看到：
A::Ctor
Test constructor delegation a = 9; b = 6
A::dtor
所以:)
【讨论】：