C++ creates temporary objects "behind your back" in several contexts. The overhead of a temporary can be significant because both its constructor and destructor are invoked. You can prevent the creation of a temporary object in most cases, though. In the following example, a temporary is created: Code: Complex x, y, z; x=y+z; /* temporary created */ The expression y+z; results in a temporary object of type Complex that stores the result of the addition. The temporary is then assigned to x and destroyed subsequently. The generation of the temporary object can be avoided in two ways: Code: Complex y,z; Complex x=y+z; /* initialization instead of assignment */ In the example above, the result of adding x and z is constructed directly into the object x, thereby eliminating the intermediary temporary. Alternatively, you can use += instead of + to get the same effect: Code: /* instead of x = y+z; */ x=y; x+=z; Although the += version is less elegant, it costs only two member function calls: assignment operator and operator +=. In contrast, the use of + results in three member function calls: a constructor call for the temporary, a copy constructor call for x, and a destructor call for the temporary.
Though this topic is very debatable. But I'll keep out of it. Nice work...again this should be added to Tips section
Code: Complex x, y, z; x=y+z; /* temporary created */ In the above case you are using the = operator and that needs to be overloaded which should take care of creation of objects. The scenario where the temporary object come into picture are. Code: #include <iostream.h> class A { int i; public: A() { cout<<"A Constructor"<<endl; } ~A() { cout<<"A Destructor"<<endl; } }; A func() { return A(); } int main() { func(); cout<<"Now end of main"<<endl; return 0; }
That's not necessary as long as you are doing monolithic copying. The code which you have shown I would term it as an advantage of temporary objects.
Exactly. Its better to be using the temp objects rather than creating a new object and copying the data into it and then returning the object.
