class Cents
{
private:
m_nCents;
public:
//Constructor
Cents( int nCents ) { m_nCents = nCents; }
int GetCents(){ return m_nCents; }

Cents operator+( const Cents& cent2 )
{
return Cents( this->m_nCents + cent2.m_nCents );
}
};

int main()
{
using namespace std;
Cents myCent1(6);
Cents myCent2(8);
Cents myCent3( myCent1 + myCent2 );
cout << myCent3.GetCents() << endl;

return EXIT_SUCCESS;
}

btw, i learned this in some OOP book…

What does &cM1? Please reply! Can you explain in more detail.

MinMax operator+(const MinMax &cM1, const MinMax &cM2)

it works the same when I use this:

MinMax operator+(const MinMax cM1, const MinMax cM2)

I also changed the declaration of the friend function

Also in light of using friend functions and manageability where do you recommend I keep them (the friend functions). Just below my class, like your example, or somewhere else?

Cheers,

Note that the code above does not work when the programmer use template class instead (cf. http://www.learncpp.com/cpp-tutorial/143-template-classes for deatils):

#include <iostream>

template < typename T > class Cents
{
  private:
    T m_nCents;

  public:
    // Acts as default constructor, parameterised constructor
    // Also performs type conversion from int to Cents

    Cents < T > (int nCents)
    {
        m_nCents = nCents;
    }

    // overload Cents + Cents
    template < typename X > friend Cents < X > operator+(const Cents < X > &c1,
                                                         const Cents < X > &c2);
    T       GetCents()
    {
        return m_nCents;
    }
};

// note: this function is not a member function!
template < typename T > Cents < T > operator+(const Cents < T > &c1, const Cents < T > &c2)
{
    // use the Cents constructor and operator+(int, int)
    return Cents<T>(c1.m_nCents + c2.m_nCents);
}

int main()
{
    Cents < int >c1 = Cents < int >(4) + 6;
    Cents < int >c2 = 6 + Cents < int >(4);

    std::cout << "I have " << c1.GetCents() << " cents." << std::endl;
    std::cout << "I have " << c2.GetCents() << " cents." << std::endl;
    return 0;
}

This code makes the g++ compiler complaining about operator+ :

cents.cpp:35: erreur: no match pour « operator+ » dans « Cents<int>(4) + 6 »
cents.cpp:36: erreur: no match pour « operator+ » dans « 6 + Cents<int>(4) »

The programmer shall explicitly define the operator+ (as Alex has done in its example).

The Jayaram suggestion is nice, but it implies some magics from compiler.

The advantage that I see from the Alex code sample is that there is no magic, making code clearer and allow the programmer changing a non template class into template class without surprise :)

Remember that a member function always has to have an implicit data type that is pointed to by *this. Thus, if you do something like this:

a + b

, the compiler translates that to a.add(b). a becomes the implicit data type. Now we have a as an implicit type, and b as an explicit type. This can be awkward.

However, if we use a friend function, then both a and b come through as parameters, which makes the functions easier to write because we don’t have to worry about any implicit variables.

In this case, we use call by reference because we don’t want to copy the Cents class to do a pass-by-value. Really, those should be const references.