CODEWITHSUNDEEP
c++c++11singletoncopy-constructor
Sanyam Goel
Sanyam Goel

Reputation: 2180

How to make a C++ class produce non cloneable objects

How can I make a Class non-cloneable like we can do in Java while creating singleton.

Is there any condition we can put on copy constructor so that an exception can be thrown if user tries to make a copy of an object?

I am a novice in C++ so kindly add any info to this or redirect if an answer is already available for the same.

Upvotes: 2

Views: 337

Answers (4)

billz
billz

Reputation: 45410

Just declare copy constructor and copy assign operator private

in C++03 

class NonCopyable
{
public:
   NonCopyable() { }

private:
   NonCopyable(const NonCopyable&);
   NonCopyable& operator=(const NonCopyable&);

};

Also you can make a class derive from NonCopyable, AnotherType is un-copyable 

class AnotherNonCopyable : private NonCopyable
{
   public:
     AnotherNonCopyable () {}
}

With C++11:

class NonCopyableType
{
public:
  NonCopyableType(const NonCopyableType&) = delete;
  NonCopyableType& operator=(const NonCopyableType&) = delete;
};

Upvotes: 7

hetepeperfan
hetepeperfan

Reputation: 4411

Is there any condition we can put on copy constructor so that an exception can be thrown if user tries to make a copy of an object.

if you make the copy constructor private, The code will not compile when the programmer tries to make another copy. This is probably better than detecting the error with an exception at runtime.

class foo {
    private:
         operator = ( const foo& f);
};

Upvotes: 2

juanchopanza
juanchopanza

Reputation: 227390

You can delete the copy constructor and assignment operator:

struct Foo
{
  Foo(const& Foo) = delete;
  Foo& operator=(const Foo&) = delete;
};

If you don't have C++11 support, make them private, and don't implement them:

struct Foo
{
 private:
  Foo(const& Foo);
  Foo& operator=(const Foo&);
};

Note In C++, class and struct are essentially the same.

Upvotes: 5

Sarfaraz Nawaz
Sarfaraz Nawaz

Reputation: 361342

Declare the copy-semantics as delete:

//C++11 only

MyClass(MyClass const &) = delete;            
MyClass& operator=(MyClass const &) = delete;

That makes the class non-copyable!

//pre-C++11 code

private:
  MyClass(MyClass const &);             //declare only, don't define it      
  MyClass& operator=(MyClass const &);  //declare only, don't define it

This should also work!

Upvotes: 3

Related Questions