Что такое семантика перемещения?
Я только что закончил слушать радио- интервью подкаста Software Engineering со Скоттом Мейерсом о C++0x. Большинство новых функций имело смысл для меня, и сейчас я на самом деле рад C++0x, за исключением одного. Я до сих пор не понимаю семантику перемещения... Что это такое?
13 ответов
Мне проще понять семантику перемещения с помощью примера кода. Давайте начнем с очень простого строкового класса, который содержит только указатель на выделенный в куче блок памяти:
#include <cstring>
#include <algorithm>
class string
{
char* data;
public:
string(const char* p)
{
size_t size = strlen(p) + 1;
data = new char[size];
memcpy(data, p, size);
}
Поскольку мы решили сами управлять памятью, нам нужно следовать правилу трех. Я собираюсь отложить написание оператора присваивания и пока реализовать только деструктор и конструктор копирования:
~string()
{
delete[] data;
}
string(const string& that)
{
size_t size = strlen(that.data) + 1;
data = new char[size];
memcpy(data, that.data, size);
}
Конструктор копирования определяет, что значит копировать строковые объекты. Параметр const string& that привязывается ко всем выражениям типа string, что позволяет вам делать копии в следующих примерах:
string a(x); // Line 1
string b(x + y); // Line 2
string c(some_function_returning_a_string()); // Line 3
Теперь приходит ключ к пониманию семантики перемещения. Обратите внимание, что только в первой строке, куда мы копируем x действительно ли эта глубокая копия необходима, потому что мы можем захотеть проверить x позже и будет очень удивлен, если x как-то изменился. Вы заметили, как я только что сказал x три раза (четыре раза, если включить это предложение) и каждый раз имел в виду один и тот же объект? Мы называем такие выражения, как x "lvalues".
Аргументы в строках 2 и 3 - это не lvalues, а rvalues, потому что нижележащие строковые объекты не имеют имен, поэтому у клиента нет возможности проверить их снова в более поздний момент времени. Значения r обозначают временные объекты, которые уничтожаются в следующей точке с запятой (точнее: в конце полного выражения, которое лексически содержит значение r). Это важно, потому что во время инициализации b а также cмы могли делать все, что хотели с исходной строкой, и клиент не мог сказать разницу!
В C++0x появился новый механизм, называемый "ссылкой на rvalue", который, помимо прочего, позволяет обнаруживать аргументы rvalue через перегрузку функций. Все, что нам нужно сделать, это написать конструктор со ссылочным параметром rvalue. Внутри этого конструктора мы можем делать с источником все, что захотим, при условии, что мы оставляем его в каком-то допустимом состоянии
string(string&& that) // string&& is an rvalue reference to a string
{
data = that.data;
that.data = nullptr;
}
Что мы здесь сделали? Вместо глубокого копирования данных кучи, мы просто скопировали указатель, а затем установили исходный указатель на ноль. По сути, мы "украли" данные, которые изначально принадлежали исходной строке. Опять же, ключевой момент заключается в том, что ни при каких обстоятельствах клиент не может обнаружить, что источник был изменен. Поскольку мы на самом деле не делаем здесь копию, мы называем этот конструктор "конструктором перемещения". Его работа заключается в перемещении ресурсов из одного объекта в другой вместо их копирования.
Поздравляем, теперь вы понимаете основы семантики перемещения! Давайте продолжим, реализовав оператор присваивания. Если вы не знакомы с идиомой копирования и обмена, изучите ее и возвращайтесь, потому что это потрясающая идиома C++, связанная с безопасностью исключений.
string& operator=(string that)
{
std::swap(data, that.data);
return *this;
}
};
Да это все? "Где ссылка? Вы можете спросить. "Нам здесь не нужно!" мой ответ:)
Обратите внимание, что мы передаем параметр that по значению, так that должен быть инициализирован, как и любой другой строковый объект. Как именно that будет инициализирован? В старые времена C++98 ответом был бы "конструктор копирования". В C++0x компилятор выбирает между конструктором копирования и конструктором перемещения в зависимости от того, является ли аргумент оператора присваивания lvalue или rvalue.
Так что, если вы скажете a = b, конструктор копирования будет инициализирован that (потому что выражение b является lvalue), и оператор присваивания заменяет содержимое только что созданной глубокой копией. Это само определение копии и идиома замены - создайте копию, обменяйте содержимое копией, а затем избавьтесь от копии, покинув область действия. Здесь нет ничего нового.
Но если вы скажете a = x + y, конструктор перемещения будет инициализирован that (потому что выражение x + y это значение), так что здесь нет глубокого копирования, только эффективный ход.that все еще является независимым объектом от аргумента, но его конструкция была тривиальной, так как данные кучи не нужно было копировать, просто перемещать. Не было необходимости копировать его, потому что x + y является rvalue, и опять же, это нормально, чтобы перейти от строковых объектов, обозначенных rvalue.
Подводя итог, конструктор копирования делает глубокую копию, потому что источник должен оставаться нетронутым. С другой стороны, конструктор перемещения может просто скопировать указатель и затем установить нулевой указатель в источнике. Таким способом можно "обнулить" исходный объект, потому что у клиента нет способа снова проверить объект.
Я надеюсь, что этот пример объяснил главное. Существует намного больше, чтобы ценить ссылки и перемещать семантику, которую я намеренно оставил для простоты. Если вы хотите получить более подробную информацию, см. Мой дополнительный ответ.
Моим первым ответом было предельно упрощенное введение в перемещение семантики, и многие детали были упущены с целью упростить его. Тем не менее, есть еще много чего изменить семантику, и я подумал, что пришло время для второго ответа, чтобы заполнить пробелы. Первый ответ уже довольно старый, и было бы неправильно просто заменить его совершенно другим текстом. Я думаю, что это все еще служит хорошим введением. Но если вы хотите копать глубже, читайте дальше:)
Стефан Т. Лававей не пожалел времени и предоставил ценные отзывы. Большое спасибо, Стефан!
Вступление
Семантика перемещения позволяет объекту при определенных условиях вступать во владение внешними ресурсами какого-либо другого объекта. Это важно двумя способами:
Превращение дорогих копий в дешевые ходы. Смотрите мой первый ответ для примера. Обратите внимание, что если объект не управляет хотя бы одним внешним ресурсом (напрямую или косвенно через свои объекты-члены), семантика перемещения не даст никаких преимуществ по сравнению с семантикой копирования. В этом случае копирование объекта и перемещение объекта означают одно и то же:
class cannot_benefit_from_move_semantics { int a; // moving an int means copying an int float b; // moving a float means copying a float double c; // moving a double means copying a double char d[64]; // moving a char array means copying a char array // ... };Реализация безопасных типов "только для перемещения"; то есть типы, для которых копирование не имеет смысла, но перемещение имеет смысл. Примеры включают в себя блокировки, файловые дескрипторы и интеллектуальные указатели с уникальной семантикой владения. Примечание: этот ответ обсуждает
std::auto_ptrустаревший шаблон стандартной библиотеки C++98, который был заменен наstd::unique_ptrв C++11. Программисты среднего уровня C++, вероятно, хотя бы немного знакомы сstd::auto_ptrи из-за отображаемой "семантики перемещения" она кажется хорошей отправной точкой для обсуждения семантики перемещения в C++11. YMMV.
Что такое ход?
Стандартная библиотека C++98 предлагает интеллектуальный указатель с уникальной семантикой владения, называемой std::auto_ptr<T>, Если вы не знакомы с auto_ptr, его цель состоит в том, чтобы гарантировать, что динамически размещенный объект всегда освобождается, даже несмотря на исключения:
{
std::auto_ptr<Shape> a(new Triangle);
// ...
// arbitrary code, could throw exceptions
// ...
} // <--- when a goes out of scope, the triangle is deleted automatically
Необычная вещь о auto_ptr это его "копирующее" поведение:
auto_ptr<Shape> a(new Triangle);
+---------------+
| triangle data |
+---------------+
^
|
|
|
+-----|---+
| +-|-+ |
a | p | | | |
| +---+ |
+---------+
auto_ptr<Shape> b(a);
+---------------+
| triangle data |
+---------------+
^
|
+----------------------+
|
+---------+ +-----|---+
| +---+ | | +-|-+ |
a | p | | | b | p | | | |
| +---+ | | +---+ |
+---------+ +---------+
Обратите внимание, как инициализация b с a не копирует треугольник, а передает право собственности на треугольник от a в b, Мы также говоримa перемещается в b"или" треугольник перемещен из a в b"Это может показаться странным, потому что сам треугольник всегда остается в памяти на одном и том же месте.
Переместить объект означает передать право собственности на некоторый ресурс, которым он управляет, на другой объект.
Копирующий конструктор auto_ptr вероятно выглядит примерно так (несколько упрощенно):
auto_ptr(auto_ptr& source) // note the missing const
{
p = source.p;
source.p = 0; // now the source no longer owns the object
}
Опасные и безобидные ходы
Опасная вещь о auto_ptr это то, что синтаксически выглядит как копия на самом деле движение. Попытка вызова функции-члена на удаленном auto_ptr вызовет неопределенное поведение, поэтому вы должны быть очень осторожны, чтобы не использовать auto_ptr после того, как оно было перемещено из:
auto_ptr<Shape> a(new Triangle); // create triangle
auto_ptr<Shape> b(a); // move a into b
double area = a->area(); // undefined behavior
Но auto_ptr не всегда опасно Заводские функции - прекрасный вариант использования auto_ptr:
auto_ptr<Shape> make_triangle()
{
return auto_ptr<Shape>(new Triangle);
}
auto_ptr<Shape> c(make_triangle()); // move temporary into c
double area = make_triangle()->area(); // perfectly safe
Обратите внимание, что оба примера следуют одному и тому же синтаксическому шаблону:
auto_ptr<Shape> variable(expression);
double area = expression->area();
И все же один из них вызывает неопределенное поведение, а другой - нет. Так в чем же разница между выражениями a а также make_triangle()? Разве они не одного типа? На самом деле они есть, но у них есть разные ценностные категории.
Ценовые категории
Очевидно, между выражением должно быть какое-то глубокое различие a который обозначает auto_ptr переменная и выражение make_triangle() который обозначает вызов функции, которая возвращает auto_ptr по стоимости, таким образом создавая свежий временный auto_ptr объект каждый раз, когда это называется. a является примером lvalue, тогда как make_triangle() это пример rvalue.
Перемещение от lvalues, таких как a опасно, потому что мы могли бы позже попытаться вызвать функцию-член через aвызывая неопределенное поведение. С другой стороны, переходя от таких значений, как make_triangle() совершенно безопасен, потому что после того, как конструктор копирования выполнил свою работу, мы не можем снова использовать временный. Нет выражения, обозначающего указанное временное; если мы просто напишем make_triangle() опять мы получаем другое временное. Фактически, перемещенный из временного уже ушел в следующую строку:
auto_ptr<Shape> c(make_triangle());
^ the moved-from temporary dies right here
Обратите внимание, что буквы l а также r имеют историческое происхождение в левой и правой части задания. Это больше не верно в C++, потому что есть l-значения, которые не могут появляться в левой части присваивания (например, массивы или пользовательские типы без оператора присваивания), и есть r-значения, которые могут (все r-значения типов классов). с оператором присваивания).
Значение класса - это выражение, оценка которого создает временный объект. При нормальных обстоятельствах никакое другое выражение внутри той же области не обозначает тот же временный объект.
Rvalue ссылки
Теперь мы понимаем, что переход от lvalues потенциально опасен, но переход от rvalues безвреден. Если бы в C++ была языковая поддержка, чтобы отличать аргументы lvalue от аргументов rvalue, мы могли бы либо полностью запретить переход от lvalue, либо, по крайней мере, сделать переход от lvalue явным на сайте вызова, чтобы мы больше не перемещались случайно.
Ответ C++ 11 на эту проблему - rvalue ссылки. Ссылка на rvalue- это новый тип ссылок, который привязывается только к rvalue, а синтаксис X&&, Старая добрая ссылка X& теперь известен как ссылка lvalue. (Обратите внимание, что X&& не является ссылкой на ссылку; в C++ такого нет.)
Если мы бросим const в миксе у нас уже есть четыре разных вида ссылок. Какие виды выражений типа X они могут связываться с?
lvalue const lvalue rvalue const rvalue
---------------------------------------------------------
X& yes
const X& yes yes yes yes
X&& yes
const X&& yes yes
На практике вы можете забыть о const X&&, Ограничение чтения из значений не очень полезно.
Rvalue ссылка
X&&это новый вид ссылок, который привязывается только к rvalues.
Неявные преобразования
Rvalue ссылки прошли через несколько версий. Начиная с версии 2.1, ссылка rvalue X&& также привязывается ко всем категориям значений другого типа Yпри условии неявного преобразования из Y в X, В этом случае временный тип X создан, и ссылка на значение привязана к этому временному:
void some_function(std::string&& r);
some_function("hello world");
В приведенном выше примере "hello world" является lvalue типа const char[12], Так как есть неявное преобразование из const char[12] через const char* в std::stringвременный тип std::string создан, и r связан с этим временным. Это один из случаев, когда различие между значениями (выражениями) и временными значениями (объектами) немного размыто.
Переместить конструкторы
Полезный пример функции с X&& параметр является конструктором перемещения X::X(X&& source), Его целью является передача права собственности на управляемый ресурс из источника в текущий объект.
В C++ 11 std::auto_ptr<T> был заменен std::unique_ptr<T> который использует в качестве ссылки rvalue. Я буду разрабатывать и обсуждать упрощенную версию unique_ptr, Сначала мы инкапсулируем необработанный указатель и перегружаем операторы. -> а также *так что наш класс выглядит как указатель:
template<typename T>
class unique_ptr
{
T* ptr;
public:
T* operator->() const
{
return ptr;
}
T& operator*() const
{
return *ptr;
}
Конструктор становится владельцем объекта, а деструктор удаляет его:
explicit unique_ptr(T* p = nullptr)
{
ptr = p;
}
~unique_ptr()
{
delete ptr;
}
Теперь перейдем к интересной части, конструктору перемещения:
unique_ptr(unique_ptr&& source) // note the rvalue reference
{
ptr = source.ptr;
source.ptr = nullptr;
}
Этот конструктор перемещения делает именно то, что auto_ptr конструктор копирования сделал, но он может быть предоставлен только с rvalues:
unique_ptr<Shape> a(new Triangle);
unique_ptr<Shape> b(a); // error
unique_ptr<Shape> c(make_triangle()); // okay
Вторая строка не компилируется, потому что a является lvalue, но параметр unique_ptr&& source может быть привязан только к значениям. Это именно то, что мы хотели; опасные действия никогда не должны быть скрытыми. Третья строка компилируется просто отлично, потому что make_triangle() это значение. Конструктор перемещения переведет владение из временного объекта в c, Опять же, это именно то, что мы хотели.
Конструктор перемещения передает владение управляемым ресурсом текущему объекту.
Операторы назначения перемещения
Последним недостающим элементом является оператор присваивания перемещения. Его задача - освободить старый ресурс и получить новый ресурс из его аргумента:
unique_ptr& operator=(unique_ptr&& source) // note the rvalue reference
{
if (this != &source) // beware of self-assignment
{
delete ptr; // release the old resource
ptr = source.ptr; // acquire the new resource
source.ptr = nullptr;
}
return *this;
}
};
Обратите внимание, что эта реализация оператора присваивания перемещения дублирует логику как деструктора, так и конструктора перемещения. Вы знакомы с идиомой копирования и обмена? Он также может применяться для перемещения семантики как идиома перемещения и обмена:
unique_ptr& operator=(unique_ptr source) // note the missing reference
{
std::swap(ptr, source.ptr);
return *this;
}
};
Теперь, когда source переменная типа unique_ptr, он будет инициализирован конструктором перемещения; то есть аргумент будет перемещен в параметр. Аргумент все еще должен быть rvalue, потому что сам конструктор перемещения имеет ссылочный параметр rvalue. Когда поток управления достигает закрывающей скобки operator=, source выходит из области видимости, автоматически освобождая старый ресурс.
Оператор назначения перемещения передает владение управляемым ресурсом текущему объекту, освобождая старый ресурс. Идиома перемещения и обмена упрощает реализацию.
Переезд из lvalues
Иногда мы хотим отойти от lvalues. То есть иногда мы хотим, чтобы компилятор обрабатывал lvalue, как если бы он был rvalue, чтобы он мог вызывать конструктор move, даже если он потенциально может быть небезопасным. Для этой цели C++ 11 предлагает стандартный шаблон библиотечной функции под названием std::move внутри заголовка <utility>, Это имя немного неудачно, потому что std::move просто бросает lvalue к rvalue; он ничего не двигает сам по себе. Это просто позволяет двигаться. Может быть, это должно было быть названо std::cast_to_rvalue или же std::enable_move, но мы застряли с именем на данный момент.
Вот как вы явно переходите от lvalue:
unique_ptr<Shape> a(new Triangle);
unique_ptr<Shape> b(a); // still an error
unique_ptr<Shape> c(std::move(a)); // okay
Обратите внимание, что после третьей строки a больше не владеет треугольником. Это нормально, потому что явно std::move(a)Мы четко заявили о своих намерениях: "Дорогой конструктор, делай все, что хочешь с a для того, чтобы инициализировать c; Меня не волнует a больше. Не стесняйтесь, чтобы ваш путь с a".
std::move(some_lvalue)преобразует lvalue в rvalue, что дает возможность последующего перемещения.
Xvalues
Обратите внимание, что даже если std::move(a) является значением, его оценка не создает временный объект. Эта загадка вынудила комитет ввести третью категорию стоимости. То, что может быть связано со ссылкой на rvalue, даже если оно не является rvalue в традиционном смысле, называется xvalue (значение eXpiring). Традиционные значения были переименованы в prvalues (чистые значения).
И prvalues, и xvalues являются rvalues. Значения xvalue и lvalue являются glvalues (Обобщенные lvalue). Отношения легче понять с помощью диаграммы:
expressions
/ \
/ \
/ \
glvalues rvalues
/ \ / \
/ \ / \
/ \ / \
lvalues xvalues prvalues
Обратите внимание, что только значения xval действительно новые; остальное только за счет переименования и группировки.
Значения в C++98 известны как значения в C++11. Мысленно замените все вхождения "rvalue" в предыдущих абзацах на "prvalue".
Выход из функций
До сих пор мы видели движение в локальные переменные и в параметры функции. Но движение также возможно в противоположном направлении. Если функция возвращает значение, некоторый объект на сайте вызова (возможно, локальная переменная или временная, но может быть любой объект) инициализируется выражением после return оператор в качестве аргумента для конструктора перемещения:
unique_ptr<Shape> make_triangle()
{
return unique_ptr<Shape>(new Triangle);
} \-----------------------------/
|
| temporary is moved into c
|
v
unique_ptr<Shape> c(make_triangle());
Возможно, что удивительно, автоматические объекты (локальные переменные, которые не объявлены как static) также может быть неявно удален из функций:
unique_ptr<Shape> make_square()
{
unique_ptr<Shape> result(new Square);
return result; // note the missing std::move
}
Почему конструктор перемещения принимает значение lvalue? result в качестве аргумента? Объем result подходит к концу, и он будет уничтожен во время разматывания стека. После этого никто не мог пожаловаться result как-то изменился; когда поток управления возвращается к вызывающей стороне, result больше не существует! По этой причине в C++ 11 есть специальное правило, которое позволяет автоматически возвращать объекты из функций без необходимости писать std::move, На самом деле, вы никогда не должны использовать std::move перемещать автоматические объекты из функций, так как это запрещает "именованную оптимизацию возвращаемого значения" (NRVO).
Никогда не используйте
std::moveубрать автоматические объекты из функций.
Обратите внимание, что в обеих фабричных функциях тип возвращаемого значения - это значение, а не ссылка на значение. Rvalue-ссылки по-прежнему являются ссылками, и, как всегда, вы никогда не должны возвращать ссылку на автоматический объект; вызывающая сторона получит висячую ссылку, если вы обманом заставите компилятор принять ваш код, например так:
unique_ptr<Shape>&& flawed_attempt() // DO NOT DO THIS!
{
unique_ptr<Shape> very_bad_idea(new Square);
return std::move(very_bad_idea); // WRONG!
}
Никогда не возвращайте автоматические объекты по ссылке. Перемещение выполняется исключительно конструктором перемещения, а не
std::moveи не просто связывая rvalue со ссылкой на rvalue.
Переезд в члены
Рано или поздно вы напишите такой код:
class Foo
{
unique_ptr<Shape> member;
public:
Foo(unique_ptr<Shape>&& parameter)
: member(parameter) // error
{}
};
В основном, компилятор будет жаловаться, что parameter это значение. Если вы посмотрите на его тип, вы увидите ссылку rvalue, но ссылка rvalue просто означает "ссылку, связанную с rvalue"; это не значит, что сама ссылка является ценным! В самом деле, parameter это просто обычная переменная с именем. Ты можешь использовать parameter так часто, как вам нравится внутри тела конструктора, и он всегда обозначает один и тот же объект. Неявное движение от него было бы опасно, следовательно, язык запрещает это.
Именованная ссылка на rvalue- это lvalue, как и любая другая переменная.
Решение состоит в том, чтобы вручную включить перемещение:
class Foo
{
unique_ptr<Shape> member;
public:
Foo(unique_ptr<Shape>&& parameter)
: member(std::move(parameter)) // note the std::move
{}
};
Вы можете утверждать, что parameter больше не используется после инициализации member, Почему нет специального правила для вставки std::move как с возвращаемыми значениями? Вероятно, потому что это будет слишком большой нагрузкой для разработчиков компилятора. Например, что, если тело конструктора было в другом модуле перевода? Напротив, правило возвращаемого значения просто должно проверить таблицы символов, чтобы определить, является ли идентификатор после return Ключевое слово обозначает автоматический объект.
Вы также можете пройти parameter по значению. Для типов только для перемещения, таких как unique_ptrПохоже, пока не существует идиомы. Лично я предпочитаю передавать по значению, так как это вызывает меньше помех в интерфейсе.
Специальные функции-члены
C++98 неявно объявляет три специальные функции-члены по требованию, то есть, когда они где-то нужны: конструктор копирования, оператор присваивания копии и деструктор.
X::X(const X&); // copy constructor
X& X::operator=(const X&); // copy assignment operator
X::~X(); // destructor
Rvalue ссылки прошли через несколько версий. Начиная с версии 3.0, C++11 объявляет две дополнительные специальные функции-члены по требованию: конструктор перемещения и оператор присваивания перемещения. Обратите внимание, что ни VC10, ни VC11 пока не соответствуют версии 3.0, поэтому вам придется реализовать их самостоятельно.
X::X(X&&); // move constructor
X& X::operator=(X&&); // move assignment operator
Эти две новые специальные функции-члены объявляются неявно, только если ни одна из специальных функций-членов не объявляется вручную. Кроме того, если вы объявляете свой собственный конструктор перемещения или оператор присваивания перемещения, ни конструктор копирования, ни оператор присваивания копии не будут объявлены неявно.
Что эти правила означают на практике?
Если вы пишете класс без неуправляемых ресурсов, вам не нужно объявлять какую-либо из пяти специальных функций-членов самостоятельно, и вы получите правильную семантику копирования и бесплатно переместите семантику. В противном случае вам придется самостоятельно выполнять специальные функции-члены. Конечно, если ваш класс не извлекает пользу из семантики перемещения, нет необходимости реализовывать специальные операции перемещения.
Обратите внимание, что оператор присваивания копии и оператор присваивания перемещения могут быть объединены в единый унифицированный оператор присваивания, принимая его аргумент по значению:
X& X::operator=(X source) // unified assignment operator
{
swap(source); // see my first answer for an explanation
return *this;
}
Таким образом, количество специальных функций-членов для реализации уменьшается с пяти до четырех. Здесь есть компромисс между безопасностью исключений и эффективностью, но я не эксперт в этом вопросе.
Пересылка ссылок ( ранее называемых универсальными ссылками)
Рассмотрим следующий шаблон функции:
template<typename T>
void foo(T&&);
Вы можете ожидать T&& привязывать только к rvalue, потому что на первый взгляд это выглядит как ссылка на rvalue. Как оказалось, хотя, T&& также связывается с lvalues:
foo(make_triangle()); // T is unique_ptr<Shape>, T&& is unique_ptr<Shape>&&
unique_ptr<Shape> a(new Triangle);
foo(a); // T is unique_ptr<Shape>&, T&& is unique_ptr<Shape>&
Если аргумент является значением типа X, T выводится Xотсюда T&& средства X&&, Это то, что можно было ожидать. Но если аргумент является lvalue типа Xиз-за особого правила, T выводится X&отсюда T&& будет означать что-то вроде X& &&, Но поскольку в C++ до сих пор нет понятия ссылок на ссылки, тип X& && свернут в X&, Поначалу это может показаться запутанным и бесполезным, но свертывание ссылок необходимо для идеальной пересылки (что здесь не обсуждается).
T && - это не ссылка на значение, а ссылка на пересылку. Он также привязывается к lvalues, в этом случае
Tа такжеT&&обе ссылки lvalue.
Если вы хотите ограничить шаблон функции значениями r, вы можете объединить SFINAE с чертами типа:
#include <type_traits>
template<typename T>
typename std::enable_if<std::is_rvalue_reference<T&&>::value, void>::type
foo(T&&);
Осуществление переезда
Теперь, когда вы понимаете, что ссылки разрушаются, вот как std::move реализовано:
template<typename T>
typename std::remove_reference<T>::type&&
move(T&& t)
{
return static_cast<typename std::remove_reference<T>::type&&>(t);
}
Как вы видете, move принимает любые параметры благодаря ссылке на пересылку T&&и возвращает ссылку на значение. std::remove_reference<T>::type вызов мета-функции необходим, потому что в противном случае для значений типа Xтип возврата будет X& &&который бы рухнул в X&, поскольку t всегда является lvalue (помните, что именованная ссылка rvalue является lvalue), но мы хотим связать t на ссылку Rvalue, мы должны явно привести t к правильному типу возврата. Вызов функции, которая возвращает ссылку на rvalue, сам по себе является xvalue. Теперь вы знаете, откуда взялись xvalues;)
Вызов функции, которая возвращает ссылку на значение, например
std::move, является xvalue.
Обратите внимание, что возвращение по ссылке rvalue в этом примере нормально, потому что t не обозначает автоматический объект, но вместо этого объект, который был передан вызывающей стороной.
Семантика перемещения основана на ссылках rvalue.
Значение r это временный объект, который будет уничтожен в конце выражения. В текущем C++ значения r связаны только с const Рекомендации. C++1x позволит не const Rvalue ссылки, пишется T&&, которые являются ссылками на объекты Rvalue.
Так как значение r умрет в конце выражения, вы можете украсть его данные. Вместо того, чтобы копировать его в другой объект, вы перемещаете в него данные.
class X {
public:
X(X&& rhs) // ctor taking an rvalue reference, so-called move-ctor
: data_()
{
// since 'x' is an rvalue object, we can steal its data
this->swap(std::move(rhs));
// this will leave rhs with the empty data
}
void swap(X&& rhs);
// ...
};
// ...
X f();
X x = f(); // f() returns result as rvalue, so this calls move-ctor
В приведенном выше коде со старыми компиляторами результат f() копируется в x с помощью X Копируй конструктор. Если ваш компилятор поддерживает семантику перемещения и X имеет конструктор перемещения, тогда он вызывается вместо этого. Так как его rhs Аргумент - это значение, мы знаем, что он больше не нужен, и мы можем украсть его значение.
Таким образом, значение перемещается из неназванного временного f() в x (в то время как данные x, инициализируется пустым X, перемещен во временный, который будет уничтожен после назначения).
Предположим, у вас есть функция, которая возвращает существенный объект:
Matrix multiply(const Matrix &a, const Matrix &b);
Когда вы пишете такой код:
Matrix r = multiply(a, b);
тогда обычный компилятор C++ создаст временный объект для результата multiply()вызовите конструктор копирования для инициализации r, а затем уничтожить временное возвращаемое значение. Семантика перемещения в C++0x позволяет вызывать "конструктор перемещения" для инициализации r скопировав его содержимое, а затем отбросив временное значение, не разрушая его.
Это особенно важно, если (как, возможно, Matrix пример выше), копируемый объект выделяет дополнительную память в куче для хранения своего внутреннего представления. Конструктор копирования должен будет либо создать полную копию внутреннего представления, либо использовать семантику подсчета ссылок и копирования при записи. Конструктор перемещения оставил бы память кучи в одиночку и просто скопировал бы указатель внутри Matrix объект.
Семантика перемещения - это передача ресурсов, а не их копирование, когда исходное значение больше никому не нужно.
В C++03 объекты часто копируются, только чтобы быть уничтоженными или присвоенными, прежде чем какой-либо код снова использует это значение. Например, когда вы возвращаете значение по значению из функции, если только RVO не активируется, возвращаемое вами значение копируется в кадр стека вызывающего, а затем выходит из области видимости и уничтожается. Это только один из многих примеров: смотрите передачу по значению, когда исходный объект является временным, алгоритмы, такие как sort что просто переставить предметы, перераспределить в vector когда это capacity() превышен и т. д.
Когда такие пары копирования / уничтожения дороги, это обычно потому, что объекту принадлежит какой-то тяжеловесный ресурс. Например, vector<string> может иметь динамически распределяемый блок памяти, содержащий массив string объекты, каждый со своей динамической памятью. Копирование такого объекта является дорогостоящим: вы должны выделить новую память для каждого динамически распределяемого блока в источнике и скопировать все значения по всему. Затем вам нужно освободить всю эту память, которую вы только что скопировали. Тем не менее, перемещение большого vector<string> означает просто скопировать несколько указателей (которые относятся к блоку динамической памяти) к месту назначения и обнулить их в источнике.
В простых (практических) терминах:
Копирование объекта означает копирование его "статических" членов и вызов new оператор для его динамических объектов. Правильно?
class A
{
int i, *p;
public:
A(const A& a) : i(a.i), p(new int(*a.p)) {}
~A() { delete p; }
};
Однако перемещение объекта (я повторяю, с практической точки зрения) подразумевает только копирование указателей динамических объектов, а не создание новых.
Но разве это не опасно? Конечно, вы можете уничтожить динамический объект дважды (ошибка сегментации). Таким образом, чтобы избежать этого, вы должны "аннулировать" указатели источника, чтобы не уничтожить их дважды:
class A
{
int i, *p;
public:
// Movement of an object inside a copy constructor.
A(const A& a) : i(a.i), p(a.p)
{
a.p = nullptr; // pointer invalidated.
}
~A() { delete p; }
// Deleting NULL, 0 or nullptr (address 0x0) is safe.
};
Хорошо, но если я переместлю объект, исходный объект станет бесполезным, нет? Конечно, но в определенных ситуациях это очень полезно. Наиболее очевидным является случай, когда я вызываю функцию с анонимным объектом (временный, объект rvalue, ..., вы можете вызывать его с разными именами):
void heavyFunction(HeavyType());
В этой ситуации анонимный объект создается, затем копируется в параметр функции, а затем удаляется. Итак, здесь лучше перемещать объект, потому что вам не нужен анонимный объект и вы можете сэкономить время и память.
Это приводит к понятию "rvalue" ссылка. Они существуют в C++11 только для определения, является ли полученный объект анонимным или нет. Я думаю, вы уже знаете, что "lvalue" является присваиваемой сущностью (левая часть = оператор), поэтому вам нужна именованная ссылка на объект, чтобы иметь возможность выступать в качестве lvalue. Значение r с точностью до наоборот, объект без именованных ссылок. Из-за этого анонимный объект и rvalue являются синонимами. Так:
class A
{
int i, *p;
public:
// Copy
A(const A& a) : i(a.i), p(new int(*a.p)) {}
// Movement (&& means "rvalue reference to")
A(A&& a) : i(a.i), p(a.p)
{
a.p = nullptr;
}
~A() { delete p; }
};
В этом случае, когда объект типа A должен быть "скопирован", компилятор создает ссылку lvalue или ссылку rvalue в зависимости от того, назван переданный объект или нет. Если нет, вызывается ваш конструктор перемещения, и вы знаете, что объект является временным, и вы можете перемещать его динамические объекты вместо их копирования, экономя место и память.
Важно помнить, что "статические" объекты всегда копируются. Нет способов "переместить" статический объект (объект в стек, а не в кучу). Таким образом, различие "перемещение"/ "копирование", когда объект не имеет динамических членов (прямо или косвенно), не имеет значения.
Если ваш объект сложный и деструктор имеет другие вторичные эффекты, такие как вызов функции библиотеки, вызов других глобальных функций или что бы то ни было, возможно, лучше сигнализировать о движении с флагом:
class Heavy
{
bool b_moved;
// staff
public:
A(const A& a) { /* definition */ }
A(A&& a) : // initialization list
{
a.b_moved = true;
}
~A() { if (!b_moved) /* destruct object */ }
};
Итак, ваш код короче (вам не нужно делать nullptr назначение для каждого динамического члена) и более общие.
Другой типичный вопрос: в чем разница между A&& а также const A&&? Конечно, в первом случае вы можете изменить объект, а во втором нет, но практический смысл? Во втором случае вы не можете изменить его, поэтому у вас нет способов сделать объект недействительным (кроме как с изменяемым флагом или чем-то в этом роде), и нет никакого практического различия в конструкторе копирования.
А что такое идеальная пересылка? Важно знать, что "ссылка на значение" является ссылкой на именованный объект в "области действия вызывающего". Но в реальной области действия ссылка на rvalue является именем объекта, поэтому она действует как именованный объект. Если вы передаете ссылку на rvalue другой функции, вы передаете именованный объект, поэтому объект не воспринимается как временный объект.
void some_function(A&& a)
{
other_function(a);
}
Предмет a будет скопирован в фактический параметр other_function, Если вы хотите объект a продолжает рассматриваться как временный объект, вы должны использовать std::move функция:
other_function(std::move(a));
С этой линией std::move бросит a к значению и other_function получит объект как неназванный объект. Конечно, если other_function не имеет специфической перегрузки для работы с неназванными объектами, это различие не важно.
Это идеальная пересылка? Нет, но мы очень близки. Идеальная пересылка полезна только для работы с шаблонами, с целью сказать: если мне нужно передать объект в другую функцию, мне нужно, чтобы, если я получил именованный объект, объект был передан как именованный объект, а когда нет, Я хочу передать его как безымянный объект:
template<typename T>
void some_function(T&& a)
{
other_function(std::forward<T>(a));
}
Это сигнатура прототипной функции, которая использует совершенную пересылку, реализованную в C++11 посредством std::forward, Эта функция использует некоторые правила создания шаблона:
`A& && == A&`
`A&& && == A&&`
Так что если T это lvalue ссылка на A (T = A &), a также (A & && => A &). Если T Rvalue ссылка на A, a также (A&& && => A&&). В обоих случаях, a является именованным объектом в реальной области видимости, но T содержит информацию о своем "ссылочном типе" с точки зрения вызывающей стороны. Эта информация (T) передается в качестве параметра шаблона forward и "а" перемещается или нет в зависимости от типа T,
Если вы действительно заинтересованы в хорошем, глубоком объяснении семантики перемещения, я настоятельно рекомендую прочитать оригинальную статью о них, "Предложение добавить поддержку семантики перемещения в язык C++".
Это очень доступно и легко читается, и это превосходное доказательство преимуществ, которые они предлагают. На веб-сайте WG21 есть и другие, более свежие и актуальные статьи о семантике перемещения, но эта, пожалуй, самая прямолинейная, так как она подходит к вещам с точки зрения верхнего уровня и не вдавается в подробности языка.
Это похоже на семантику копирования, но вместо того, чтобы дублировать все данные, которые вы получаете, чтобы украсть данные из "перемещаемого" объекта.
Вы знаете, что означает семантика копирования? это означает, что у вас есть типы, которые можно копировать, для пользовательских типов, которые вы определяете, это либо покупайте явно написав конструктор копирования и оператор присваивания, либо компилятор генерирует их неявно. Это сделает копию.
Семантика перемещения - это в основном пользовательский тип с конструктором, который принимает ссылку на r-значение (новый тип ссылки с использованием && (да, два амперсанда)), который не является константным, это называется конструктором перемещения, то же самое относится и к оператору присваивания. Так что же делает конструктор перемещения, вместо того, чтобы копировать память из аргумента источника, он "перемещает" память из источника в место назначения.
Когда бы вы хотели это сделать? Например, std::vector - это, скажем, вы создали временный std::vector и возвращаете его из функции, например:
std::vector<foo> get_foos();
При возврате из функции вы получите служебные данные от конструктора копирования, если (и это будет в C++0x) std::vector имеет конструктор перемещения вместо того, чтобы копировать его, просто установив указатели и динамически расположив 'move' память на новый экземпляр. Это похоже на семантику передачи права собственности с помощью std::auto_ptr.
Я пишу это, чтобы убедиться, что я правильно понимаю.
Семантика перемещения была создана, чтобы избежать ненужного копирования больших объектов. Бьярн Страуструп в своей книге "Язык программирования C++" использует два примера, где по умолчанию происходит ненужное копирование: один - обмен двух больших объектов и два - возврат большого объекта из метода.
Замена двух больших объектов обычно включает копирование первого объекта во временный объект, копирование второго объекта в первый объект и копирование временного объекта во второй объект. Для встроенного типа это очень быстро, но для больших объектов эти три копии могут занять много времени. "Назначение перемещения" позволяет программисту переопределить поведение копирования по умолчанию и вместо этого поменять местами ссылки на объекты, что означает, что копирование вообще не выполняется и операция подкачки выполняется намного быстрее. Назначение перемещения может быть вызвано путем вызова метода std::move().
Возврат объекта из метода по умолчанию включает в себя создание копии локального объекта и связанных с ним данных в месте, доступном для вызывающей стороны (поскольку локальный объект недоступен для вызывающей стороны и исчезает после завершения метода). Когда возвращается встроенный тип, эта операция выполняется очень быстро, но если возвращается большой объект, это может занять много времени. Конструктор перемещения позволяет программисту переопределить это поведение по умолчанию и вместо этого "повторно" использовать данные кучи, связанные с локальным объектом, указав объекту, возвращаемому вызывающей стороне, для кучи данных, связанных с локальным объектом. Таким образом, копирование не требуется.
В языках, которые не позволяют создавать локальные объекты (то есть объекты в стеке), эти типы проблем не возникают, поскольку все объекты размещаются в куче и всегда доступны по ссылке.
Чтобы проиллюстрировать необходимость семантики перемещения, давайте рассмотрим этот пример без семантики перемещения:
Вот функция, которая принимает объект типа T и возвращает объект того же типа T:
T f(T o) { return o; }
//^^^ new object constructed
Вышеупомянутая функция использует вызов по значению, что означает, что когда эта функция вызывается, объект должен быть создан для использования функцией.
Поскольку функция также возвращает значение, для нового значения создается другой новый объект:
T b = f(a);
//^ new object constructed
Два новых объекта были построены, один из которых является временным объектом, который используется только на время выполнения функции.
Когда новый объект создается из возвращаемого значения, вызывается конструктор копирования, чтобы скопировать содержимое временного объекта в новый объект b. После завершения функции временный объект, используемый в функции, выходит из области видимости и уничтожается.
Теперь давайте рассмотрим, что делает конструктор копирования.
Сначала необходимо инициализировать объект, а затем скопировать все соответствующие данные из старого объекта в новый.
В зависимости от класса, может быть это контейнер с очень большим количеством данных, тогда это может представлять много времени и использования памяти
// Copy constructor
T::T(T &old) {
copy_data(m_a, old.m_a);
copy_data(m_b, old.m_b);
copy_data(m_c, old.m_c);
}
С семантикой перемещения теперь можно сделать большую часть этой работы менее неприятной, просто перемещая данные, а не копируя.
// Move constructor
T::T(T &&old) noexcept {
m_a = std::move(old.m_a);
m_b = std::move(old.m_b);
m_c = std::move(old.m_c);
}
Перемещение данных включает в себя повторное связывание данных с новым объектом. И никакой копии не происходит вообще.
Это достигается с помощью rvalue ссылка.
rvalue ссылка работает в значительной степени как lvalue ссылка с одним важным отличием:
Ссылка rvalue может быть перемещена, а lvalue - нет.
Чтобы сделать возможным строгое исключение, пользовательские конструкторы перемещения не должны генерировать исключения. Фактически, стандартные контейнеры обычно используют std::move_if_noexcept для выбора между перемещением и копированием, когда необходимо перемещать элементы контейнера. Если предусмотрены конструкторы копирования и перемещения, разрешение перегрузки выбирает конструктор перемещения, если аргумент является значением rvalue (либо prvalue, например, безымянное временное значение, либо xvalue, например, результат std::move), и выбирает конструктор копирования, если аргумент является lvalue (именованный объект или функция / оператор, возвращающий ссылку на lvalue). Если предоставляется только конструктор копирования, все категории аргументов выбирают его (при условии, что он принимает ссылку на const, поскольку rvalues может связываться с ссылками на const), что делает копирование запасного варианта для перемещения, когда перемещение недоступно. Во многих ситуациях конструкторы перемещения оптимизируются, даже если они будут вызывать наблюдаемые побочные эффекты, см. Раздел "Разрешение копирования". Конструктор называется "конструктором перемещения", когда он принимает ссылку на значение в качестве параметра. Он не обязан что-либо перемещать, класс не обязан иметь ресурс для перемещения, и "конструктор перемещения" может не иметь возможности перемещать ресурс, как в допустимом (но, возможно, нецелесообразном) случае, когда параметр является ссылка на постоянное значение (const T&&).
Я просто хотел добавить этот комментарий для отчаявшихся людей.
Вы можете наблюдать следующую запутанную ситуацию:
Вы создаете все причудливые конструкторы перемещения для класса Matrix. Затем вы создаете оператор + для двух матриц. Тогда вы звоните
Matrix m = a + b;
... и ничего из этого хорошего (конструктор перемещения) не вызывается. Хотя (a+b) временно! Но если ты позвонишь
Matrix m = std::move(a+b);
Это называется. И если вы не пишете конструкторы перемещения или копирования, это тоже нормально. Но почему?
Дело в том, что вы просто еще не слышали всей истории.
Во-первых, конструктор перемещения очень часто оптимизируется. Чтобы отключить это, вы можете написать
-no-elide-constructors
как флаг компилятора, просто чтобы увидеть, действительно ли он вызван. Однако не делайте этого с производственным кодом. Компилятор знает, что он может оптимизировать, а что нет. Хотя это может привести к путанице. В Visual Studio Code флаг устанавливается через некоторый файл json, чтобы вам не приходилось писать его в командной строке.
Во-вторых, компилятор также может автоматически сгенерировать конструкторы перемещения и копирования. Компилятор иногда делает больше, чем вы можете себе представить, будучи новичком! Вот почему код все еще работает, например, после того, как вы в отчаянии решили удалить все свои конструкторы.
Вот ответ из книги Бьярна Страуструпа "Язык программирования C++". Если вы не хотите смотреть видео, вы можете увидеть текст ниже:
Рассмотрим этот фрагмент. Возврат из оператора + предполагает копирование результата из локальной переменнойres и в то место, где вызывающий может получить к нему доступ.
Vector operator+(const Vector& a, const Vector& b)
{
if (a.size()!=b.size())
throw Vector_siz e_mismatch{};
Vector res(a.size());
for (int i=0; i!=a.size(); ++i)
res[i]=a[i]+b[i];
return res;
}
Нам действительно не нужна была копия; мы просто хотели получить результат из функции. Поэтому нам нужно переместить вектор, а не копировать его. Мы можем определить конструктор перемещения следующим образом:
class Vector {
// ...
Vector(const Vector& a); // copy constructor
Vector& operator=(const Vector& a); // copy assignment
Vector(Vector&& a); // move constructor
Vector& operator=(Vector&& a); // move assignment
};
Vector::Vector(Vector&& a)
:elem{a.elem}, // "grab the elements" from a
sz{a.sz}
{
a.elem = nullptr; // now a has no elements
a.sz = 0;
}
&& означает "ссылку на rvalue" и является ссылкой, к которой мы можем привязать rvalue. "rvalue" 'предназначено для дополнения "lvalue", что примерно означает "что-то, что может появиться в левой части присваивания". Таким образом, rvalue означает примерно "значение, которое вы не можете присвоить", такое как целое число, возвращаемое вызовом функции, аres локальная переменная в operator+() для векторов.
Теперь заявление return res; копировать не буду!