这是一个 r 值实验，但当 gcc 向我提示缺少移动构造函数(我已将其删除)并且没有回退到复制构造函数(如我所料)时，它发生了变化 然后我从标志中删除了 -std=c++11 并尝试了你在下面看到的内容，它有很多输出(最初没有)因为我试图弄清楚为什么它不起作用(我知道如何调试，但我发现 stdout 上的消息可以很好地指示正在发生的事情)

这是我的代码:

#include <iostream>

class Object {
public:
    Object() { id=nextId; std::cout << "Creating object: "<<id<<"\n"; nextId++; }
    Object(const Object& from) {
         id=nextId; std::cout << "Creating object: "<<id<<"\n"; nextId++;
        std::cout<<"(Object: "<<id<<" created from Object: "<<from.id<<")\n";
    }
    Object& operator=(const Object& from) {
        std::cout<<"Assigning to "<<id<<" from "<<from.id<<"\n";
        return *this;
    }
    ~Object() { std::cout<<"Deconstructing object: "<<id<<"\n";}

private:
    static int nextId;
    int id;
};

int Object::nextId = 0;

Object test();

int main(int,char**) {
    Object a;
    std::cout<<"A ought to exist\n";
    Object b(test());
    std::cout<<"B ought to exist\n";
    Object c = test();
    std::cout<<"C ought to exist\n";
    return 0;
}


Object test() {
    std::cout<<"In test\n";
    Object tmp;
    std::cout<<"Test's tmp ought to exist\n";
    return tmp;
}

输出:

Creating object: 0
A ought to exist
In test
Creating object: 1
Test's tmp ought to exist
B ought to exist
In test
Creating object: 2
Test's tmp ought to exist
C ought to exist
Deconstructing object: 2
Deconstructing object: 1
Deconstructing object: 0

我使用解构，因为解构已经是一个词，有时我使用析构函数，我对这个词不太满意，我更喜欢用 destructor 作为名词。

这是我的预期:

A to be constructed
tmp in test to be constructed, a temporary to be created from that 
    tmp, tmp to be destructed(?) 
that temporary to be the argument to B's copy constructor
the temporary to be destructed.
C's default constructor to be used
"" with a temporary from `test`
C's assignment operator to be used
the temporary to be destructed
c,b,a to be destructed.

我被称为“顽固的 C”，我正在努力学习使用 C++ 而不是“带命名空间的 C”。

有人可能会说“编译器优化了它”我希望那个人永远不要用这样的答案来回答问题，优化不能改变程序状态，它必须好像 一切都按照规范所说发生，所以编译器可能会通过在 cout 上放置一条包含数字的消息来取悦我，它甚至可能不会费心增加数字等等，但程序的输出就像它确实完成了代码描述的所有事情。

所以这不是优化，这是怎么回事？

最佳答案

这是一种优化，是唯一可以改变程序的可观察行为的优化。

这是段落 12.8./31，摘自标准草案 n3337(强调我的):

When certain criteria are met, an implementation is allowed to omit the copy/move construction of a class object, even if the copy/move constructor and/or destructor for the object have side effects. In such cases, the implementation treats the source and target of the omitted copy/move operation as simply two different ways of referring to the same object, and the destruction of that object occurs at the later of the times when the two objects would have been destroyed without the optimization. This elision of copy/move operations, called copy elision, is permitted in the following circumstances (which may be combined to eliminate multiple copies):

— in a return statement in a function with a class return type, when the expression is the name of a non-volatile automatic object (other than a function or catch-clause parameter) with the same cv- unqualified type as the function return type, the copy/move operation can be omitted by constructing the automatic object directly into the function’s return value

— in a throw-expression, when the operand is the name of a non-volatile automatic object (other than a function or catch-clause parameter) whose scope does not extend beyond the end of the innermost enclosing try-block (if there is one), the copy/move operation from the operand to the exception object (15.1) can be omitted by constructing the automatic object directly into the exception object

— when a temporary class object that has not been bound to a reference (12.2) would be copied/moved to a class object with the same cv-unqualified type, the copy/move operation can be omitted by constructing the temporary object directly into the target of the omitted copy/move

— when the exception-declaration of an exception handler (Clause 15) declares an object of the same type (except for cv-qualification) as the exception object (15.1), the copy/move operation can be omitted by treating the exception-declaration as an alias for the exception object if the meaning of the program will be unchanged except for the execution of constructors and destructors for the object declared by the exception-declaration.

[示例...省略]

复制/移动构造函数的语义就是在初始化另一个对象的同时复制/移动对象的内容。如果您的复制构造函数发送电子邮件邀请您参加生日聚会，那么如果您最终独自参加聚会，您应该不会感到惊讶:)

好的，一些复制构造函数也做其他事情。想想智能指针的引用计数。但是，如果它得到优化，那很好。没有拷贝，也不需要统计。

关于C++ 意外行为(我的临时对象在哪里!？)，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/18486598/