Preventing Object Copy in C++ (3 Different Ways)

4.5

Many times, user wants that an instance of a C++ class should not be copied at all. So, the question is how do we achieve this ?

There are three ways to achieve this :

  1. Keeping the Copy Constructor and Copy assignment operator as private in the class.

    Below is the C++ implementation to illustrate how this can be done.

    #include <iostream>
    using namespace std;
    
    class Base {
        int x;
    public:
        Base()    {  }
        Base(int y): x(y)     {  }
    private:
    
        // Copy constructor
        Base(const Base& obj) : x(obj.x) {   }
    
        // copy assignment operator
        Base& operator=(const Base& tmp_obj)
        {
            x = tmp_obj.x;
            return *this;
        }
    };
    
    int main()
    {
        Base b1(10);
        Base b2(b1); // calls copy constructor
        b2 = b1; // calls copy assignment operator
        return 0;
    }
    

    NOTE: This code does not compile as we cannot copy the object of this class and hence it will show this error.

    prog.cpp: In function 'int main()':
    prog.cpp:18:2: error: 'Base::Base(const Base&)' is private
      Base(const Base &obj) : x(obj.x) //Copy constructor
      ^
    prog.cpp:33:12: error: within this context
      Base b2(b1); // Calls copy constructor
                ^
    prog.cpp:22:8: error: 'Base& Base::operator=(const Base&)' is private
      Base& operator = (const Base& tmp_obj) // copy assignment operator
            ^
    prog.cpp:35:5: error: within this context
      b2 = b1; // calls copy assignment operator
         ^
    
  2. Inherit a Dummy class with a private copy constructor and a private copy assignment operator.

    Below is the C++ implementation to illustrate how this can be done.

    #include <iostream>
    using namespace std;
    
    class Dummy {
    public:
        Dummy() {  }
    private:
        Dummy(const Dummy& temp_obj)  {   }
        Dummy& operator=(const Dummy& temp_obj)   {   }
    };
    
    class Base : public Dummy {
        int x;
    public: 
        Base()  {   }
        Base(int y) : x(y)  {  }
    };
    
    int main()
    {
        Base b1(10);
        Base b2(b1); // Calls copy constructor
        b2 = b1; // Calls copy assignment operator
        return 0;
    }
    
    prog.cpp: In function 'int main()':
    
    prog.cpp:12:5: error: 
    'Dummy::Dummy(const Dummy&)' is private
         Dummy(const Dummy &temp_obj)
         ^
    prog.cpp:22:7: error: within this context
     class Base: public Dummy
           ^
    prog.cpp:16:12: error: 
    'Dummy& Dummy::operator=(const Dummy&)' is private
         Dummy& operator = (const Dummy &temp_obj)
                ^
    prog.cpp:22:7: error: within this context
     class Base: public Dummy
    

    NOTE: This code does not compile as we cannot copy the object of this class and hence it will show this error.

  3. Using Deleted copy constructor and copy assignment operator: Above two ways are quite complex, C++11 has come up with a simpler solution i.e. just delete the copy constructor and assignment operator.

    Below is the C++ implementation to illustrate :

    // CPP program to demonstrate use Delete copy
    // constructor and delete assignment operator
    #include <iostream>
    using namespace std;
    
    class Base {
        int x;
    public:
        Base()   {     }
        Base(int y) : x(y) {    }
        Base(const Base& temp_obj) = delete;
        Base& operator=(const Base& temp_obj) = delete;
    };
    
    int main()
    {
        Base b1(10);
        Base b2(b1); // Calls copy constructor
        b2 = b1; // Calls copy assignment operator
        return 0;
    }
    
    prog.cpp: In function 'int main()':
    prog.cpp:24:15: error: use of deleted function
     'Base::Base(const Base&)'
         Base b2(b1); // Calls copy constructor
                   ^
    prog.cpp:16:5: note: declared here
         Base(const Base &temp_obj) = delete;
         ^
    prog.cpp:26:8: error: use of deleted function 
    'Base& Base::operator=(const Base&)'
         b2 = b1;  // Calls copy assignment operator
            ^
    prog.cpp:17:11: note: declared here
         Base& operator = (const Base &temp_obj) = delete;
               ^
    

    NOTE: This code does not work as we cannot copy the object of this class and hence it will show this error.


Reference:

https://ariya.io/2015/01/c-class-and-preventing-object-copy

This article is contributed by MAZHAR IMAM KHAN. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

GATE CS Corner    Company Wise Coding Practice

Recommended Posts:



4.5 Average Difficulty : 4.5/5.0
Based on 8 vote(s)










Writing code in comment? Please use ide.geeksforgeeks.org, generate link and share the link here.