Question

Here is the code which confuses me:

#include <iostream>
using namespace std;

class B {
public:
    B() {
        cout << "constructor\n";
    }
    B(const B& rhs) {
        cout << "copy ctor\n";
    }
    B & operator=(const B & rhs) {
        cout << "assignment\n";
    }
    ~B() {
        cout << "destructed\n";
    }
    B(int i) : data(i) {
        cout << "constructed by parameter " << data << endl;
    }

private:
    int data;
};

B play(B b)
{
    return b;
}

int main(int argc, char *argv[])
{
#if 1
    B t1;
    t1 =  play(5);
#endif

#if 0
    B t1 = play(5);
#endif

    return 0;
}

Environment is g++ 4.6.0 on Fedora 15.
The first code fragment output is as follows:

constructor
constructed by parameter 5
copy ctor
assignment
destructed
destructed
destructed

And the second fragment code output is:

constructed by parameter 5
copy ctor
destructed
destructed

Why are are three destructors are called in the first example, while in the second it is only two?

Answer 1

First Case:

B t1;
t1 =  play(5);

1. Creates a object t1 by calling default constructor of B.
2. In order to call play(), A temporary object of B is created by using B(int i). 5 is passed as an and object of B is created, and play() is called.
3. return b; inside play() causes the copy constructor to be called for returning a copy of object.
4. t1 = calls the Assignemnt operator to assign the returned object copy to t1.
5. First destructor, destructs the temporary object created in #3.
6. Second destructor destructs the returned temporay object in #2.
7. Third destructor destructs the object t1.

Second case:

B t1 = play(5);  

1. An temporary object of class B is created by calling parameterized constructor of B which takes int as a paraemter.
2. This temporary object is used to call the Copy constructor of class B.
3. First destructor destructs the temporary created in #1.
4. Second destructor destructs object t1.

One destructor call is less in Second Case because, in second Case the compiler uses Return value Optimization and elides the call to create an additional temporary object while returning from play(). Instead the Base object is created in the location where the temporary would have been assigned.