12 Overloading [over]

12.4 Overloaded operators [over.oper]

12.4.1 General [over.oper.general]

A declaration whose declarator-id is an operator-function-id shall declare a function or function template or an explicit instantiation or specialization of a function template.

A function so declared is an operator function.

A function template so declared is an operator function template.

A specialization of an operator function template is also an operator function.

An operator function is said to implement the operator named in its operator-function-id.

operator-function-id:
operator operator

operator: one of
new delete new[] delete[] co_await ( ) [ ] -> ->*
~ ! + - * / % ^ &
| = += -= *= /= %= ^= &=
|= == != < > <= >= <=> &&
|| << >> <<= >>= ++ -- ,

[Note 1:

The operators new[], delete[], (), and [] are formed from more than one token.

The latter two operators are function call and subscripting .

— end note]

Both the unary and binary forms of

+ - * &

can be overloaded.

[Note 2:

The following operators cannot be overloaded:

. .* :: ?:

nor can the preprocessing symbols # ([cpp.stringize]) and ## ([cpp.concat]).

— end note]

Operator functions are usually not called directly; instead they are invoked to evaluate the operators they implement ([over.unary] – [over.inc]).

They can be explicitly called, however, using the operator-function-id as the name of the function in the function call syntax ([expr.call]).

[Example 1: complex z = a.operator+(b); // complex z = a+b; void* p = operator new(sizeof(int)*n); — end example]

The allocation and deallocation functions, operator new, operator new[], operator delete, and operator delete[], are described completely in [basic.stc.dynamic].

The attributes and restrictions found in the rest of [over.oper] do not apply to them unless explicitly stated in [basic.stc.dynamic].

The co_await operator is described completely in [expr.await].

The attributes and restrictions found in the rest of [over.oper] do not apply to it unless explicitly stated in [expr.await].

An operator function shall either

(7.1)
be a member function or
(7.2)
be a non-member function that has at least one non-object parameter whose type is a class, a reference to a class, an enumeration, or a reference to an enumeration.

It is not possible to change the precedence, grouping, or number of operands of operators.

The meaning of the operators =, (unary) &, and , (comma), predefined for each type, can be changed for specific class types by defining operator functions that implement these operators.

Likewise, the meaning of the operators (unary) & and , (comma) can be changed for specific enumeration types.

Operator functions are inherited in the same manner as other base class functions.

An operator function shall be a prefix unary, binary, function call, subscripting, class member access, increment, or decrement operator function.

[Note 3:

The identities among certain predefined operators applied to fundamental types (for example, ++a ≡ a+=1) need not hold for operator functions.

Some predefined operators, such as +=, require an operand to be an lvalue when applied to fundamental types; this is not required by operator functions.

— end note]

An operator function cannot have default arguments, except where explicitly stated below.

Operator functions cannot have more or fewer parameters than the number required for the corresponding operator, as described in the rest of [over.oper].

Operators not mentioned explicitly in subclauses [over.ass] through [over.inc] act as ordinary unary and binary operators obeying the rules of [over.unary] or [over.binary].

12.4.2 Unary operators [over.unary]

A prefix unary operator function is a function named operator@ for a prefix unary-operator @ ([expr.unary.op]) that is either a non-static member function ([class.mfct]) with no non-object parameters or a non-member function with one parameter.

For a unary-expression of the form @ cast-expression, the operator function is selected by overload resolution ([over.match.oper]).

If a member function is selected, the expression is interpreted as

cast-expression . operator @ ()

Otherwise, if a non-member function is selected, the expression is interpreted as

operator @ ( cast-expression )

[Note 1:

The operators ++ and -- ([expr.pre.incr]) are described in [over.inc].

— end note]

[Note 2:

The unary and binary forms of the same operator have the same name.

Consequently, a unary operator can hide a binary operator from an enclosing scope, and vice versa.

— end note]

12.4.3 Binary operators [over.binary]

12.4.3.1 General [over.binary.general]

A binary operator function is a function named operator@ for a binary operator @ that is either a non-static member function ([class.mfct]) with one non-object parameter or a non-member function with two parameters.

For an expression x @ y with subexpressions x and y, the operator function is selected by overload resolution ([over.match.oper]).

If a member function is selected, the expression is interpreted as

x . operator @ ( y )

Otherwise, if a non-member function is selected, the expression is interpreted as

operator @ ( x , y )

An equality operator function is an operator function for an equality operator ([expr.eq]).

A relational operator function is an operator function for a relational operator ([expr.rel]).

A three-way comparison operator function is an operator function for the three-way comparison operator ([expr.spaceship]).

A comparison operator function is an equality operator function, a relational operator function, or a three-way comparison operator function.

12.4.3.2 Simple assignment [over.ass]

A simple assignment operator function is a binary operator function named operator=.

A simple assignment operator function shall be a non-static member function.

[Note 1:

Because only standard conversion sequences are considered when converting to the left operand of an assignment operation ([over.best.ics]), an expression x = y with a subexpression x of class type is always interpreted as x.operator=(y).

— end note]

[Note 2:

Since a copy assignment operator is implicitly declared for a class if not declared by the user ([class.copy.assign]), a base class assignment operator function is always hidden by the copy assignment operator function of the derived class.

— end note]

[Note 3:

Any assignment operator function, even the copy and move assignment operators, can be virtual.

For a derived class D with a base class B for which a virtual copy/move assignment has been declared, the copy/move assignment operator in D does not override B's virtual copy/move assignment operator.

[Example 1: struct B { virtual int operator= (int); virtual B& operator= (const B&); }; struct D : B { virtual int operator= (int); virtual D& operator= (const B&); }; D dobj1; D dobj2; B* bptr = &dobj1; void f() { bptr->operator=(99); // calls D::operator=(int) *bptr = 99; // ditto bptr->operator=(dobj2); // calls D::operator=(const B&) *bptr = dobj2; // ditto dobj1 = dobj2; // calls implicitly-declared D::operator=(const D&) } — end example]

— end note]

12.4.4 Function call [over.call]

A function call operator function is a function named operator() that is a member function with an arbitrary number of parameters.

It may have default arguments.

For an expression of the form

postfix-expression ( expression-list

_{o p t}

)

where the postfix-expression is of class type, the operator function is selected by overload resolution ([over.call.object]).

If a surrogate call function is selected, let e be the result of invoking the corresponding conversion operator function on the postfix-expression;

the expression is interpreted as

e ( expression-list

_{o p t}

)

Otherwise, the expression is interpreted as

postfix-expression . operator () ( expression-list

_{o p t}

)

12.4.5 Subscripting [over.sub]

A subscripting operator function is a member function named operator[] with an arbitrary number of parameters.

It may have default arguments.

For an expression of the form

postfix-expression [ expression-list

_{o p t}

]

the operator function is selected by overload resolution ([over.match.oper]).

If a member function is selected, the expression is interpreted as

postfix-expression . operator [] ( expression-list

_{o p t}

)

[Example 1: struct X { Z operator[](std::initializer_list<int>); Z operator[](auto...); }; X x; x[{1,2,3}] = 7; // OK, meaning x.operator[]({1,2,3}) x[1,2,3] = 7; // OK, meaning x.operator[](1,2,3) int a[10]; a[{1,2,3}] = 7; // error: built-in subscript operator a[1,2,3] = 7; // error: built-in subscript operator — end example]

12.4.6 Class member access [over.ref]

A class member access operator function is a function named operator-> that is a non-static member function taking no non-object parameters.

For an expression of the form

postfix-expression -> template

_{o p t}

id-expression

the operator function is selected by overload resolution ([over.match.oper]), and the expression is interpreted as

( postfix-expression . operator -> () ) -> template

_{o p t}

id-expression

12.4.7 Increment and decrement [over.inc]

An increment operator function is a function named operator++.

If this function is a non-static member function with no non-object parameters, or a non-member function with one parameter, it defines the prefix increment operator ++ for objects of that type.

If the function is a non-static member function with one non-object parameter (which shall be of type int) or a non-member function with two parameters (the second of which shall be of type int), it defines the postfix increment operator ++ for objects of that type.

When the postfix increment is called as a result of using the ++ operator, the int argument will have value zero.109

[Example 1: struct X { X& operator++(); // prefix ++a X operator++(int); // postfix a++ }; struct Y { }; Y& operator++(Y&); // prefix ++b Y operator++(Y&, int); // postfix b++ void f(X a, Y b) { ++a; // a.operator++(); a++; // a.operator++(0); ++b; // operator++(b); b++; // operator++(b, 0); a.operator++(); // explicit call: like ++a; a.operator++(0); // explicit call: like a++; operator++(b); // explicit call: like ++b; operator++(b, 0); // explicit call: like b++; } — end example]

A decrement operator function is a function named operator-- and is handled analogously to an increment operator function.

109)109)

Calling operator++ explicitly, as in expressions like a.operator++(2), has no special properties: The argument to operator++ is 2.