Back to General and Gameplay Programming

The Copy&Swap Idiom

The Comet · 2013-10-18T10:11:28

This thread is about me questioning the efficiency of the copy&swap idiom. Before I can ask this question, however, I will briefly explain what the copy&swap idiom is. For those of you who already know it, you can skip to the next big headline. The Copy&Swap Idiom I was reading up on the rule of 3, and found a more elegant way of overriding the assignment operator. The way I initially learned to do it was something like this: class Foo { public: Foo& operator=( const Foo& cp ) { if( this == &cp ) return *this; // copy resources here return *this; } }; HOWEVER, this is not exception safe (for instance, if you are allocating new objects during the copying of resources, and any one of them throws an exception, you'll be looking at a memory leak) and it performs needless checks for self assignment. The copy&swap idiom solves these problems. It requires your class to have a copy constructor and a swap method in order to work (which is also part of the rule of 3 and a half). The simplest example of a copy&swap implementation would look like the following: #include <algorithm> // std::swap class Foo public: Foo( const Foo& cp ) : m_Data(cp.m_Data) /*insert any copyable members into initializer list*/ {} Foo& operator=( Foo O ) // intentionally not a reference, so copying of the object Foo is forced { swap( O ); return *this; } void swap( Foo& O ) { using std::swap; swap( m_Data, o.m_Data ); /* swap any further copyable members here*/ } private: int m_Data; }; Given this test code: Foo myObject1; Foo myObject2; myObject2 = myObject1; // copy and swap When calling myObject2 = myObject1, the overridden assignment operator operator=( Object1 ) is called. Now here's the part where the magical thing happens: As seen in the comments in the code, Object1 is not passed by reference, but by value. What does this mean? Two things: The copying of Object1 into a temporary is forced, which means the copy constructor of Foo is called before we even enter the overridden assignment method. Unlike the "traditional" way of overriding assignment, if an exception is thrown within the copy constructor, it is guaranteed to be handled by the class' destructor as soon as it goes out of scope. Since std::swap is guaranteed to be exception safe, any further operations are guaranteed to be safe as well. A far more detailed description can be found here: http://stackoverflow.com/questions/3279543/what-is-the-copy-and-swap-idiom Efficiency So here's my question. Following the completely unoptimized version of the code, there appear to be a total of 4 copies made of the object. The first copy is done when the copy constructor is first called from when the assignment operator is called. The second, third, and forth copies are done inside std::swap, where it copies each member of the object into a temporary, copies one to the other, and then copies the temporary back before destructing it again. How efficient is this? Here is some code for you to play around with using the copy&swap idiom: #include <iostream> #include <algorithm> template <class T> class Container { public: // default constructor Container( void ); // copy constructors Container( const Container<T>& cp ); Container( const Container<T>* cp ); // destructor ~Container( void ); // pushes an element into the container void push_back( const T& data ); // returns the number of elements currently in the container const std::size_t& size( void ) const; // prints the contents of the container to cout void print( void ); // override subscript operators for easy element access T& operator[]( const std::size_t& index ); const T& operator[]( const std::size_t& index ) const; // the copy&swap idiom Container<T>& operator=( Container<T> o ); void swap( Container<T>& o ); private: T* m_Data; std::size_t m_Size; }; // --------------------------------------------------------------------- template <class T> Container<T>::Container( void ) : m_Data( 0 ), m_Size( 0 ) { } // --------------------------------------------------------------------- template <class T> Container<T>::Container( const Container<T>& cp ) : m_Data( new T[cp.m_Size] ), m_Size( cp.m_Size ) { for( std::size_t i = 0; i != m_Size; ++i ) m_Data[i] = cp.m_Data[i]; } // --------------------------------------------------------------------- template <class T> Container<T>::Container( const Container<T>* cp ) : m_Data( new T[cp->m_Size] ), m_Size( cp->m_Size ) { for( std::size_t i = 0; i != m_Size; ++i ) m_Data[i] = cp->m_Data[i]; } // --------------------------------------------------------------------- template <class T> Container<T>::~Container( void ) { if( m_Data ) delete[] m_Data; } // --------------------------------------------------------------------- template <class T> void Container<T>::push_back( const T& data ) { // reallocate memory T* oldData = m_Data; m_Data = new T[m_Size+1]; if( oldData ) { for( std::size_t i = 0; i != m_Size; ++i ) m_Data[i] = oldData[i]; delete[] oldData; } // add new data m_Data[m_Size] = data; ++m_Size; } // --------------------------------------------------------------------- template <class T> void Container<T>::print( void ) { for( std::size_t i = 0; i != m_Size; ++i ) std::cout << m_Data[i] << std::endl; } // --------------------------------------------------------------------- template <class T> const std::size_t& Container<T>::size( void ) const { return m_Size; } // --------------------------------------------------------------------- template <class T> T& Container<T>::operator[]( const std::size_t& index ) { return m_Data[index]; } // --------------------------------------------------------------------- template <class T> const T& Container<T>::operator[]( const std::size_t& index ) const { return m_Data[index]; } // --------------------------------------------------------------------- template <class T> Container<T>& Container<T>::operator=( Container<T> o ) { swap( o ); return *this; } // --------------------------------------------------------------------- template <class T> void Container<T>::swap( Container<T>& o ) { using std::swap; swap( m_Data, o.m_Data ); swap( m_Size, o.m_Size ); } // --------------------------------------------------------------------- // simple test int main() { // test on stack { Container<int> test2; { Container<int> test; test.push_back(10); test.push_back(20); test.print(); test2 = test; // copy and swap occurs here } test2.print(); } // test on heap Container<int>* test = new Container<int>(); test->push_back(666); test->push_back(999); test->print(); Container<int>* test2 = new Container<int>(); *test2 = *test; // copy and swap occurs here delete test; test2->print(); delete test2; return 0; }

General and Gameplay Programming Programming

Started by TheComet October 16, 2013 12:00 PM

31 comments, last by TheComet 10 years, 6 months ago

Khatharr

8,814

October 18, 2013 05:03 AM

Is this not how it's done traditionally? Or am I missing something?

'traditional' isn't a technical term, but in this context it would mean 'plainly wrong and rather straw-mannish'. Of course you can get leakage if you do it that way. You're using raw pointers for resource control. That doesn't mean that C&S is the only alternative. Doing it right is another alternative, as I showed in the block after that.

C&S collects the copying behavior and then adopts it in a single transaction. That's the correct pattern, but C&S is not the only way to implement that pattern, and it can be unclear, make the machine do more work than it needs to, and/or trigger side-effects.

Using smart pointers or other RAII implementors allows you to prepare the new state, and then once everything is created successfully you adopt it. That's the 'normal' way of writing exception safe code. C&S is just a trick for doing that by invoking the copy ctor and then adopting it only if construction succeeds.

It does not magically guarantee exception safety.

Your code here is NOT exception safe!


    // copy constructor
    Player( const Player& that ) : m_Texture( new Texture(*that.m_Texture) ),
                                                  m_Sprite( new Sprite(*that.m_Texture) ),
                                                  m_Health( new m_HealthController(*that.m_Health) )

    {
    }

What if the allocation for m_Health fails? m_Texture and m_Sprite have already been allocated! How will you reach them in order to release them, since the object failed construction?

void hurrrrrrrr() {__asm sub [ebp+4],5;}

There are ten kinds of people in this world: those who understand binary and those who don't.

King Mir

2,506

October 18, 2013 07:55 AM

Your code here is NOT exception safe!
    // copy constructor
    Player( const Player& that ) : m_Texture( new Texture(*that.m_Texture) ),
                                                  m_Sprite( new Sprite(*that.m_Texture) ),
                                                  m_Health( new m_HealthController(*that.m_Health) )

    {
    }
What if the allocation for m_Health fails? m_Texture and m_Sprite have already been allocated! How will you reach them in order to release them, since the object failed construction?

Code like this shows why RAII works best when there is only one resource per object. If you wrap each of m_Texture, m_Sprite, and m_Health in it own object, then these sorts of problems go away. Alternatively, proper use of smart pointers used together with make_shared and the like resolves the problems too, because of how make_shared works.

Not that it's not possible to write a class that maintains two resources and is exception safe, but that's doing things the hard way, and is a likely spot for bugs introduced when the code is later maintained.

TheComet

3,927

Author

October 18, 2013 10:11 AM

@Khatharr & King Mir - Ah, I see now. Thanks for the pointers!

"I would try to find halo source code by bungie best fps engine ever created, u see why call of duty loses speed due to its detail." -- GettingNifty

The Copy&Swap Idiom

This topic is closed to new replies.

Popular Topics

Recommended Tutorials

The Copy&Swap Idiom

This topic is closed to new replies.

Popular Topics

Recommended Tutorials

Reticulating splines