Руководство по деструктивной семантике перемещения в C++26

C++26 не вводит разрушительную семантику перемещения, но вводит тривиальную перемещаемость через предложение P2786, которое предоставляет функциональность, аналогичную описанной вами trivially_relocate_at. Хотя это позволяет перемещать объекты без вызова деструкторов для исходного объекта, это принципиально отличается от истинной разрушительной семантики перемещения, как в Rust.

Содержание

• Что на самом деле вводит C++26
• Понимание trivially_relocate_at
• Текущие ограничения C++
• Реализация перемещения в текущем C++
• Статическая передача владения и семантика, похожая на Rust
• Необходимые языковые функции для истинных разрушительных перемещений
• Практическое применение и варианты использования

Что на самом деле вводит C++26

C++26 вводит тривиальную перемещаемость через предложение P2786, а не разрушительную семантику перемещения. Согласно официальному документу P2786R13, эта функция определяет типы, которые можно безопасно перемещать в памяти с помощью побитовых операций без вызова их деструкторов.

Ключевая идея из документа заключается в том, что “Типы без пользовательских специальных функций-членов определяются как тривиально перемещаемые на основе того, являются ли их базовые классы и нестатические члены данных тривиально перемещаемыми”. Это означает, что компилятор может автоматически определять, какие типы можно безопасно перемещать.

В отличие от разрушительной семантики перемещения (которая полностью уничтожала бы исходный объект), тривиальная перемещаемость в C++26 обеспечивает более безопасный и контролируемый механизм перемещения объектов, который сохраняет некоторый уровень допустимости объекта, позволяя выполнять эффективные операции с памятью.

Понимание trivially_relocate_at

Сигнатура функции trivially_relocate_at, которую вы упомянули, действительно является частью предложения C++26:

template <class T>
T* trivially_relocate_at(T* dst, T* src);

Согласно предложению P2786, эта функция будет:

1. Перемещать-конструировать объект в dst из объекта в src
2. Уничтожать объект в src
3. Возвращать dst

Однако, как вы правильно заметили, эта сигнатура не явно выражает разрушительный характер операции. Функция эффективно выполняет разрушительное перемещение - она передает владение от src к dst и гарантирует, что деструктор вызывается только один раз для исходного объекта.

В предложении подчеркивается, что это “основные точки входа в основную магию отслеживания и управления временем жизни объектов” и что требуется “магия компилятора для реализации” - то есть вы не можете написать эту функцию самостоятельно в текущем C++.

Текущие ограничения C++

В текущих стандартах C++ вы не можете реализовать истинную разрушительную семантику перемещения по нескольким причинам:

1. Деструктор всегда вызывается: Даже при операциях перемещения деструктор исходного объекта всегда вызывается в конце его времени жизни.

2. Допустимость объекта: Семантика перемещения требует, чтобы исходный объект оставался в допустимом, но неопределенном состоянии, что предотвращает полное уничтожение.

3. Нет статической передачи владения: C++ не обладает возможностью выражать передачу владения на уровне системы типов, что необходимо для статического анализа времени жизни, как в Rust.

Как объясняет Херб Саттер (Herb Sutter), постусловие операции перемещения должно указывать, что “rv присваиваем и уничтожаем”, но его состояние в остальном не определено - это предотвращает истинную разрушительную семантику.

Реализация перемещения в текущем C++

Хотя вы не можете реализовать trivially_relocate_at именно как предложено, в текущем C++ есть обходные пути, которые аппроксимируют часть ее функциональности:

1. Ручное перемещение с placement new

template <class T>
T* relocate_manual(T* dst, T* src) {
    new (dst) T(std::move(*src));
    src->~T();
    return dst;
}

Этот подход:

• Использует placement new для конструирования в месте назначения
• Явно вызывает деструктор для исходного объекта
• Не предоставляет гарантий безопасности версии C++26
• Требует осторожной обработки исключений

2. Использование стандартных библиотечных средств

Стандартная библиотека C++ предоставляет некоторые возможности, похожие на перемещение:

// Для контейнеров, поддерживающих реаллокацию
std::vector<T> vec;
// При реаллокации вектора он использует семантику перемещения, но вызывает деструкторы

Однако эти подходы все еще не предоставляют разрушительную семантику, которую вы ищете.

3. Пользовательские утилиты перемещения

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

Статическая передача владения и семантика, похожая на Rust

