Question

Suppose you have a class NonCopyable

class NonCopyable
{
public:
   NonCopyable(int n){}
   ~NonCopyable(){}
   [...]

private:
   [members...]

private:
   NonCopyable( const NonCopyable& ); //disabled (no definition)
   NonCopyable& operator= ( const NonCopyable& ); //disabled (no definition)
};

For this class, it’s illogical to have copies of it, thus the copy constructor and assignment operator are disabled.

However, when you need a vector of NonCopyables objects:

std::vector<NonCopyable> m_V;
int n;
m_V.push_back(NonCopyable(n));

Here, you implicitly invoke the copy constructor.

I’ve been taught to solve this problem by using pointers to those objects instead of the objects themselves. But this is annoying both in use and in performance, because you have to dynamically allocate those objects with new()…

My question:
Is there a way around this? What’s a common solution to this problem?

Answer 1

C++11 has a solution that applies to many non-copyable classes: make the class movable (instead of copyable), and use emplace_back to add new elements to the vector.

If you need to fudge something with C++03, perhaps you can find a way to implement copying of “empty” NonCopyable objects (and use Luchian’s idea of restricting this operation), and also find a way to implement swap. Then you can do:

std::vector<NonCopyable> m_V;
int n;
m_V.push_back(NonCopyable());
NonCopyable(n).swap(m_V.back());