Когда сделать тип неподвижным в C ++ 11?

Краткий ответ: если тип копируемый, он также должен быть перемещаемым. Однако обратное неверно: некоторые типы, такие как std::unique_ptr подвижны, но копировать их не имеет смысла; это, естественно, только для перемещения типов.

Чуть более длинный ответ следует …

Есть два основных типа типов (среди других более специализированных, таких как черты):

1. Типы типа значения, такие как int или же vector<widget>, Они представляют собой значения и, естественно, должны быть копируемыми. В C ++ 11, как правило, вы должны думать о перемещении как об оптимизации копии, и поэтому все копируемые типы, естественно, должны быть перемещаемыми … перемещение — это всего лишь эффективный способ сделать копию в часто встречающемся случае, который вы не делаете. Тебе больше не нужен оригинальный объект, и он все равно собирается его уничтожить.

2. Подобные ссылкам типы, которые существуют в иерархиях наследования, такие как базовые классы и классы с виртуальными или защищенными функциями-членами. Они обычно хранятся с помощью указателя или ссылки, часто base* или же base&и так не предоставляют конструкцию копирования, чтобы избежать нарезки; если вы хотите получить другой объект, такой же, как существующий, вы обычно вызываете виртуальную функцию clone, Они не нуждаются в построении перемещения или назначении по двум причинам: они не копируются, и у них уже есть еще более эффективная естественная операция перемещения — вы просто копируете / перемещаете указатель на объект, а сам объект не делает придется перейти на новое место в памяти вообще.

Большинство типов попадают в одну из этих двух категорий, но есть и другие типы типов, которые также полезны, но встречаются реже. В частности, здесь типы, которые выражают уникальное право собственности на ресурс, такие как std::unique_ptr, являются, естественно, только перемещаемыми типами, потому что они не имеют значения (не имеет смысла копировать их), но вы используете их напрямую (не всегда по указателю или по ссылке) и поэтому хотите перемещать объекты этого типа вокруг из одного места в другое.

На самом деле, когда я искал, я обнаружил, что некоторые типы в C ++ 11 не являются подвижными:

• все mutex типы (recursive_mutex , timed_mutex, recursive_timed_mutex,
• condition_variable
• type_info
• error_category
• locale::facet
• random_device
• seed_seq
• ios_base
• basic_istream<charT,traits>::sentry
• basic_ostream<charT,traits>::sentry
• все atomic типы
• once_flag

По-видимому, есть дискуссия о Clang: https://groups.google.com/forum/?fromgroups=#!topic/comp.std.c++/pCO1Qqb3Xa4

Еще одна причина, которую я нашел — производительность.
Скажем, у вас есть класс «а», который содержит значение.
Вы хотите вывести интерфейс, который позволяет пользователю изменять значение в течение ограниченного времени (для области).

Один из способов добиться этого — вернуть объект ‘scope guard’ из ‘a’, который возвращает значение в своем деструкторе, например, так:

class a
{
int value = 0;

public:

struct change_value_guard
{
friend a;
private:
change_value_guard(a& owner, int value)
: owner{ owner }
{
owner.value = value;
}
change_value_guard(change_value_guard&&) = delete;
change_value_guard(const change_value_guard&) = delete;
public:
~change_value_guard()
{
owner.value = 0;
}
private:
a& owner;
};

change_value_guard changeValue(int newValue)
{
return{ *this, newValue };
}
};

int main()
{
a a;
{
auto guard = a.changeValue(2);
}
}

Если бы я сделал change_value_guard перемещаемым, мне пришлось бы добавить ‘if’ к его деструктору, который бы проверял, был ли удален охранник — это дополнительное if и влияние на производительность.

Да, конечно, он может быть оптимизирован любым здравомыслящим оптимизатором, но все-таки приятно, что язык (для этого требуется C ++ 17, хотя для возможности возврата неподвижного типа требуется гарантированное исключение копирования) не требует от нас заплатить это, если мы не собираемся перемещать охрану в любом случае, кроме как вернуть его из функции создания (принцип dont-pay-for-what-you-dont-use).