> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C++ Explicit Object Parameter An explicit object parameter (introduced in C++23, commonly referred to as "deducing `this`") is a language feature that allows a non-static member function or a lambda expression to explicitly declare the object instance it is invoked upon as its first parameter. By prefixing the first parameter with the `this` keyword, the function replaces the traditional implicit `this` pointer with an explicit, user-named parameter. ```cpp theme={"dark"} struct Example { // Traditional implicit 'this' with trailing qualifiers void traditional_method(int arg) const&; // C++23 explicit object parameter void explicit_method(this const Example& self, int arg); }; ``` ## Syntactic Rules and Mechanics **1. Parameter Positioning and Declaration** The explicit object parameter must be the strictly first parameter in the function's parameter list. It is declared by placing the `this` specifier immediately before the type of the parameter. It can be passed by value, by reference, or as a templated forwarding reference. **2. Elimination of Trailing Qualifiers** When a member function utilizes an explicit object parameter, it cannot declare trailing cv-qualifiers (`const`, `volatile`) or ref-qualifiers (`&`, `&&`). The constness and value category of the object are entirely dictated by the type signature of the explicit parameter itself. ```cpp theme={"dark"} struct Widget { // INVALID: Cannot combine explicit object parameter with trailing qualifiers // void bad_method(this Widget& self) const; // VALID: Constness is defined by the parameter type void good_method(this const Widget& self); }; ``` **3. Shadowing of the Implicit `this` Pointer** Inside the body of a member function with an explicit object parameter, the implicit `this` pointer is inaccessible. Any member access must be performed explicitly through the named object parameter. ```cpp theme={"dark"} struct Data { int value = 42; void update(this Data& self, int new_value) { // this->value = new_value; // ERROR: 'this' is unavailable self.value = new_value; // CORRECT } }; ``` **4. Type Deduction (Deducing `this`)** When the explicit object parameter is declared as a template parameter (typically a forwarding reference `Self&&`), the compiler deduces the exact type, const-qualification, and value category (lvalue or rvalue) of the object at the call site. To correctly preserve the value category and constness of a returned member when using `decltype(auto)`, the return expression must be parenthesized. An unparenthesized class member access (e.g., `return std::forward(self).data;`) applies standard `decltype` rules, which deduces the *declared type* of the member (yielding a return by value) and discards the reference category. Parenthesizing the expression forces reference deduction. Alternatively, C++23 provides `std::forward_like` to apply the deduced object's value category directly to the member. ```cpp theme={"dark"} #include struct Container { template decltype(auto) get_data(this Self&& self) { // C++23 approach: std::forward_like applies Self's category to the member return std::forward_like(self.data); // Alternative approach using std::forward: // The expression MUST be parenthesized to force reference deduction. // return (std::forward(self).data); } private: int data = 0; }; ``` **5. Explicit Object Parameters in Lambdas** The explicit object parameter syntax is fully supported in lambda expressions. When used in a lambda, the explicit parameter represents the generated closure object itself. This provides a direct mechanism for a lambda to reference itself, enabling recursive lambdas without relying on `std::function` overhead or complex Y-combinator patterns. ```cpp theme={"dark"} auto fibonacci = [](this auto const& self, int n) -> int { if (n < 2) return n; return self(n - 1) + self(n - 2); // 'self' invokes the closure object }; ``` ## Restrictions * **Pointer Types:** The type of an explicit object parameter shall not be a pointer type (e.g., `this Example* self` is explicitly forbidden by the standard). * **Virtual Functions:** An explicit object parameter cannot be used on `virtual` member functions. * **Static Functions:** It cannot be applied to `static` member functions, as they do not operate on an object instance. * **Special Member Functions:** It cannot be used in the declarations of constructors or destructors. * **Multiple Explicit Objects:** A function signature may only contain exactly one explicit object parameter, and it must be the first parameter. ## Overload Resolution During overload resolution, a member function with an explicit object parameter is treated identically to a non-member function whose first parameter is the object type. The compiler matches the object instance against the explicit parameter using standard argument-matching rules, allowing for precise control over lvalue/rvalue and const/non-const dispatching based on the parameter's type signature.

Tired of Poor C++ Skills? Fix That With Deep Grasping! Learn More