使用移动赋值调整向量大小：结果类型必须可从输入类型构造

Question

I wanted to try to add a move assignment operator to my Mesh class below, knowing that a vector of Meshes appear as a field member in my Model class:

    #include <vector>

    struct Mesh {
      std::vector<int> vertexes;
    
      Mesh() {
      }
    
      Mesh& operator=(Mesh&& m) {
        vertexes = std::move(m.vertexes);
    
        return *this;
      }
    };
    
    struct Model {
      std::vector<Mesh> meshes;
    
      Model() {
        meshes.resize(10);
      }
    };
    
    int main() {
      Model model;
    
      return 0;
    }

This code doesn't work though. Below is the error I'm getting (clang was more explicit than gcc):

    In file included from script.cpp:1:                                                   
    In file included from /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/12.2.0/../../../../include/c++/12.2.0/vector:63:
    /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/12.2.0/../../../../include/c++/12.2.0/bits/stl_uninitialized.h:90:7: error: static_assert failed due to requirement 'is_constructib
    le<Mesh, Mesh &&>::value' "result type must be constructible from input type"                                                                                                
          static_assert(is_constructible<_ValueType, _Tp>::value,                                                                                                                
          ^             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/12.2.0/../../../../include/c++/12.2.0/bits/stl_uninitialized.h:182:4: note: in instantiation of function template specialization 's
    td::__check_constructible<Mesh, Mesh &&>' requested here                                                                                                                     
            = _GLIBCXX_USE_ASSIGN_FOR_INIT(_ValueType2, _From);                
              ^                                                                           
    /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/12.2.0/../../../../include/c++/12.2.0/bits/stl_uninitialized.h:101:13: note: expanded from macro '_GLIBCXX_USE_ASSIGN_FOR_INIT'
        && std::__check_constructible<T, U>()                                                                                                                                    
                ^                                                                         
    /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/12.2.0/../../../../include/c++/12.2.0/bits/stl_uninitialized.h:372:19: note: in instantiation of function template specialization '
    std::uninitialized_copy<std::move_iterator<Mesh *>, Mesh *>' requested here
          return std::uninitialized_copy(__first, __last, __result);                                                                                                             
                      ^                                                                   
    /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/12.2.0/../../../../include/c++/12.2.0/bits/stl_uninitialized.h:396:19: note: in instantiation of function template specialization '
    std::__uninitialized_copy_a<std::move_iterator<Mesh *>, Mesh *, Mesh>' requested here
          return std::__uninitialized_copy_a                                                                                                                                     
                      ^         
    /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/12.2.0/../../../../include/c++/12.2.0/bits/vector.tcc:674:14: note: in instantiation of function template specialization 'std::__un
    initialized_move_if_noexcept_a<Mesh *, Mesh *, std::allocator<Mesh>>' requested here
                          std::__uninitialized_move_if_noexcept_a(                                                                                                               
                               ^
    /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/12.2.0/../../../../include/c++/12.2.0/bits/stl_vector.h:1011:4: note: in instantiation of member function 'std::vector<Mesh>::_M_de
    fault_append' requested here                                                                                                                                                 
              _M_default_append(__new_size - size());
              ^
    script.cpp:20:12: note: in instantiation of member function 'std::vector<Mesh>::resize' requested here
        meshes.resize(10);   
    In file included from script.cpp:1:
    In file included from /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/12.2.0/../../../../include/c++/12.2.0/vector:62:
    /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/12.2.0/../../../../include/c++/12.2.0/bits/stl_construct.h:119:25: error: call to implicitly-deleted copy constructor of 'Mesh'
          ::new((void*)__p) _Tp(std::forward<_Args>(__args)...);
                            ^   ~~~~~~~~~~~~~~~~~~~~~~~~~~~
    /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/12.2.0/../../../../include/c++/12.2.0/bits/stl_uninitialized.h:120:11: note: in instantiation of function template specialization '
    std::_Construct<Mesh, Mesh>' requested here 
                std::_Construct(std::__addressof(*__cur), *__first);
                     ^
    /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/12.2.0/../../../../include/c++/12.2.0/bits/stl_uninitialized.h:137:16: note: in instantiation of function template specialization '
    std::__do_uninit_copy<std::move_iterator<Mesh *>, Mesh *>' requested here
            { return std::__do_uninit_copy(__first, __last, __result); }
                          ^
    /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/12.2.0/../../../../include/c++/12.2.0/bits/stl_uninitialized.h:185:2: note: in instantiation of function template specialization 's
    td::__uninitialized_copy<false>::__uninit_copy<std::move_iterator<Mesh *>, Mesh *>' requested here
            __uninit_copy(__first, __last, __result);
            ^
    /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/12.2.0/../../../../include/c++/12.2.0/bits/stl_uninitialized.h:372:19: note: in instantiation of function template specialization '
    std::uninitialized_copy<std::move_iterator<Mesh *>, Mesh *>' requested here
          return std::uninitialized_copy(__first, __last, __result);
                      ^
    /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/12.2.0/../../../../include/c++/12.2.0/bits/stl_uninitialized.h:396:19: note: in instantiation of function template specialization '
    std::__uninitialized_copy_a<std::move_iterator<Mesh *>, Mesh *, Mesh>' requested here
          return std::__uninitialized_copy_a
                      ^
    /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/12.2.0/../../../../include/c++/12.2.0/bits/vector.tcc:674:14: note: in instantiation of function template specialization 'std::__un
    initialized_move_if_noexcept_a<Mesh *, Mesh *, std::allocator<Mesh>>' requested here
                          std::__uninitialized_move_if_noexcept_a(
                               ^
    /usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/12.2.0/../../../../include/c++/12.2.0/bits/stl_vector.h:1011:4: note: in instantiation of member function 'std::vector<Mesh>::_M_de
    fault_append' requested here
              _M_default_append(__new_size - size());
              ^
    script.cpp:20:12: note: in instantiation of member function 'std::vector<Mesh>::resize' requested here
        meshes.resize(10);
               ^
    script.cpp:9:9: note: copy constructor is implicitly deleted because 'Mesh' has a user-declared move assignment operator
      Mesh& operator=(Mesh&& m) {
        ^

I do realize that:

• std::vector::resize() requires that the value_type is default constructible (hence the empty constructor Mesh::Mesh()).
• The move assignment operator (like the move constructor) deletes the copy constructor and copy assignment operator.

My questions are:

• Why is std::vector::resize() trying to call the deleted copy constructor to allocate space for new items, when an empty constructor is defined?

• Is it failing because one of std::vector::resize() 's requirements isn't met?

• If so how do I meet it without removing the move assignment? (if I do my code works, same with resize()).

Answer 1

std::vector::resize() requires T to be MoveInsertible and DefaultInsertable .

Per MoveInsertible :

If A is std::allocator<T> , then this will call placement-new, as by ::new((void*)p) T(rv) ^{(until C++20)} std::construct_at(p, rv) ^{(since C++20)} . This effectively requires T to be move constructible.

If std::allocator<T> or a similar allocator is used, a class does not have to implement a move constructor to satisfy this type requirement: a copy constructor that takes a const T& argument can bind rvalue expressions. If a MoveInsertable class implements a move constructor, it may also implement move semantics to take advantage of the fact that the value of rv after construction is unspecified.

And per Move constructors :

Implicitly-declared move constructor

If no user-defined move constructors are provided for a class type ( struct , class , or union ), and all of the following is true :

• there are no user-declared copy constructors ;
• there are no user-declared copy assignment operators ;
• there are no user-declared move assignment operators ;
• there is no user-declared destructor .

then the compiler will declare a move constructor as a non- explicit inline public member of its class with the signature T::T(T&&) .

Your Mesh class does not have any user-declared copy/move constructors, but it does have a user-declared move assignment operator. As such, Mesh does not have a compiler-generated move constructor, so it is not move constructible , and thus does not satisfy the requirements of MoveInsertible , hence the compiler error.

To fix this without removing your move assignment operator, as you requested, you will need to add a user-declared copy constructor and/or move constructor to Mesh , eg:

struct Mesh {
    std::vector<int> vertexes;
    
    Mesh() {
    }
    
    Mesh(const Mesh& m) : vertexes(m.vertexes) {
    }
    // and/or:
    Mesh(Mesh&& m) : vertexes(std::move(m.vertexes)) {
    }

    // in which case, you may as well consider adding this, too:
    Mesh& operator=(const Mesh& m) {
        if (this != &m) {
            vertexes = m.vertexes;
        }
        return *this;
    }

    Mesh& operator=(Mesh&& m) {
        vertexes = std::move(m.vertexes);
        return *this;
    }
};

However, std::vector is fully copyable and movable by itself, so if you can forget your unnecessary requirement and get rid of the move assignment operator altogether, then all of the compiler-generated constructors and assignment operators will suffice for this example:

struct Mesh {
    std::vector<int> vertexes;
};

Answer 2

Your class Mesh declares an explicit default constructor, which by default, deletes the move constructor.

Either do not declare a constructor, or declare all these 5 functions:

• default constructor
• copy constructor
• move constructor
• copy operator
• move operator

In most cases, but not all, defaults should work fine.

Example:

#include <vector>

// Quick explanation of the rules of 0, 3 and 5

struct Mesh_rule_of_0 {
    std::vector<int> vertices;
    // rule of zero.  No explicit constructors, nor operator=() defined.
    // The compiler will generate implicit defaults for you.
};

struct Model_0 {
    std::vector<Mesh_rule_of_0> meshes;

    Model_0() { meshes.resize(10); }
};

struct Mesh_rule_of_3 {
    std::vector<int> vertices;

    // if one of these 3 is defined, then all three must be defined
    // The compiler will _try_ to generate implicit move operations for you.

    Mesh_rule_of_3() = default;
    Mesh_rule_of_3(const Mesh_rule_of_3&) = default;
    Mesh_rule_of_3& operator=(const Mesh_rule_of_3&) = default;
};

struct Model_3 {
    std::vector<Mesh_rule_of_3> meshes;
    Model_3() { meshes.resize(10); }
};

struct Mesh_rule_of_5 {
    std::vector<int> vertices;

    // rule of 5, if a move operator is defined, all 5 must be
    // defined.

    Mesh_rule_of_5() = default;
    Mesh_rule_of_5(const Mesh_rule_of_5&) = default;
    Mesh_rule_of_5(Mesh_rule_of_5&&) = default;

    Mesh_rule_of_5& operator=(const Mesh_rule_of_5&) = default;
    Mesh_rule_of_5& operator=(Mesh_rule_of_5&&) = default;
};

struct Model_5 {
    std::vector<Mesh_rule_of_5> meshes;
    Model_5() { meshes.resize(10); }
};

struct Mesh_fail {
    std::vector<int> vertices;

    // this will fail, because it doesn't satisfy the requirements 
    // of the rule of 0, nor of the rule of 3 nor of 
    // the rule of 5
    Mesh_fail() {}
    Mesh_fail& operator=(Mesh_fail&&) = default;
};

// uncomment for failure
// struct Model_fail {
//     std::vector<Mesh_fail> meshes;
//     Model_fail() { meshes.resize(10); }
// };

int main() {
    Model_0 m0;
    Model_3 m3;
    Model_5 m5;

    // uncomment for failure
    // Model_fail mf;

    return 0;
}