The compiler inserts temporary objects “behind your back” in several contexts. For time critical applications, the overhead of a temporary can be quite significant because both the constructor and the destructor of each temporary object must be invoked. Fortunately, you can prevent the creation of a temporary object in most cases, thereby minimizing its incurred performance overhead. Here’s a concrete example. In the following snippet, a temporary is created:

   Complex x, y, z;  x = y+z; // assignment; temporary generated here

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:

   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 need for an intermediary temporary. Alternatively, you can use += instead of + to get the same effect:

   // the following 2 lines are equivalent to: x = y+z;  x =y; // assignmnet  x+=z; // no temporary here

Although the form that uses += 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: constructor call for the temporary, copy constructor for x, and a destructor call for the temporary.