Here are some ways to prevent compiler generated functions:

     The key to the solution is that all the compiler generated functions are public. To prevent these functions from being generated, you must declare them yourself, but there is nothing that requires that you declare them public. Instead, declare the copy constructor and the copy assignment operator private. By declaring a member function explicitly, you prevent compilers from generating their own version, and by making the function private, you keep people from calling it.

     But member and friend function can still call this private functions. So, another trick is declaring member functions private and deliberately not implementing them. 

     class NonCom{
          public:
               .....
          private:
               NonCom(const NonCom&);
               NonCom& operator=(const NonCom&);
               ...
          };

     If you inadvertently try to do call this function in a member or a friend function, the linker will complain.

     It‘s possible to move the link- time error up to compile time (always a good thing—earlier error detection is better than later) by declaring the copy constructor and copy assignment operator private  not in NonCom itself, but in a base class specifically designed to prevent copying. The base class is simplicity itself:

     class noncopyable{
          public:
               noncopyable(){}
               ~noncopyable(){}
          private:
               noncopyable(const noncopyable&);
               noncopyable& operator=(const noncopyable&);
     };
     class NonCom : noncopyable{
          ...
     }; 

     This works, because compilers will try to generate a copy constructor and a copy assignment operator if anybody — even a member or friend function — tries to copy a NonCom object. As Item 12 (See 10.8) explains, the compiler- generated versions of these functions will try to call their base class counterparts, and those calls will be rejected, because the copying operations are private in the base class.