C ++基本构造函数/向量问题（1个构造函数，2个析构函数）

Question

Question is probably pretty basic, but can't find out what's wrong (and it leads to huge of memleaks in my app):

class MyClass {
public:
    MyClass() { cout << "constructor();\n"; };
    MyClass operator= (const MyClass& b){ 
        cout << "operator=;\n"; return MyClass(); 
    };
    ~MyClass() { cout << "destructor();\n"; };
};

main() {
    cout << "1\n";
    vector<MyClass> a;
    cout << "2\n";
    MyClass b;
    cout << "3\n";
    a.push_back(b);
    cout << "4\n";
}

The output is:

1
2
constructor();
3
4
destructor();
destructor();

1. Why are there 2 destructors?
2. If it's because a copy is created to be inserted into vector - how come "operator=" is never called?

Answer 1

When the b object gets pushed onto the vector a copy is made, but not by the operator=() you have - the compiler generated copy constructor is used.

When the main() goes out of scope, the b object is destroyed and the copy in the vector is destroyed.

Add an explicit copy constructor to see this:

MyClass( MyClass const& other) {
    cout << "copy ctor\n";
};

Answer 2

If you want to log all copies and constructions you should add an explicit copy constructor so that the compiler doesn't create one for you.

MyClass( const MyClass& )
{
    cout << "Copy constructor\n";
}

You can, in your copy constructor, call your assignment operator. It is a reasonably common way of implementing things, however with your definition of operator=, this may have serious problems.

You have an unconventional implementation of operator=. operator= should return a reference to the class on which it is called (to enable proper chaining), but you return a new class instance by value. This means that if you tried to call operator= from your copy constructor you may well end up with infinite recursion. Try this operator= instead:

MyClass& operator=( const MyClass& )
{
    cout << "operator=\n";
    return *this;
}

When defining an assignment operator you should always consider the possibility that the parameter and *this may refer to the same object and ensure that the definition of the operator won't have any unintended effects in this scenario.