复合模式的递归迭代器(Recursive iterator for composite pattern)

    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+=定义为公共成员函数，您需要编写单个实现，并且该实现可以重用，因此您可以获得两个运算符，其中一个（以及三个额外的代码行是微不足道的）。 
 
 按值计算的参数和按值返回。 如果参数是临时的，这使编译器可以将副本删除为参数。 由于存在移动构造函数 ，因此也不会有任何内部副本，参数将被修改并移动到返回对象。 （不能省略第二份副本）。 
 
 我前段时间在运算符重载上写了不止这些......它没有明确处理优化（ 移动 ），但还有其他帖子处理它的C ++ 03版本。 从那个到C ++ 11功能，你应该能够填补空白。 

    Ding * neu = new Ding(tmp);
    return *neu;
 
This is wrong. You are dynamically allocating a Ding and then forcing a copy of it. Because the Ding is dynamically allocated, you are leaking it, it's lifetime extends beyond the return statement and the compiler cannot move from it. Note that you are not returning a temporary.
 
Change that to:
 
    return Ding(tmp);
 
Or even:
 
    return tmp;
 
As your constructor taking a const char* is not explicit, the compiler will use it to create a new Ding object. In both cases, the lifetime of the temporary does not extend beyond the return statement and the compiler will move.
 
(This answer assumes that you understand that the copy from the returned object to the d3 has been elided, if that is where you expected the move, then the compiler did something better: avoid the operation altogether).
 
EDIT As DeadMG has written a canonical form but it includes errors I will follow up on that:
 
There is much to say about operator overloading, but a common recommendation (the one I give and follow) is to implement operatorX= as a member function (it is an operation applied to the left hand side) and then implement operator+ as a free function in terms of the former. In C++11 that would be:
 
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;
}
 
Some things to note: operator+ is symmetric with respect to types as it is a free function. All implicit conversions that can happen on the right hand side are also available in the lhs. In your particular case, Ding is implicitly convertible from const char*, which means that by having a free function operator+ you can write:
 
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
 
By defining operator+= as a public member function you need to write a single implementation and that implementation can be reused, so you get two operators for the cost of one (and three extra lines of code that are trivial).
 
Argument by value and return by value. This enables the compiler to elide the copy to the parameter if the argument is a temporary. As there is a move constructor, there will not be any internal copy either, the argument will be modified and moved to the return object. (This second copy cannot be elided).
 
I wrote a bit more than this on operator overloading here some time ago... It does not explicitly deal with optimizations (moving) but there are other posts there that deal with the C++03 version of it. From that to C++11 features you should be able to fill in the blanks.