Почему необходима семантика перемещения для исключения временных копий?

Семантика копирования и перемещения не совсем то же самое. При копировании не копируется весь объект, он остается на месте. При движении «что-то» все равно копируется. Копия на самом деле не устранена. Но это «что-то» - бледная тень того, что должна утащить полноценная копия.

Простой пример:

class Bar {

    std::vector<int> foo;

public:

    Bar(const std::vector<int> &bar) : foo(bar)
    {
    }
};

std::vector<int> foo();

int main()
{
     Bar bar=foo();
}

Удачи в попытках заставить ваш компилятор удалить копию здесь.

Теперь добавьте этот конструктор:

    Bar(std::vector<int> &&bar) : foo(std::move(bar))
    {
    }

И теперь объект в main() создается с помощью операции перемещения. Полная копия на самом деле не была удалена, но операция перемещения - это просто некоторый линейный шум.

С другой стороны:

Bar foo();

int main()
{
     Bar bar=foo();
}

Здесь будет полная копия. Ничего не копируется.

В заключение: семантика перемещения на самом деле не исключает и не удаляет копию. Это просто делает получившуюся копию «меньше».

У вас есть фундаментальное непонимание того, как работают определенные вещи в C ++:

Даже без семантики перемещения C ++ 11 компилятор все равно должен уметь определять, что выражение, переданное в func (), является rvalue, и, следовательно, копия из временного объекта не нужна.

Этот код не вызывает никакого копирования, даже в C ++ 98. const& - это ссылка, а не значение. И поскольку это const, он вполне может ссылаться на временное. Таким образом, функция, принимающая const string& никогда, получает копию параметра.

Этот код создаст временный объект и передаст ссылку на него в func. Копирование вообще не происходит.

В качестве другого примера, зачем использовать такой код?

Никто не делает. Функция должен принимать параметр по ссылке rvalue только в том случае, если эта функция будет перемещаться от него. Если функция собирается только наблюдать значение, не изменяя его, они принимают его на const&, как в C ++ 98.

Самое главное:

Итак, мое понимание семантики перемещения состоит в том, что они позволяют вам переопределять функции для использования с временными значениями (rvalues) и избегать потенциально дорогостоящих копий (путем перемещения состояния из безымянного временного значения в ваше именованное lvalue).

Ваше понимание неверно.

Перемещение касается не исключительно временных значений; если бы это было так, у нас не было бы std::move, позволяющего перейти от lvalues. Перемещение - это передача владения данными от одного объекта к другому. Хотя это часто происходит с временными библиотеками, это также может происходить с lvalue:

std::unique_ptr<T> p = ...
std::unique_ptr<T> other_p = std::move(p);
assert(p == nullptr); //Will always be true.

Этот код создает unique_ptr, а затем перемещает содержимое этого указателя в другой объект unique_ptr. Это не касается временных конструкций; он передает владение внутренним указателем другому объекту.

Это не то, что компилятор мог сделать выводом о том, что вы хотели сделать. Вы должны явно заявить, что хотите выполнить такой переход с lvalue (вот почему там std::move).

Ответ заключается в том, что семантика перемещения была введена не для удаления копий. Он был введен, чтобы позволить / продвигать более дешевое копирование. Например, если все члены данных класса являются простыми целыми числами, семантика копирования будет такой же, как и семантика перемещения. В этом случае нет смысла определять оператор перемещения и оператор присваивания перемещения для этого класса. Перемещение ctor и назначение перемещения имеют смысл, когда в классе есть что-то, что можно переместить.

На эту тему написано множество статей. Тем не менее некоторые примечания:

• Когда параметр указан как T&&, всем становится ясно, что украсть его содержимое - это нормально. Точка. Просто и понятно. В C ++ 03 не было четкого синтаксиса или какого-либо другого установленного соглашения, чтобы передать эту идею. На самом деле, есть масса других способов выразить то же самое. Но комитет пошел по этому пути.
• Семантика перемещения полезна не только для rvalue ссылок. Его можно использовать везде, где вы хотите указать, что хотите передать свой объект функции, и эта функция может принимать его содержимое.

У вас может быть такой код:

void Func(std::vector<MyComplexType> &v)
{
    MyComplexType x;
    x.Set1();          // Expensive function that allocates storage
                       // and computes something.
    .........          // Ton of other code with if statements and loops
                       // that builds the object x.

    v.push_back(std::move(x));  // (1)

    x.Set2();         // Code continues to use x. This is ok.        
}

Обратите внимание, что в строке (1) будет использоваться ctor перемещения, и объект будет добавлен по более низкой цене. Обратите внимание, что объект не умирает на этой линии и там нет временных объектов.