Static assertion for a move constructor different from the copy constructor

Question

Imagine that I have a class A that is cheap to move and expensive to copy. It could look like

class A {
  public: 
    [...]

  private:
    HeavyClass m;
};

For this class, I would like an static verification that the class (1) is move constructible and (2) does not simply use the copy constructor for move construction, independently of whether the move constructor was explicitly declared or not.

Is this possible?

As to why I would like this, consider the following example: At first, the class generates the move constructor automatically and behaves as desired. Then, someone changes the class and adds a destructor, which causes the move constructor not to be implicitly generated and the copy constructor to be used instead.

Therefore, a static_assert would be ideal, but it seems that none of is_move_constructible or is_trivially_move_constructible is helpful here.

Also, I know that it is possible to have A(A&&) = default; for all such classes but a solution with a static_assert would be cleaner and allow for doing the check outside of the class definition (f.i. in other projects relying on this class).

EDIT:
I do not want to forbid copy construction, I would just like to make sure that the move constructor is not using it...

Answer 1

If you can change A to have an indirection, you may do the following:

template <bool>
struct MoveOnly {
    MoveOnly() = default;
    ~MoveOnly() = default;
    MoveOnly(const MoveOnly&) = delete;
    MoveOnly(MoveOnly&&) = default;
    MoveOnly& operator=(const MoveOnly&) = delete;
    MoveOnly& operator=(MoveOnly&&) = default;
};

template <> struct MoveOnly<false> {};

template <bool check = false>
class A_Impl : MoveOnly<check> {
public: 
    // ... as ~A_Impl() {}
    // ...
private:
    HeavyClass m;
};

using A = A_Impl<false>; // Normal case

// The check
static_assert(std::is_move_constructible<A_Impl<true>>::value, "");

Demo

Answer 2

Generation of copy constructor and copy assignment operator is deprecated when destructor is declared. No need for static assert or templates, this is part of modern C++.

The solution is simply to enable deprecation warnings

Also turn warnings into errors if you have not already done so.

This way you don't have to remember to add static asserts all over. Also, you are still allowed to add destructors, have non-moveable members and inherit from non-moveables as long as you do not copy or move any instances of such objects. No point in restrictions when they don't apply.

With this setup you can try to add this code to you class (a typical regression)

virtual ~A() = default;

If you try to move or copy an instance of A now, then compilation will fail.

Example error message from clang-3.9 -Werror -Wdeprecated

main.cpp:13:13: error: definition of implicit copy assignment
operator for 'A' is deprecated because it has a user-declared 
destructor [-Werror,-Wdeprecated]
    virtual ~A() = default;
            ^
main.cpp:21:7: note: implicit copy assignment operator for
'A' first required here
    b = std::move(a);
      ^
1 error generated.

If you create an instance of A and simply pass it around by const reference, then no complaints from you compiler.

Answer 3

This is a totally generic maintenance problem. Ideally we want to find a generic solution for this. Manually adding asserts is a poor solution. It is error prone, easy to forget, time consuming and makes code less readable.

One generic solution would be to use a static analyzer to enforce the Rule of Zero for all classes.

Link to SO question about this. However, adding compiler options as described in my other answer is a better solution if you compiler suports it.