На протяжении C++98 члены функции получали доступ к неявному объекту через скрытый указатель this, что требовало различных перегрузок для обработки const и неконстантных контекстов, тогда как C++11 ввел квалификаторы ссылок для различения lvalue и rvalue объектов. Это потенциально требовало создания четырех перегрузок на функцию для покрытия всех комбинаций cv-ref, создавая значительное дублирование кода и проблемы с обслуживанием для универсальных библиотек.
Основная проблема возникает, когда член функции должен вернуть объект с той же категорией значения и cv-квалификацией, что и вызывающий код, чтобы обеспечить эффективную семантику перемещения или предотвратить вампирские ссылки. Без установления типа объекта разработчики писали многословные наборы перегрузок или шли на компромисс с семантикой копирования, что приводило к неэффективной обработке rvalue или к тонким ошибкам жизненного цикла в универсальном коде, которые распространяли ссылки на объекты.
C++23 вводит явные параметры объекта, позволяя использовать синтаксис void foo(this auto&& self). Здесь self становится параметром с выводом типа, захватывающим категорию значения и cv-квалификаторы объекта, что устраняет необходимость в отдельных перегрузках & и &&, так как std::forward<decltype(self)>(self) передает правильную категорию. Однако статические члены функции полностью лишены неявного объекта, поэтому применение этого синтаксиса к ним нарушает основное требование о наличии объекта для связывания с self, что делает программу некорректной по стандарту.
// Пред- C++23: Нужны четыре перегрузки class Builder { public: Builder& setName(...) & { /* ... */ return *this; } Builder const& setName(...) const& { /* ... */ return *this; } Builder&& setName(...) && { /* ... */ return std::move(*this); } Builder const&& setName(...) const&& { /* ... */ return std::move(*this); } }; // C++23: Одна перегрузка class Builder { public: template<typename Self> auto setName(this Self&& self, ...) -> Self&& { // ... return std::forward<Self>(self); } };
Наша команда разработала высокопроизводительную JSON библиотеку, где DOM узлы поддерживали метод цепочки для построения дерева, что требовало от класса Node предоставления методов addChild() с различными семантиками возврата. Эти методы должны были возвращать родительский элемент по ссылке, когда родитель был lvalue, чтобы позволить дальнейшие изменения, и по значению, когда родитель был временным rvalue, чтобы обеспечить устранение перемещения и предотвратить случайное изменение истекающих объектов.
Первоначальная реализация использовала традиционные перегрузки с учетом квалификации ссылок. Мы поддерживали четыре версии addChild: одна возвращала Node& для lvalue, одна возвращала Node const& для const lvalue, одна возвращала Node&& для rvalue, и одна возвращала Node const&& для const rvalue. Этот подход удовлетворял требованиям производительности, но увеличивал нашу площадь тестирования в четыре раза, и возникла критическая ошибка, когда перегрузка const&& неправильно возвращала вампирскую ссылку из-за ошибки копирования-вставки из перегрузки &.
Мы рассмотрели возможность полного отказа от квалификаторов ссылок и всегда возвращать по значению, полагаясь на RVO для оптимизации копий, но это заставляло выполнять ненужные перемещения на именованных объектах и нарушало обратную совместимость API с существующим кодом, который сохранял ссылки на возвращаемый узел. Мы также оценили CRTP с базовым классом-шаблоном, выводящим производный тип, но это обнажило детали реализации для пользователей и усложнило иерархии наследования, не решив полностью проблему передачи категории значения.
Принятие явных параметров объекта в C++23 позволило нам сократить набор перегрузок до одного шаблонного метода: template<typename Self> auto addChild(this Self&& self, ...) -> Self. Это захватило точную требуемую категорию значения, позволяло совершать идеальную переадресацию без избыточности std::move или std::forward в реализации и снизило цикломатическую сложность метода до одного пути. В результате мы сократили количество шаблонного кода на 75% и устранили категорию ошибок, связанных с дивергенцией перегрузок.
Почему использование синтаксиса явного параметра объекта предотвращает наличие традиционных cv-квалификаторов или квалификаторов ссылок, добавленных после списка параметров?
Традиционные члены функции размещают cv-квалификаторы и квалификаторы ссылок после списка параметров, чтобы изменить тип неявного указателя this. С явными параметрами объекта this Self&& self уже кодирует cv-квалификацию и категорию ссылки в выводе типа Self. Добавление дополнительных квалификаторов, таких как const или &, после списка параметров будет пытаться квалифицировать несуществующий неявный объект, создавая противоречие в системе типов. Стандарт явно запрещает эту комбинацию, потому что явный параметр подменяет роль как параметра, так и квалификаторов, и разрешение обоих создало бы двусмысленность относительно того, какие семантики управляют вызовом.
Как поиск имен внутри тела функции отличается при использовании явных параметров объекта по сравнению с традиционными членами функции?
В традиционных членах функции неограниченный поиск имени автоматически ищет в области класса, как если бы this-> был добавлен в начало. С явными параметрами объекта не существует неявного указателя this; параметр self должен использоваться явно для доступа к членам. Кандидаты часто предполагают, что member внутри void foo(this auto& self) разрешается автоматически как this->member, но на самом деле требует квалификации self. или явной квалификации класса, такой как ClassName::member. Это меняет основные правила поиска и требует адаптации при миграции кода, особенно для доступа к защищенным членам из производных классов, где self. явно инициирует проверку доступа к выведенному типу, а не к статическому типу класса.
Могут ли явные параметры объекта участвовать в переопределении виртуальных функций, и какие ограничения применимы к отношениям переопределения?
Явные параметры объекта могут появляться в виртуальных функциях, но они фундаментально изменяют правила совпадения переопределения. Базовый класс, объявляющий virtual void bar(this Base& self), не может быть переопределен производным классом, объявляющим void bar(this Derived& self), даже если традиционные переопределения допускают ковариантные возвращаемые типы. Явный параметр объекта становится частью сигнатуры функции для целей соответствия переопределения. Поскольку Base& и Derived& являются различными типами, это не составляет действительного переопределения. Это предотвращает распространенный шаблон использования явных параметров объекта для достижения «дружественных к sfinae» виртуальных функций или сохранения типов при методах цепочки в полиморфных иерархиях. Для переопределения производная функция должна точно соответствовать явному типу параметра базового класса, что аннулирует выгоды вывода для этого параметра в контексте переопределения.