O que posso fazer com um objeto movido de?

O padrão define precisamente o que posso fazer com um objeto depois que ele foi movido? Eu costumava pensar que tudo o que você pode fazer com um objeto movido é destruí-lo, mas isso não seria suficiente.

Por exemplo, considere o modelo de função swapconforme definido na biblioteca padrão:

template <typename T>
void swap(T& a, T& b)
{
    T c = std::move(a); // line 1
    a = std::move(b);   // line 2: assignment to moved-from object!
    b = std::move(c);   // line 3: assignment to moved-from object!
}

Obviamente, deve ser possível atribuir a objetos movidos, caso contrário as linhas 2 e 3 falharão. Então, o que mais posso fazer com objetos movidos de? Onde exatamente posso encontrar esses detalhes no padrão?

(A propósito, por que está em T c = std::move(a);vez da T c(std::move(a));linha 1?)

Os objetos removidos existem em um estado não especificado, mas válido. Isso sugere que, embora o objeto possa não ser mais capaz de fazer muito, todas as suas funções de membro ainda devem exibir um comportamento definido - incluindo operator=- e todos os seus membros em um estado definido - e ainda requer destruição. O Padrão não fornece definições específicas porque seria exclusivo para cada UDT, mas você pode encontrar especificações para os tipos Padrão. Alguns contêineres semelhantes são relativamente óbvios - eles apenas movem seu conteúdo e um contêiner vazio é um estado válido bem definido. As primitivas não modificam o objeto movido de.

Nota lateral: Eu acredito que é T c = std::move(a)para que, se o construtor de movimentação (ou construtor de cópia, se nenhuma movimentação for fornecida) for explícito, a função falhará.

17.6.5.15 [lib.types.movedfrom]

Objetos dos tipos definidos na biblioteca padrão C ++ podem ser movidos de (12.8). As operações de movimentação podem ser especificadas explicitamente ou geradas implicitamente. Salvo especificação em contrário, esses objetos movidos devem ser colocados em um estado válido, mas não especificado.

Quando um objeto está em um estado não especificado, você pode executar qualquer operação no objeto que não tenha condições prévias. Se houver uma operação com pré-condições que você deseja executar, não será possível executá-la diretamente porque você não sabe se o estado não especificado do objeto satisfaz as pré-condições.

Exemplos de operações que geralmente não têm pré-condições:

• destruição
• tarefa
• observadores const, como get, empty,size

Exemplos de operações que geralmente têm pré-condições:

• desreferência
• pop_back

Esta resposta agora aparece no formato de vídeo aqui: http://www.youtube.com/watch?v=vLinb2fgkHk&t=47m10s