deducing this

"Deducing this" — возможность объявить метод класса с явным первым параметром this Self&& self, где Self — шаблонный параметр, автоматически выводимый компилятором как тип объекта, через который метод был вызван. Это заменяет неявный, скрытый параметр this, который раньше нельзя было ни поименовать, ни параметризовать по типу."Deducing this" is the ability to declare a class method with an explicit first parameter this Self&& self, where Self is a template parameter automatically deduced by the compiler as the type of the object the method was called through. This replaces the implicit, hidden this parameter, which previously could neither be named nor parameterized by type.

template<class Derived>
struct Base {
    void print() {
        static_cast<Derived*>(this)->do_print();  // ручной static_cast, шаблонный Base// manual static_cast, a templated Base
    }
};
struct Derived : Base<Derived> {  // многословное самоссылающееся наследование// verbose, self-referential inheritance
    void do_print() { /* ... *//* ... */ }
};

struct Base {
    template<class Self>
    void print(this Self&& self) {
        self.do_print();  // Self выводится как тип наследника, без static_cast// Self is deduced as the derived type, no static_cast
    }
};
struct Derived : Base {  // обычное, не шаблонное наследование// ordinary, non-templated inheritance
    void do_print() { /* ... *//* ... */ }
};

Два независимых, но родственных источника boilerplate-кода в C++ существовали десятилетиями без прямого решения на уровне языка:Two independent but related sources of boilerplate had existed in C++ for decades with no direct language-level fix:

Параметр this Self&& self ведёт себя как universal reference (forwarding reference): Self выводится компилятором в момент вызова метода так же, как выводился бы тип шаблонного параметра T&& в обычной функции — если вызов идёт через lvalue, Self становится ссылочным типом (Derived&), если через rvalue — обычным типом (Derived), с сохранением const, если объект был const. Метод при этом остаётся невиртуальным — весь полиморфизм разрешается на этапе компиляции.The this Self&& self parameter behaves like a universal (forwarding) reference: the compiler deduces Self at the call site just as it would deduce a T&& template parameter in an ordinary function — calling through an lvalue makes Self a reference type (Derived&), calling through an rvalue makes it a plain type (Derived), preserving const if the object was const. The method itself stays non-virtual — all polymorphism is resolved at compile time.

struct Base {
    template<class Self>
    void print(this Self&& self) {
        self.do_print();  // вызов через self — не через *this, self и есть выведенный объект// called via self — not *this; self is the deduced object itself
    }
};
struct Widget : Base {
    void do_print() const { std::println("widget"); }
};

Widget w;
w.print();               // Self выводится как Widget& (lvalue)// Self is deduced as Widget& (lvalue)
const Widget cw;
cw.print();              // Self выводится как const Widget&// Self is deduced as const Widget&
Widget{}.print();          // Self выводится как Widget (rvalue)// Self is deduced as Widget (rvalue)

Тот же механизм убирает дублирование перегрузок для метода, который должен вести себя по-разному для lvalue/rvalue самого объекта (классический пример — геттер, возвращающий копию для rvalue-объекта и ссылку для lvalue-объекта, чтобы избежать лишнего копирования там, где это безопасно):The same mechanism removes overload duplication for a method that must behave differently for an lvalue vs. an rvalue object (the classic example — a getter that returns a copy for an rvalue object and a reference for an lvalue object, to avoid an unnecessary copy where it's safe):

struct Widget {
    std::string data_;
    template<class Self>
    auto&& data(this Self&& self) {
        return std::forward<Self>(self).data_;  // одна перегрузка вместо четырёх// one overload instead of four
    }
};

• cppreference — explicit object parameter
• WG21 P0847 — deducing this