Export (0) Print
Expand All

Operator Overloading

The operator keyword declares a function specifying what operator-symbol means when applied to instances of a class. This gives the operator more than one meaning, or "overloads" it. The compiler distinguishes between the different meanings of an operator by examining the types of its operands.


type operator operator-symbol ( parameter-list )

You can redefine the function of most built-in operators globally or on a class-by-class basis. Overloaded operators are implemented as functions.

The name of an overloaded operator is operatorx, where x is the operator as it appears in the following table. For example, to overload the addition operator, you define a function called operator+. Similarly, to overload the addition/assignment operator, +=, define a function called operator+=.

Redefinable Operators
Operator Name Type

,

Comma

Binary

!

Logical NOT

Unary

!=

Inequality

Binary

%

Modulus

Binary

%=

Modulus assignment

Binary

&

Bitwise AND

Binary

&

Address-of

Unary

&&

Logical AND

Binary

&=

Bitwise AND assignment

Binary

( )

Function call

( )

Cast Operator

Unary

*

Multiplication

Binary

*

Pointer dereference

Unary

*=

Multiplication assignment

Binary

+

Addition

Binary

+

Unary Plus

Unary

++

Increment1

Unary

+=

Addition assignment

Binary

Subtraction

Binary

Unary negation

Unary

––

Decrement1

Unary

–=

Subtraction assignment

Binary

–>

Member selection

Binary

–>*

Pointer-to-member selection

Binary

/

Division

Binary

/=

Division assignment

Binary

<

Less than

Binary

<<

Left shift

Binary

<<=

Left shift assignment

Binary

<=

Less than or equal to

Binary

=

Assignment

Binary

==

Equality

Binary

>

Greater than

Binary

>=

Greater than or equal to

Binary

>>

Right shift

Binary

>>=

Right shift assignment

Binary

[ ]

Array subscript

^

Exclusive OR

Binary

^=

Exclusive OR assignment

Binary

|

Bitwise inclusive OR

Binary

|=

Bitwise inclusive OR assignment

Binary

||

Logical OR

Binary

~

One's complement

Unary

delete

Delete

new

New

conversion operators

conversion operators

Unary

1   Two versions of the unary increment and decrement operators exist: preincrement and postincrement.

See General Rules for Operator Overloading for more information. The constraints on the various categories of overloaded operators are described in the following topics:

The operators shown in the following table cannot be overloaded. The table includes the preprocessor symbols # and ##.

Nonredefinable Operators

Operator

Name

.

Member selection

.*

Pointer-to-member selection

::

Scope resolution

? :

Conditional

#

Preprocessor convert to string

##

Preprocessor concatenate

Although overloaded operators are usually called implicitly by the compiler when they are encountered in code, they can be invoked explicitly the same way as any member or nonmember function is called:

Point pt;
pt.operator+( 3 );  // Call addition operator to add 3 to pt.

The following example overloads the + operator to add two complex numbers and returns the result.

// operator_overloading.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

struct Complex {
   Complex( double r, double i ) : re(r), im(i) {}
   Complex operator+( Complex &other );
   void Display( ) {   cout << re << ", " << im << endl; }
private:
   double re, im;
};

// Operator overloaded using a member function
Complex Complex::operator+( Complex &other ) {
   return Complex( re + other.re, im + other.im );
}

int main() {
   Complex a = Complex( 1.2, 3.4 );
   Complex b = Complex( 5.6, 7.8 );
   Complex c = Complex( 0.0, 0.0 );

   c = a + b;
   c.Display();
}

Community Additions

ADD
Show:
© 2014 Microsoft