Most concise way to disable copying class in C++11

Question

I have a problem dealing with deprecated since C++11 default generation of copy constructor and copy assignment operator when there is a user-defined destructor.

For most sufficiently simple classes default-generated constructors, operators and destructor are fine. Consider the following reasons to declare destructor:

1. Making trivial destructor virtual in base class:

   // header
   class Base1 { public: virtual ~Base1() = default; };
   class Base2 { public: virtual ~Base2(); };
   // source
   Base2::~Base2() = default;
   

   Would all 4 copy and move special methods be generated by compiler in these cases? If yes, then I think it is fine and there is no need to complicate Base1 or Base2.

2. Printing debug message in destructor:

   // header
   class D { public: ~D(); };
   // source
   D::~D() {
   #ifdef DEBUG_THIS
       std::cout << "D was destructed." << std::endl;
   #endif
   }
   

   I believe that in this case copy constructor and assignment operator would be generated; but move constructor and assignment operator would not. I want to avoid using deprecated default-generating and disable copying of D. I also want to avoid flooding D with 4 deleted declarations. Is disabling only one copy constructor enough? Is it a good style?

Answer 1

With C++11, a clean way is to follow the pattern used in boost (see here)

You basically create a base class where copy constructor and copy assignment are deleted, and inherit it:

class non_copyable
{
protected:
    non_copyable() = default;
    ~non_copyable() = default;

    non_copyable(non_copyable const &) = delete;
    void operator=(non_copyable const &x) = delete;
};

class MyClass: public non_copyable
{
...
}

Answer 2

Deleting the copy-constructor and copy-assignment operator is the simplest and clearest way to disable copying:

class X
{
    X(X const &) = delete;
    void operator=(X const &x) = delete;
};

I don't follow what you are talking about with virtual destructors in the question body . It sounds like you're asking for a way to make your code take up fewer characters of source code, but also be more cryptic to anybody looking at it.

If the list of deleted functions bothers you, you could hide them behind a macro, I guess.

 #define NON_COPYABLE_NOR_MOVABLE(T) \ 
      T(T const &) = delete; \
      void operator=(T const &t) = delete; \
      T(T &&) = delete;