Preventing compilers from defining copy constructo

Question

Is there a way by which we can prevent compilers from defining copy constructors, operator = overload for C++ classes.

Answer 1

You can declare these functions as private which prevents people from using them when working with your class and at the same time prevents the compiler from generating them.

Answer 2

Inherit from a type that declares those functions in the private scope, such as boost::noncopyable.

Or...have a reference member variable :P

Answer 3

FWIW if you ever get around to using Qt then you can use the Q_DISABLE_COPY macro:

class Foo
{
public:
  Foo();

private:
  Q_DISABLE_COPY(Foo)
};

Answer 4

Yes. Derive from boost::noncopyable.

(There're also NIH ways to do that, by declaring the private never-defined methods for operator= and copy constructor, but, please love boost).

Answer 5

Declare those functions yourself and make them private. Also you can didn't write definitions of that functions, so everyone who try to use those functions - will get an linker error.

Answer 6

In C++0x, you'll be able to write

class NonCopyable {
  NonCopyable & operator=(NonCopyable const&) = delete;
  NonCopyable(NonCopyable const&) = delete;
};

Note that the compiler will not generate converting NonCopyable::operator=(Other const&) overloads in any case.