对象创建中涉及的构造函数和析构函数调用

Question

I am using the following code snippet to compare two methods for creating an object in C++.

#include <iostream>

using std::cout;
using std::endl;

class Foo {
    public:
        Foo() : x(0) { cout << "In Foo constructor." << endl; }
        ~Foo() { cout << "In Foo destructor." << endl; }
        Foo(const Foo&) { cout << "In Foo copy constructor." << endl; }

        // Assignment operator.
        Foo& operator=(const Foo&) {
            cout << "In assignment operator." << endl;
            return *this;
        }

    private:
        int x;
};

int main() {

    cout << "Constructing Foo 1" << endl;
    Foo Foo_1;
    cout << "Constructing Foo 2" << endl;
    Foo Foo_2 = Foo();

    return 0;
}

The output from this code snippet is:

  Constructing Foo 1
  In Foo constructor.
  Constructing Foo 2
  In Foo constructor.
  In Foo destructor.
  In Foo destructor.

I am using Visual C++ 2010 (compiler version 16.x) and I am compiling the snippet using cl /EHsc /W4 test.cpp . In the construction of Foo_2 , I was expecting to see an extra call to the constructor and destructor in order to create a temporary object and a call to the assignment operator in order to assign the temporary object to Foo_2 . Can someone explain to me why this is not the case. Apologies if I am missing something very obvious here.

Answer 1

There are two forms of initialization available for Foo :

Foo f1;
Foo f2 = Foo();

The first constructs f directly, using the default constructor. The second constructs a temporary of type Foo , using the default constructor, and copies that temporary into f2 . The latter is what you describe as what you expected. And you're right, except for one additional rule: if that form of initialization is valid (which it is here; make the copy constructor private and see what happens), the compiler is allowed to "elide" the copy construction and construct f2 directly, just as in the first version. That's what you're seeing. The compiler isn't required to elide the copy constructor, but every one I've used recently does.

Answer 2

Foo Foo_2 = Foo(); is similar to Foo Foo_2(Foo()); . Compiler is smart enough to do this, no assignment operator is being called. BTW, you have a bug in the assignment operator - you return reference to your object instead of copying it.

Answer 3

第一个“本周专家”问题与您的问题有关， http：//www.gotw.ca/gotw/001.htm特别是有关编译器优化的说明。