9.6 — Overloading operators using member functions

In the lesson on overloading the arithmetic operators, you learned that when the operator does not modify it’s operands, it’s best to implement the overloaded operator as a friend function of the class. For operators that do modify their operands, we typically overload the operator using a member function of the class.

Overloading operators using a member function is very similar to overloading operators using a friend function. When overloading an operator using a member function:

  • The leftmost operand of the overloaded operator must be an object of the class type.
  • The leftmost operand becomes the implicit *this parameter. All other operands become function parameters.

Most operators can actually be overloaded either way, however there are a few exception cases:

  • If the leftmost operand is not a member of the class type, such as when overloading operator+(int, YourClass), or operator<<(ostream&, YourClass), the operator must be overloaded as a friend.
  • The assignment (=), subscript ([]), call (()), and member selection (->) operators must be overloaded as member functions.

Overloading the unary negative (-) operator

The negative operator is a unary operator that can be implemented using either method. Before we show you how to overload the operator using a member function, here’s a reminder of how we overloaded it using a friend function:

Now let’s overload the same operator using a member function instead:

You’ll note that this method is pretty similar. However, the member function version of operator- doesn’t take any parameters! Where did the parameter go? In the lesson on the hidden this pointer, you learned that a member function has an implicit *this pointer which always points to the class object the member function is working on. The parameter we had to list explicitly in the friend function version (which doesn’t have a *this pointer) becomes the implicit *this parameter in the member function version.

Remember that when C++ sees the function prototype Cents Cents::operator-();, the compiler internally converts this to Cents operator-(const Cents *this), which you will note is almost identical to our friend version Cents operator-(const Cents &cCents)!

Overloading the binary addition (+) operator

Let’s take a look at an example of a binary operator overloaded both ways. First, overloading operator+ using the friend function:

Now, the same operator overloaded using the member function method:

Our two-parameter friend function becomes a one-parameter member function, because the leftmost parameter (cCents) becomes the implicit *this parameter in the member function version.

Most programmers find the friend function version easier to read than the member function version, because the parameters are listed explicitly. Furthermore, the friend function version can be used to overload some things the member function version can not. For example, friend operator+(int, cCents) can not be converted into a member function because the leftmost parameter is not a class object.

However, when dealing with operands that modify the class itself (eg. operators =, +=, -=, ++, --, etc…) the member function method is typically used because C++ programmers are used to writing member functions (such as access functions) to modify private member variables. Writing friend functions that modify private member variables of a class is generally not considered good coding style, as it violates encapsulation.

Furthermore, as mentioned, some specific operators must be implemented as member functions. We’ll be covering most of these in upcoming lessons.

9.7 -- Overloading the increment and decrement operators
9.5 -- Overloading unary operators +, -, and !

23 comments to 9.6 — Overloading operators using member functions

  • egordo19


    In 9.6 for overloading the operator+, it says that the friend function's left most operand has to be of type cents for it to be overloaded via member function. What if someone were to explicitly declare the *this pointer as the second operand in a member function and an int as the first operand. Would this work?

  • yakisobskie

    Remember that when C++ sees the function prototype Cents Cents::operator-();, the compiler internally converts this to Cents operator-(const Cents *this), which you will note is almost identical to our friend version Cents operator-(const Cents &cCents)!

    Cents Cents::operator-(); converts to Cents operator-(const Cents *this);

    On your Chapter 8.7 The hidden "this" pointer

    void SetID(int nID) {} converts to void SetID(Simple* const this, int nID) {}

    Based on Chapter 9.6, "this" is a pointer to a constant class.
    Based on Chapter 8.7, "this" is a constant pointer to a class.

    Please help. Thanks!

  • Muddasar Azeem

    Sorting refers to ordering data in an increasing or decreasing fashion according to some linear
    relationship among the data items. Write a class Sorting() that has one member variable of
    integer array sArray of size 5. The class will have 2 constructor functions; one default
    and one parametrized. The default constructor initializes the sArray members with all zeros
    whereas the parametrized constructor initializes sArray members with the members of array
    ssArray passed to this constructor function while calling it from main program. The Sorting
    class will have another member function setArrayValue which will input (unsorted) values
    from the user and assign them to sArray when the Sorting object will be created with the
    default constructor. The Sorting class will also have a member function Sort which when
    called will sort the array sArray using any sorting algorithm and display the sorted data.
    Write a main() program that creates an object S1 of class Sorting using default constructor,
    assigns value to sArray, sorts them and displays the result. Create another object S2 of the same
    class using the parametrized constructor and pass to it the (unsorted) array ssArray. The values
    of ssArray can be either obtained from the user or assigned to it while declaring this array. Sort
    the array ssArray and display the sorted data.

    ANY ONE can HELP ???????????? TO WRITE A PROGRAME

  • Muddasar Azeem

    hi, Priyali. Plz Help me,write a programe how to add two object & 1 object + 1int with in single programe.

  • Priyali

    Hi Alex,

    I tried overloading binary addition (+) operator using a member function as shown below.


    using namespace std;

    class Cents
    int m_nCents;

    Cents(int nCents = 0) { m_nCents = nCents; }

    // Overload for Cents + Cents
    Cents operator+(const Cents &cTemp);

    int GetCents() { return m_nCents; }

    // note: this function is a member function!
    Cents Cents::operator+(const Cents &cTemp)
    return Cents(m_nCents + cTemp.m_nCents);

    int main()
    Cents cAdd;
    Cents c1(4);
    Cents c2(6);
    cAdd = c1 + c2;
    cout << "I have " << cAdd.GetCents() << " cents." << endl;

    return 0;


    The code is compiling without errors and giving me the desired output. As per my understanding, when I do c1+c2 , the call gets converted into Cents operator+(const Cents *this, const Cents &cTemp). How could "this pointer" which points to object c1 can access private member m_nCents of object c2(cTemp) even if its not a friend function. This is a bit confusing for me.

  • Jansi

    My previous reply for bishwadeepsg not Alex

  • Jansi

    Hi Alex,

    The main function for operator overloaded using the member function method;

    Cents c(6);

    Output: 8

Leave a Reply

You can use these HTML tags

<a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code class="" title="" data-url=""> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong> <pre class="" title="" data-url=""> <span class="" title="" data-url="">