现在回答：不要费心阅读这个问题，这有点冗长，可能不值得你花时间。我的代码中存在错误，这就是为什么没有调用移动构造函数的原因。检查答案以获取详细信息。请记住，RVO和NRVO（命名返回值优化）可能会导致未按预期发生的呼叫。
我希望为此行调用move ctor，但是会调用copy ctor：
Ding d3 = d1 + d2;
Ding类具有用户定义的移动ctor和操作符+重载。我希望调用move ctor的原因是operator +返回一个临时对象，一个rvalue引用，因此可能会发生移动优化。
我在这里写的所有东西都可能是错的，因为我是C ++初学者。这是代码：
// Copied and modified code from here: https://stackoverflow.com/a/3109981
#include <iostream>
#include <cstring>
struct Ding {
char* data;
Ding(const char* p) {
std::cout << " ctor for: " << p << "\n";
size_t size = strlen(p) + 1;
data = new char[size];
memcpy(data, p, size);
}
~Ding() {
std::cout << " dtor for: " << data << "\n";
delete[] data;
}
Ding(const Ding& that) {
std::cout << " copy for: " << that.data << "\n";
size_t size = strlen(that.data) + 1;
data = new char[size];
memcpy(data, that.data, size);
}
Ding(Ding&& that) {
std::cout << " MOVE for: " << that.data << "\n";
data = that.data;
that.data = nullptr;
}
Ding& operator=(Ding that) {
std::cout << " assignment: " << that.data << "\n";
std::swap(data, that.data);
return *this;
}
Ding& operator+(const Ding that) const {
std::cout << " plus for: " << that.data << "\n";
size_t len_this = strlen(this->data);
size_t len_that = strlen(that.data);
char * tmp = new char[len_this + len_that + 1];
memcpy( tmp, this->data, len_this);
memcpy(&tmp[len_this], that.data, len_that + 1);
Ding * neu = new Ding(tmp);
return *neu;
}
};
void print(Ding d) {
std::cout << " (print): " << d.data << std::endl;
}
int main(void) {
std::cout << "putting a Ding on the stack\n";
Ding d1("jajaja");
std::cout << "calling print routine\n";
print(d1);
std::cout << "putting a second Ding on the stack\n";
Ding d2("nein");
// std::cout << "calling print routine\n";
// print(d2);
std::cout << "Putting a third Ding on the stack, init from + op ...\n";
std::cout << "... so expecting so see MOVE ctor used ...\n";
Ding d3 = d1 + d2;
// std::cout << "calling print routine\n";
// print(d3);
std::cout << "End of main, dtors being called ...\n";
}
VC2010 Express和MinGW（GCC 4.6）的编译器调用（在Win7上）如下：
cl /nologo /W4 /EHsc /MD move-sem.cpp
g++ -std=c++0x move-sem.cpp -o move-gcc.exe
两个二进制文件产生相同的输出（在程序结束时没有破坏顺序）：
putting a Ding on the stack
ctor for: jajaja
calling print routine
copy for: jajaja
(print): jajaja
dtor for: jajaja
putting a second Ding on the stack
ctor for: nein
Putting a third Ding on the stack, init from + op ...
... so expecting so see MOVE ctor used ...
copy for: nein
plus for: nein
ctor for: jajajanein
dtor for: nein
copy for: jajajanein
End of main, dtors being called ...
dtor for: jajajanein
dtor for: nein
dtor for: jajaja
回想一下这个长文本之后的问题：为什么移动构造函数不需要Ding d3 = d1 + d2;？
我知道还有其他问题，为什么移动ctors没有被调用，但我无法将他们的答案映射到这个案例。
根据David Rodriguez的评论，我按照以下方式更改了程序：
--- move-sem.cpp.orig 2012-03-17 17:00:56.901570900 +0100
+++ move-sem.cpp 2012-03-17 17:01:14.016549800 +0100
@@ -36,15 +36,14 @@
return *this;
}
- Ding& operator+(const Ding that) const {
+ Ding operator+(const Ding that) const {
std::cout << " plus for: " << that.data << "\n";
size_t len_this = strlen(this->data);
size_t len_that = strlen(that.data);
char * tmp = new char[len_this + len_that + 1];
memcpy( tmp, this->data, len_this);
memcpy(&tmp[len_this], that.data, len_that + 1);
- Ding * neu = new Ding(tmp);
- return *neu;
+ return tmp;
}
};
然后我使用上面提到的编译器调用重新编译了程序，得到了一个输出，其中删除了一个副本（copy for: jajajanein）。然后我尝试了以下一行：
g++ -std=c++0x -fno-elide-constructors move-sem.cpp -o move-gcc.exe
塔塔！现在我看到移动ctor在工作！ ...但我认为现在还有另一个错误，新move-gcc.exe的输出不再列出dtor调用：
putting a Ding on the stack
ctor for: jajaja
calling print routine
copy for: jajaja
(print): jajaja
dtor for: jajaja
putting a second Ding on the stack
ctor for: nein
Putting a third Ding on the stack, init from + op ...
... so expecting so see MOVE ctor used ...
copy for: nein
plus for: nein
ctor for: jajajanein
MOVE for: jajajanein
dtor for:
我用以下（可能同样糟糕的）代码替换了坏operator+：
Ding& operator+=(const Ding & rhs) {
std::cout << " op+= for: " << data << " and " << rhs.data << "\n";
size_t len_this = strlen(this->data);
size_t len_that = strlen(rhs.data);
char * buf = new char[len_this + len_that + 1];
memcpy( buf, this->data, len_this);
memcpy(&buf[len_this], rhs.data, len_that + 1);
delete[] data;
data = buf;
return *this;
}
Ding operator+(const Ding & rhs) const {
Ding temp(*this);
temp += rhs;
return temp;
}
我还从析构函数中删除了以下行，它阻止程序异常终止：
std::cout << " dtor for: " << data << "\n";
现在在使用MSVC和g++ -std=c++0x -fno-elide-constructors进行编译时调用移动构造函数。
答案 0 :(得分：2)
Ding * neu = new Ding(tmp);
return *neu;
这是错误的。您正在动态分配Ding，然后强制复制它。因为Ding是动态分配的，所以泄漏它，它的生命周期超出了return语句，编译器无法移动。请注意，您不返回临时。
将其更改为：
return Ding(tmp);
甚至：
return tmp;
由于您的构造函数const char*不是显式，编译器将使用它来创建新的Ding对象。在这两种情况下，临时的生命周期都不会超出return语句，编译器将移动。
（这个答案假设您理解从返回的对象到d3的副本已被省略，如果这是您期望移动的位置，那么编译器会做得更好：完全避免操作）。
编辑由于DeadMG已经编写了 规范表单，但它包含错误我会跟进：
关于运算符重载有很多话要说，但是一个共同的建议（我给出和遵循的那个）是将operatorX=实现为成员函数（它是应用于左侧的操作）然后根据前者实现operator+作为自由函数。在C ++ 11中将是：
class X {
X& operator+=( X const & ); // we do not modify the rhs internally
};
X operator+( X lhs, X const & rhs ) {
lhs += rhs; // reuse implementation
return lhs;
}
有些注意事项：operator+在类型方面是对称的，因为它是一个自由函数。可以在lhs中获得右侧可能发生的所有隐式转换。在您的特定情况下，Ding可以隐式转换为const char*，这意味着您可以通过自由函数operator+来编写：
Ding d( "A" );
const char* str = "B";
d + d; // no conversions
d + str; // conversion on the right hand side
str + d; // conversion on the left hand side
通过将operator+=定义为公共成员函数，您需要编写单个实现，并且可以重用该实现，因此您可以获得两个运算符，其中一个（以及三个额外的代码行是微不足道的）
按值参数和按值返回。如果参数是临时的，这使编译器可以将副本删除为参数。由于存在移动构造函数，因此也不会有任何内部副本，参数将已修改且已移动到返回对象。 （不能省略第二份副本。）
我在前一段时间对运算符重载here写了不止这些......它没有明确处理优化（移动）但是还有其他帖子可以处理它的C ++ 03版本。从那个到C ++ 11的功能，你应该能够填补空白。
答案 1 :(得分：1)
没有什么可以动的。
您无法从d1或d2移动，因为这会破坏它们。并且您无法移动operator+的返回值，因为这是一个参考。
答案 2 :(得分：1)
您尚未编写正确的加法运算符。规范形式是
Ding operator+(Ding other) const {
other += this;
return other;
// return std::move(other) if you're on MSVC
// which sometimes doesn't do this properly
}
Ding& operator+=(const Ding& other);
您的代码存在许多问题，例如内存泄漏，这也是运算符过载导致的错误。
另外，不要忘记RVO和NRVO对预期产量的潜在影响。