1. This site uses cookies. By continuing to use this site, you are agreeing to our use of cookies. Learn More.

Eliminating Temporary Objects

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

  1. pradeep

    pradeep Team Leader

    Joined:
    Apr 4, 2005
    Messages:
    1,646
    Likes Received:
    86
    Trophy Points:
    0
    Occupation:
    Programmer
    Location:
    Kolkata, India
    Home Page:
    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

    Joined:
    May 9, 2006
    Messages:
    90
    Likes Received:
    0
    Trophy Points:
    0
    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

    Joined:
    Jul 12, 2004
    Messages:
    15,285
    Likes Received:
    364
    Trophy Points:
    83
    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

    Joined:
    May 9, 2006
    Messages:
    90
    Likes Received:
    0
    Trophy Points:
    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.
     
  5. coderzone

    coderzone Super Moderator

    Joined:
    Jul 25, 2004
    Messages:
    734
    Likes Received:
    37
    Trophy Points:
    0
    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

    Joined:
    Jul 12, 2004
    Messages:
    15,285
    Likes Received:
    364
    Trophy Points:
    83
    and also the + operator.
    Yes thats the main reason why we have temp objects after all.
     

Share This Page