我经常看到人们使用 C++ 创建对象
Thing myThing("asdf");
而不是这个：
Thing myThing = Thing("asdf");
这似乎有效（使用 gcc），至少只要不涉及模板。我现在的问题是，第一行是否正确，如果正确，我应该使用它吗？
【问题讨论】：
标签： c++
这两行实际上都是正确的，但做的事情却略有不同。
第一行通过调用Thing(const char*) 格式的构造函数在堆栈上创建一个新对象。
第二个有点复杂。它基本上执行以下操作
Thing(const char*)创建Thing类型的对象
Thing(const Thing&)创建Thing类型的对象
~Thing()
【讨论】：
Thing myThing = Thing(...) 不使用赋值运算符，它仍然像 Thing myThing(Thing(...)) 一样是复制构造的，并且不涉及默认构造的 Thing（编辑：随后更正了帖子）
我假设您实际上是指第二行：
Thing *thing = new Thing("uiae");
这将是创建新的 动态 对象（动态绑定和多态所必需的）并将它们的地址存储到指针的标准方法。您的代码执行 JaredPar 描述的操作，即创建两个对象（一个传递 const char*，另一个传递 const Thing&），然后在第一个对象（const char* 一个）上调用析构函数 (~Thing())。
相比之下，这个：
Thing thing("uiae");
创建一个静态对象，在退出当前作用域时自动销毁。
【讨论】：
编译器可以很好地将第二种形式优化为第一种形式，但不是必须的。
#include <iostream>
class A
{
public:
A() { std::cerr << "Empty constructor" << std::endl; }
A(const A&) { std::cerr << "Copy constructor" << std::endl; }
A(const char* str) { std::cerr << "char constructor: " << str << std::endl; }
~A() { std::cerr << "destructor" << std::endl; }
};
void direct()
{
std::cerr << std::endl << "TEST: " << __FUNCTION__ << std::endl;
A a(__FUNCTION__);
static_cast<void>(a); // avoid warnings about unused variables
}
void assignment()
{
std::cerr << std::endl << "TEST: " << __FUNCTION__ << std::endl;
A a = A(__FUNCTION__);
static_cast<void>(a); // avoid warnings about unused variables
}
void prove_copy_constructor_is_called()
{
std::cerr << std::endl << "TEST: " << __FUNCTION__ << std::endl;
A a(__FUNCTION__);
A b = a;
static_cast<void>(b); // avoid warnings about unused variables
}
int main()
{
direct();
assignment();
prove_copy_constructor_is_called();
return 0;
}
gcc 4.4 的输出：
TEST: direct
char constructor: direct
destructor
TEST: assignment
char constructor: assignment
destructor
TEST: prove_copy_constructor_is_called
char constructor: prove_copy_constructor_is_called
Copy constructor
destructor
destructor
【讨论】：
很简单，这两行都在堆栈上创建对象，而不是像“new”那样在堆上创建对象。第二行实际上涉及对复制构造函数的第二次调用，因此应该避免（它还需要按照 cmets 中的指示进行更正）。您应该尽可能将堆栈用于小对象，因为它更快，但是如果您的对象的生存时间比堆栈帧长，那么这显然是错误的选择。
【讨论】：
我玩了一下，当构造函数不带参数时，语法似乎变得很奇怪。举个例子吧：
#include <iostream>
using namespace std;
class Thing
{
public:
Thing();
};
Thing::Thing()
{
cout << "Hi" << endl;
}
int main()
{
//Thing myThing(); // Does not work
Thing myThing; // Works
}
所以只写不带括号的 Thing myThing 实际上会调用构造函数，而 Thing myThing() 使编译器成为您想要创建函数指针或其他东西的东西??!!
【讨论】：
理想情况下，编译器会优化第二个，但这不是必需的。第一种是最好的方法。但是，了解 C++ 中堆栈和堆之间的区别非常重要，因为您必须管理自己的堆内存。
【讨论】：
附加到 JaredPar 答案
1-通常的ctor，带有临时对象的2nd-function-like-ctor。
使用不同的编译器在此处 http://melpon.org/wandbox/ 某处编译此源代码
// turn off rvo for clang, gcc with '-fno-elide-constructors'
#include <stdio.h>
class Thing {
public:
Thing(const char*){puts(__FUNCTION__ );}
Thing(const Thing&){puts(__FUNCTION__ );}
~Thing(){puts(__FUNCTION__);}
};
int main(int /*argc*/, const char** /*argv*/) {
Thing myThing = Thing("asdf");
}
你会看到结果。
来自 ISO/IEC 14882 2003-10-15
8.5，第 12 部分
您的第 1、2 个构造称为直接初始化
12.1，第 13 部分
功能符号类型转换 (5.2.3) 可用于创建 其类型的新对象。 [注意：语法看起来像显式调用 的构造函数。 ] ...以这种方式创建的对象是未命名的。 [注：12.2 描述了临时对象的生命周期。 ] [笔记： 显式构造函数调用不会产生左值，见 3.10。 ]
在哪里了解 RVO：
12 特殊成员函数/12.8 复制类对象/第 15 部分
当满足某些条件时，允许省略实现 类对象的复制构造，即使如果是复制构造函数 和/或对象的析构函数有副作用。
使用注释中的编译器标志将其关闭以查看此类复制行为）
【讨论】：