In C++, an overloaded unary operator defined as a member function requires how many variables to be passed as function argument?

Question

Accepted Answer

The correct option is (1):
When a unary operator (such as the logical NOT \!, increment ++, or unary negation -) is overloaded as a **member function** of a class in C++, it requires **zero** explicit arguments in its function signature. The essential principle here is the implicit `this` pointer. A unary operator operates on a single operand. For a member function, this single operand is the object on which the operator is invoked. This object is automatically passed to the function by the compiler via the hidden `this` pointer, which points to the calling object. Since the single required operand is already accounted for implicitly, the function is declared without any formal parameters: `return_type operator@()`.

The incorrect option is (2):
The requirement of **one** argument is correct for an overloaded unary operator only when it is defined as a *non-member function* (a global or friend function). In that specific case, there is no implicit `this` pointer, so the single operand on which the operator acts must be passed explicitly as an argument. However, because the question specifies a *member function*, which uses the implicit `this` pointer, passing one argument explicitly is incorrect for this context.

The incorrect option is (3):
The requirement of **two** arguments is the standard signature for overloading a *binary operator* (which takes two operands, such as +, -, or \*) when it is defined as a *non-member function*. Since the question is about a *unary* operator, which only requires one operand, and a *member* function, which handles one implicitly, specifying two arguments is fundamentally incorrect.

The incorrect option is (4):
The statement that an unary operator cannot be overloaded is **false**. Operator overloading is a core feature of Object-Oriented Programming in C++, and it applies to most operators, including all unary operators (++, --, \!, unary -). Overloading is crucial for allowing C++ operators to work intuitively with user-defined class objects. Only four operators are non-overloadable: the scope resolution operator (::), the member access operator (.), the pointer-to-member operator (.\*), and the ternary conditional operator (?:).