В чем обоснование для операторов присваивания нестандартных операций назначения в стандартной библиотеке?

Question

Стандартная политика библиотеки относительно назначения перемещения заключается в том, что the implementation is allowed to assume that self-assignment will never happen; это кажется мне очень плохой идеей, учитывая, что:

• «обычный» («копировать») договор назначения на C++ всегда считался безопасным с самоналожением; теперь у нас есть еще один некогерентный угловой случай C++, чтобы помнить и объяснять - и тоже очень опасный; Я думаю, мы все согласны с тем, что в C++ требуется не больше скрытых ловушек;
• это усложняет алгоритмы - все в семье remove_if необходимо позаботиться об этом угловом корпусе;
• было бы очень легко выполнить это требование - там, где вы реализуете перемещение с заменой, оно приходит бесплатно, и даже в других случаях (где вы можете получить повышение производительности с помощью ad-hoc-логики) это просто сингл (почти) никогда не брали ветку, которая практически свободна на любом CPU¹; также в большинстве интересных случаев (перемещение с параметрами или локалями) ветвь будет полностью удаляться оптимизатором при вставке (что должно происходить почти всегда для «простых» операторов присваивания перемещения).

Итак, почему такое решение?

---

¹ Особенно в коде библиотеки, где исполнители могут свободно эксплуатировать компилятор конкретных намеков на «ветвь Ожидаемого результата» (думает, что в НКУ __builtin_expect/__assume в VC++).

Answer 1

Предполагается, что из объектов в std отбрасываются или назначаются до их повторного использования. Ничего, который не является полностью бесплатным, кроме того, что не обещано.

Иногда вещи бесплатны. Как контейнер, построенный с помощью перемещения, пуст. Обратите внимание, что некоторые случаи, связанные с перемещением, не имеют такой гарантии, поскольку некоторые реализации могут выбирать перемещение элементов вместо буферов. Почему разница? Одна из них была бесплатной дополнительной гарантией, а другая - нет.

Ветвь или другая проверка не является полностью бесплатной. Он занимает слот предсказания ветвления, и даже если предсказано просто почти бесплатно.

Кроме того, a = std::move(a); является доказательством логической ошибки. Назначение - от a (в пределах std) означает, что вы будете назначать или отменять a. Но здесь вы хотите, чтобы у него было определенное состояние на следующей строке. Либо вы знаете, что вы самонастраиваетесь, либо нет. Если вы этого не сделаете, вы теперь переходите с объекта, который вы также заселяете, и вы этого не знаете.

Принцип «делайте немного вещей, чтобы держать вещи в безопасности» сталкивается с «вы не платите за то, что вы не используете». В этом случае вторая выиграла.

Answer 2

Yakk gives a very good answer (как обычно и одобрен), но на этот раз я хотел добавить немного больше информации.

В течение последних полувеков политика по самообучению значительно изменилась. Мы недавно выяснили этот угловой случай в LWG 2468. На самом деле, я должен уточнить: неофициальная группа между совещаниями согласилась с решением этой проблемы, и она, вероятно, будет проголосована в рабочий проект C++ 1z в следующем месяце (ноябрь 2016 года).

Суть проблемы заключается в изменении требований MoveAssignable, чтобы уточнить, что если цель и источник назначения перемещения являются одним и тем же объектом, тогда нет требований к значению объекта после назначения (за исключением того, что оно должно быть действительным состоянием). Далее уточняется, что если этот объект используется с std :: lib, он должен все еще отвечать требованиям алгоритма (например, LessThanComparable) независимо от того, назначен ли он или нет, он назначен или назначен для самозапуска.

Итак ...

T x, y; 
x = std::move(y); // The value of y is unspecified and x == the old y 
x = std::move(x); // The value of x is unspecified 

Но оба x и y все еще находятся в допустимых состояниях. Произошла утечка памяти. Не было обнаружено неопределенного поведения.

Обоснование этой позиции

Это еще производительность. Однако признано, что swap(x, x) является законным с C++ 98 и происходит в дикой природе. Кроме того, поскольку 11 swap(x, x) С ++ выполняет самотестирование задание на перемещение x:

T temp = std::move(x); 
x = std::move(x); 
x = std::move(temp); 

До C++ 11, swap(x, x) был (довольно дорого) нет-оп (используя копию вместо хода). LWG 2468 разъясняет, что с C++ 11 и после swap(x, x) по-прежнему (не так дорого) no-op (с использованием перемещения вместо копирования).

Деталь:

T temp = std::move(x); 
// temp now has the value of the original x, and x's value is unspecified 
x = std::move(x); 
// x's value is still unspecified 
x = std::move(temp); 
// x's value now has the value of temp, which is also the original x value 

Для выполнения этого не-оп, само-движения-задания на x может делать все, что он хочет, пока он оставляет x в допустимом состоянии без утверждения или бросать исключение ,

Если вы хотите указать, что для вашего типа T self-move-assign - это не-op, это прекрасно. Std :: lib делает именно это для unique_ptr.

Если вы хотите указать, что для вашего типа U self-move-assign оставляет его в допустимом, но неуказанном состоянии, это тоже нормально. Std :: lib делает именно это для vector. Некоторые реализации (я считаю, VS) идут на труд, чтобы сделать самовозбуждение-присвоение на vector no-op. Другим нет (например, libC++).