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.

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

A.Y r we using call by reference??
B.What happens in Main when

Cents cCentsSum = cCents1 + cCents2;

is encountered/

I have an observation. Instead of having many versions of overloading the operators with different combos it should be sufficient to have one version of operator to do Objects & use type conversion to handle other types. Otherwise the no. of combos of operators may become too unwieldy.

Thus, the Cents & MinMax examples work with minimal operator versions as below.

// =============================
class Cents
{
private:
    int m_nCents;

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

    Cents(int nCents) { m_nCents = nCents; }

    // overload Cents + Cents
    friend Cents operator+(const Cents &c1, const Cents &c2);
    int GetCents() { return m_nCents; }
};

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

int main()
{
    Cents c1 = Cents(4) + 6;
    Cents c2 = 6 + Cents(4);
    std::cout << "I have " << c1.GetCents() << " cents." << std::endl;
    std::cout << "I have " << c2.GetCents() << " cents." << std::endl;
    return 0;
}

// ======================================================

class MinMax
{
private:
    int m_nMin; // The min value seen so far
    int m_nMax; // The max value seen so far

public:
    MinMax(int nMin, int nMax)
    {
        m_nMin = nMin;
        m_nMax = nMax;
    }

    // Single argument Constructor which also doubles as
    // type converter from

    MinMax(int nMinMax)
    {
        m_nMin = nMinMax;
        m_nMax = nMinMax;
    }
    int GetMin() { return m_nMin; }
    int GetMax() { return m_nMax; }

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

};

MinMax operator+(const MinMax &cM1, const MinMax &cM2)
{
    // Get the minimum value seen in cM1 and cM2
    int nMin = cM1.m_nMin < cM2.m_nMin ? cM1.m_nMin : cM2.m_nMin;

    // Get the maximum value seen in cM1 and cM2
    int nMax = cM1.m_nMax > cM2.m_nMax ? cM1.m_nMax : cM2.m_nMax;

    return MinMax(nMin, nMax);
}

int main()
{
    MinMax cM1(10, 15);
    MinMax cM2(8, 11);
    MinMax cM3(3, 12);

    MinMax cMFinal = cM1 + cM2 + 5 + 8 + cM3 + 16;

    std::cout << "Result: (" << cMFinal.GetMin() << ", " <<
        cMFinal.GetMax() << ")" << std::endl;

    return 0;
}
// =========================================================