With explicitly deleted member functions in C++11, is it still worthwhile to inherit from a noncopyable base class?

by

Well, this:

private:
    MyClass(const MyClass&) {}
    MyClass& operator=(const MyClass&) {}

Still technically allows MyClass to be copied by members and friends. Sure, those types and functions are theoretically under your control, but the class is still copyable. At least with boost::noncopyable and = delete, nobody can copy the class.

I don’t get why some people claim it’s easier to make a class non-copyable in C++11.

It’s not so much “easier” as “more easily digestible”.

Consider this:

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

If you are a C++ programmer who has read an introductory text on C++, but has little exposure to idiomatic C++ (ie: a lot of C++ programmers), this is… confusing. It declares copy constructors and copy assignment operators, but they’re empty. So why declare them at all? Yes, they’re private, but that only raises more questions: why make them private?

To understand why this prevents copying, you have to realize that by declaring them private, you make it so that non-members/friends cannot copy it. This is not immediately obvious to the novice. Nor is the error message that they will get when they try to copy it.

Now, compare it to the C++11 version:

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

What does it take to understand that this class cannot be copied? Nothing more than understanding what the = delete syntax means. Any book explaining the syntax rules of C++11 will tell you exactly what that does. The effect of this code is obvious to the inexperienced C++ user.

What’s great about this idiom is that it becomes an idiom because it is the clearest, most obvious way to say exactly what you mean.

Even boost::noncopyable requires a bit more thought. Yes, it’s called “noncopyable”, so it is self-documenting. But if you’ve never seen it before, it raises questions. Why are you deriving from something that can’t be copied? Why do my error messages talk about boost::noncopyable‘s copy constructor? Etc. Again, understanding the idiom requires more mental effort.

More Related Contents:

  1. Dots in printf in C++
  2. What does the namespace std add? (C++) [closed]
  3. to_string is not a member of std, says g++ (mingw)
  4. Rvalue Reference is Treated as an Lvalue?
  5. How do I terminate a thread in C++11?
  6. When should std::move be used on a function return value? [duplicate]
  7. What is the type of lambda when deduced with “auto” in C++11?
  8. What are inline namespaces for?
  9. Arrow operator (->) in function heading
  10. C++ auto keyword. Why is it magic?
  11. How much is the overhead of smart pointers compared to normal pointers in C++?
  12. How to store variadic template arguments?
  13. Choosing between std::map and std::unordered_map [duplicate]
  14. How to declare a vector of atomic in C++
  15. Try to understand compiler error message: default member initializer required before the end of its enclosing class
  16. How to use C++11 uniform initialization syntax?
  17. Constant expression initializer for static class member of type double
  18. C++11 full support on Eclipse [closed]
  19. std::function fails to distinguish overloaded functions
  20. Variadic templates
  21. C++11: How to alias a function? [duplicate]
  22. Can C++ code be valid in both C++03 and C++11 but do different things?
  23. Should a move constructor take a const or non-const rvalue reference?
  24. std::unique_ptr with derived class
  25. how to avoid undefined execution order for the constructors when using std::make_tuple
  26. Move out element of std priority_queue in C++11
  27. Memory alignment : how to use alignof / alignas?
  28. Check if a type is from a particular namespace
  29. Does ‘auto’ type assignments of a pointer in c++11 require ‘*’?
  30. Why can’t C++11 move a noncopyable functor to a std::function?

Leave a Comment