Это приводит нас к вашему основному вопросу о статической передаче владения. Желание “статического анализа времени жизни, подобного Rust” - это именно то, что мотивирует обсуждение разрушительной семантики перемещения.

Как упоминается в обсуждении на Reddit, “В C++ объекты просто не могут менять свою идентичность, и должен создаваться новый объект с отдельной идентичностью, которая может наследовать владение его ресурсами, как реализовано конструкторами перемещения”.

Идея квалификатора указателя, которую вы предложили:

template <class T>
T* trivially_relocate_at(new T* dst, delete T* src);

На самом деле, это довольно близко к тому, что нужно для истинной передачи владения. Ключевые требования для семантики, похожей на Rust, были бы:

1. Явная передача владения: Поддержка системы типов для указания, когда передается владение
2. Нет двойного уничтожения: Гарантия того, что деструкторы вызываются ровно один раз на каждый объект
3. Статический анализ времени жизни: Компиляционная проверка времени жизни объектов

Необходимые языковые функции для истинных разрушительных перемещений

Для реализации истинной разрушительной семантики перемещения и статической передачи владения C++ потребовались бы несколько новых языковых функций:

1. Новые квалификаторы указателей

Ваш предложенный синтаксис с квалификаторами владения идет в правильном направлении. Мы могли бы увидеть что-то вроде:

// Передать владение от src, передать владение dst
template <class T>
T* relocate(owning<T*> dst, owning<T*> src);

// Или более явно указать операции
template <class T>
T* relocate(consume T* dst, produce T* src);

2. Новые классы хранения

// Объекты, помеченные как 'перемещенные', не вызывают деструкторы
relocated MyClass obj;

3. Улучшенные типовые признаки

template <class T>
constexpr bool is_destructively_movable = /* ... */;

4. Измененная семантика деструкторов

Фундаментальным изменением было бы позволить условно пропускать вызовы деструкторов, когда владение явно передается.

Практическое применение и варианты использования

Возможность реализации разрушительной семантики перемещения позволила бы реализовать несколько важных вариантов использования:

1. Высокопроизводительные структуры данных

Контейнеры могли бы реализовывать реаллокацию без накладных расходов на перемещение-конструирование всех элементов и последующее их уничтожение.

2. Системное программирование

Лучший контроль над временем жизни объектов в встраиваемых системах и разработке ядра.

3. Взаимодействие с Rust

Более простая и безопасная интеграция между C++ и Rust, особенно в критичных по производительности сценариях.

4. Инструменты статического анализа

Улучшенная возможность для инструментов статического анализа проверять безопасность памяти и предотвращать ошибки использования после освобождения (use-after-free).

Как отмечено в обсуждении на Stack Overflow, это не просто оптимизация C++, а “спасение” его путем включения статического анализа времени жизни, который мог бы предотвратить целые классы ошибок безопасности памяти.

Заключение

C++26 вводит тривиальную перемещаемость через P2786, которая предоставляет возможности перемещения объектов, но не достигает уровня истинной разрушительной семантики перемещения. Функция trivially_relocate_at позволит эффективно перемещать объекты, сохраняя гарантии безопасности, но она не предоставляет полной семантики передачи владения, которую вы ищете.

Для истинной разрушительной семантики перемещения и статического анализа времени жизни, подобного Rust, C++ потребовались бы значительные изменения языка, включая новые квалификаторы указателей, расширенную поддержку системы типов для владения и измененную семантику деструкторов. Синтаксис передачи владения, который вы предложили, представляет собой перспективное направление для выражения этих концепций на уровне языка.

Между тем разработчики могут обходить эти ограничения с помощью ручных техник перемещения, пользовательских утилит или путем принятия шаблонов, которые минимизируют необходимость в разрушительных перемещениях. Функция тривиальной перемещаемости в C++26 представляет значительный шаг вперед в управлении временем жизни объектов, даже если она не полностью достигает разрушительной семантики, которая позволила бы реализовать полный статический анализ времени жизни.

Источники

1. P2786R13: Trivial Relocatability For C++26
2. P2786R11: Trivial Relocatability For C++26
3. Qt and Trivial Relocation (Part 5): Trivial Relocation and Standard C++
4. Is C++26 getting destructive move semantics? - Stack Overflow
5. Move, simply - Herb Sutter
6. Reddit: Move Semantics in C++ and Rust: The Case for Destructive Moves
7. P1144R6: Object relocation in terms of move plus destroy