забудьте о C++0x на данный момент. Семантика перемещения-это то, что не зависит от языка . C++0x просто предоставляет стандартный способ выполнения операций с семантикой перемещения.

определение

переместить семантика определите поведение определенных операций. Большую часть времени они контрастируют с скопировать семантику, поэтому было бы полезно сначала определить их.

задание копировать семантика имеет следующие характеристики:

// Copy semantics
assert(b == c);
a = b;
assert(a == b && b == c);

то есть a заканчивается равен b, оставить b без изменений.

задание переместить семантика имеет более слабые условия сообщение:

// Move semantics
assert(b == c);
move(a, b); // not C++0x
assert(a == c);

обратите внимание, что больше нет никакой гарантии, что b остается неизменным после назначения с семантикой перемещения. В этом принципиальное отличие.

использует

одно преимущество движения семантика заключается в том, что она позволяет оптимизировать в определенных ситуациях. Рассмотрим следующий тип регулярного значения:

struct A { T* x; };

предположим также, что мы определяем два объекта типа A равным МФЛ их x член указывает на равные значения.

bool operator==(const A& lhs, const A& rhs) { return *lhs.x == *rhs.x; }

наконец, предположим, что мы определяем объект A иметь единоличное владение над указателем их x член.

A::~A() { delete x; }
A::A(const A& rhs) : x(new T(rhs.x)) {}
A& A::operator=(const A& rhs) { if (this != &rhs) *x = *rhs.x; }

теперь предположим, что мы хотим определить функцию для замены двух A объекты.

мы могли бы сделать это обычным способом с семантикой копирования.

void swap(A& a, A& b)
{
    A t = a;
    a = b;
    b = t;
}

однако это излишне неэффективно. Что мы делаем?

• мы создаем копию a на t.
• затем мы копируем b на a.
• скопировать t на b.
• наконец, уничтожить t.

если T объекты дорого копировать, то это расточительно. Если бы я попросил вас поменять местами два файла на вашем компьютере, вы бы не создали третий файл, а затем скопировать и вставить содержимое файла вокруг, прежде чем уничтожить временный файл, не так ли? Нет, ты бы движение один файл,движение второй в первую позицию, затем, наконец,движение первый файл во второй. Нет необходимости копировать данные.

в нашем случае легко перемещаться по объектам типа A:

// Not C++0x
void move(A& lhs, A& rhs)
{
    lhs.x = rhs.x;
    rhs.x = 0;
}

мы просто двигайтесь rhsуказатель на lhs и затем отказаться rhs владение этим указателем (установив его в значение null). Это должно объяснить, почему более слабое условие post семантики перемещения позволяет оптимизировать.

С этой новой операцией перемещения, мы можем определить оптимизированный своп:

void swap(A& a, A& b)
{
    A t;
    move(t, a);
    move(a, b);
    move(b, t);
}

еще одним преимуществом семантики перемещения является то, что она позволяет перемещать объекты, которые не могут быть скопированы. Ярким примером этого является std::auto_ptr.

C++0x

C++0x позволяет перемещать семантику через ее ссылочную функцию rvalue. В частности, операции такого рода:

a = b;

есть семантика перемещения, когда b является ссылкой rvalue (spelt T&&), в противном случае у них есть семантика копирования. Вы можете заставить семантику перемещения с помощью std::move функция (отличается от move я задал ранее), когда b не rvalue ссылка:

a = std::move(b);

std::move - это простая функция, которая по существу приводит свой аргумент к ссылке rvalue. Следует отметить, что результаты выражений (например, вызов функции) автоматически ссылки rvalue, поэтому вы можете использовать семантику перемещения в этих случаях без изменения кода.

чтобы определить оптимизацию перемещения, необходимо определить конструктор перемещения и оператор назначения перемещения:

T::T(T&&);
T& operator=(T&&);

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

вывод

это, по сути, все, что нужно. Обратите внимание, что ссылки rvalue также используются для идеальной пересылки в C++0x (из-за специально созданных системных взаимодействий типов между ссылками rvalue и другими типами), но это не связано с семантикой перемещения, поэтому я не обсуждал это здесь.