1. We have moved from vBulletin to XenForo and you are viewing the site in the middle of the move. Though the functional aspect of everything is working fine, we are still working on other changes including the new design on Xenforo.
    Dismiss Notice

Eliminating Temporary Objects

Discussion in 'C++' started by pradeep, May 22, 2006.

  1. pradeep

    pradeep Team Leader

    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.
     
  2. Aztec

    Aztec New Member

    Though this topic is very debatable. But I'll keep out of it.
    Nice work...again this should be added to Tips section
     
  3. shabbir

    shabbir Administrator Staff Member

    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;
    }
     
  4. Aztec

    Aztec New Member

    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.
     
  5. coderzone

    coderzone Super Moderator

    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.
     
  6. shabbir

    shabbir Administrator Staff Member

    and also the + operator.
    Yes thats the main reason why we have temp objects after all.
     

Share This Page