What are the advantages of boost::noncopyable

Question

To prevent copying a class, you can very easily declare a private copy constructor / assignment operators. But you can also inherit boost::noncopyable.

What are the advantages / disadvantages of using boost in this case?

Answer 1

I see no documentation benefit:

#include <boost/noncopyable.hpp>  struct A     : private boost::noncopyable { }; 

vs:

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

When you add move-only types, I even see the documentation as misleading. The following two examples are not copyable, though they are movable:

#include <boost/noncopyable.hpp>  struct A     : private boost::noncopyable {     A(A&&) = default;     A& operator=(A&&) = default; }; 

vs:

struct A {     A(A&&) = default;     A& operator=(A&&) = default; }; 

Under multiple inheritance, there can even be a space penalty:

#include <boost/noncopyable.hpp>  struct A     : private boost::noncopyable { };  struct B     : public A {     B();     B(const B&);     B& operator=(const B&); };  struct C     : public A { };  struct D     : public B,       public C,       private boost::noncopyable { };  #include <iostream>  int main() {     std::cout << sizeof(D) << '\n'; } 

For me this prints out:

3 

But this, which I believe to have superior documentation:

struct A {     A(const A&) = delete;     A& operator=(const A&) = delete; };  struct B     : public A {     B();     B(const B&);     B& operator=(const B&); };  struct C     : public A {     C(const C&) = delete;     C& operator=(const C&) = delete; };  struct D     : public B,       public C {     D(const D&) = delete;     D& operator=(const D&) = delete; };  #include <iostream>  int main() {     std::cout << sizeof(D) << '\n'; } 

Outputs:

2 

I find it much easier to declare my copy operations than to reason whether or not I'm deriving from boost::non_copyable multiple times and if that is going to cost me. Especially if I'm not the author of the complete inheritance hierarchy.