Como aplicar a semântica de movimento quando um vetor cresce?

Eu tenho uma std::vectorsérie de objetos de uma certa classe A. A classe não é trivial e tem construtores de cópia e construtores de movimento definidos.

std::vector<A>  myvec;

Se eu preencher o vetor com Aobjetos (usando por exemplo myvec.push_back(a)), o vetor aumentará de tamanho, usando o construtor de cópia A( const A&)para instanciar novas cópias dos elementos no vetor.

Posso de alguma forma impor que o construtor de movimento da classe Aestá começando a ser usado em vez disso?

Você precisa informar ao C ++ (especificamente std::vector) que o seu construtor e destruidor de movimento não atira, usando noexcept. Então, o construtor de movimento será chamado quando o vetor crescer.

Esta é a forma de declarar e implementar um construtor de movimento que é respeitado por std::vector:

A(A && rhs) noexcept { 
  std::cout << "i am the move constr" <<std::endl;
  ... some code doing the move ...  
  m_value=std::move(rhs.m_value) ; // etc...
}

Se o construtor não for noexcept, não std::vectorpode usá-lo, pois então não pode garantir as garantias de exceção exigidas pelo padrão.

Para mais informações sobre o que é dito no padrão, leia C ++ Move semantics and Exceptions

Crédito para Bo, que deu a entender que pode ter a ver com exceções. Considere também o conselho de Kerrek SB e use emplace_backquando possível. Ele pode ser mais rápido (mas muitas vezes não é), pode ser mais clara e mais compacto, mas também existem algumas armadilhas (especialmente com construtores não explícitas).

Edite , muitas vezes o padrão é o que você deseja: mova tudo o que pode ser movido, copie o resto. Para pedir isso explicitamente, escreva

A(A && rhs) = default;

Fazendo isso, você obterá noexcept quando possível: O construtor Move padrão está definido como noexcept?

Observe que as versões anteriores do Visual Studio 2015 e anteriores não davam suporte a isso, embora ofereça suporte à semântica de movimentação.

Curiosamente, o vetor do gcc 4.7.2 só usa o construtor de movimento se o construtor de movimento e o destruidor o forem noexcept. Um exemplo simples:

struct foo {
    foo() {}
    foo( const foo & ) noexcept { std::cout << "copy\n"; }
    foo( foo && ) noexcept { std::cout << "move\n"; }
    ~foo() noexcept {}
};

int main() {
    std::vector< foo > v;
    for ( int i = 0; i < 3; ++i ) v.emplace_back();
}

Isso produz o esperado:

move
move
move

No entanto, quando removo noexceptde ~foo(), o resultado é diferente:

copy
copy
copy

Eu acho que isso também responde a essa pergunta .

Parece que a única maneira (para C ++ 17 e anteriores) de forçar o std::vectoruso da semântica de movimentação na realocação é excluindo o construtor de cópia :). Desta forma, ele usará seus construtores de movimento ou teste de dados, em tempo de compilação :).

Existem muitas regras onde std::vectorNÃO DEVE usar o construtor de movimento na realocação, mas nada sobre onde ele DEVE USAR .

template<class T>
class move_only : public T{
public:
   move_only(){}
   move_only(const move_only&) = delete;
   move_only(move_only&&) noexcept {};
   ~move_only() noexcept {};

   using T::T;   
};

Viver

ou

template<class T>
struct move_only{
   T value;

   template<class Arg, class ...Args, typename = std::enable_if_t<
            !std::is_same_v<move_only<T>&&, Arg >
            && !std::is_same_v<const move_only<T>&, Arg >
    >>
   move_only(Arg&& arg, Args&&... args)
      :value(std::forward<Arg>(arg), std::forward<Args>(args)...)
   {}

   move_only(){}
   move_only(const move_only&) = delete;   
   move_only(move_only&& other) noexcept : value(std::move(other.value)) {};    
   ~move_only() noexcept {};   
};

Código ao vivo

Sua Tclasse deve ter noexcepto construtor de movimento / operador de atribuição e noexceptdestruidor. Caso contrário, você obterá um erro de compilação.

std::vector<move_only<MyClass>> vec;