C++ overloading operator +

NumeroFarlocco operator+(NumeroFarlocco n1, NumeroFarlocco n2)

Should be an out-of-class definition, that is, a free function.

class NumeroFarlocco {
  // ...
};

NumeroFarlocco operator+(NumeroFarlocco n1, NumeroFarlocco n2) {
  // ...
}

If you using NumeroFarlocco operator+( NumeroFarlocco n2 ); it goes inside the class definition. Yes, the this pointer is how you access the left-hand-side value.

Those are two different things,

The first method:

NumeroFarlocco operator+(NumeroFarlocco n1, NumeroFarlocco n2);

defines globally how to interprete the + operator.

That is it does means:

NumeroFarlocco n = operator+(n0,n2);

Where as the second one:

NumeroFarlocco operator+( NumeroFarlocco n2 );

defines how to interprete the addition of one to another.

that is:

NumeroFarlocco n = n0.operator+(n1)

I'd like to expand somewhat on Luchian Grigore's answer. Technically, as he says, there are two ways of defining binary operators. In practice, however, a certain number of conventions are usually followed; in particular, binary objects which return a new object (like operator+) are usually defined as non members, and those which modify the left operand (like operator+=) are usually defined as members. In addition, it is frequent to define the functions which return an object by using those which modify an object, e.g.:

MyType
operator+( MyType const& lhs, MyType const& rhs )
{
    MyType results( lhs );
    results += rhs;
    return results;
}

In fact, I don't normally even write the functions which return a value; I've written a base class template which defines them, and derive from that:

template <typename DerivedClass>
class MathematicOperators
{
    friend DerivedClass
    operator+( DerivedClass const& lhs, DerivedClass const& rhs )
    {
        DerivedClass results( lhs );
        results += rhs;
        return results;
    }
    //  And so on for all of the binary operators...
};

class MyClass : MathematicOperators<MyClass>
{
    //  ...
    MyClass& operator+=( MyClass const& other )
    {
        //  modify *this...
        return *this;
    }
    //  ...
};

(Note that the friend in MathematicOperators is not to be able to access private members of the derived class, but to be able to define the free function inline in the class template.)

I would strongly recommend following this procedure. It will result in a lot less code, and will guarantee that + and += have the expected relationship.

First of all you might want to read the following tutorial to learn some basic rules on how to overload operators.

Starting with your original code :

NumeroFarlocco operator+(NumeroFarlocco n1, NumeroFarlocco n2);

This is might not what you really want to declare. The way you declare operator+ is dependant on what you want to achieve.

Assuming from your question, you want to overload the binary+, so you would do it like this:

friend NumeroFarlocco operator+(NumeroFarlocco n1 , NumeroFarlocco n2 );

or alternatively as you declared above :

NumeroFarlocco operator+( NumeroFarlocco n2 );

The difference between these two declaration is that the first one is friend(free funcion) while the second one is a member function.

The first one(using friend function) means you don't call the function via object (it's like a global function), the second one means that you must call this function via object (as you normally do with member function).

Also, always remember that operator is a function.

NumeroFarlocco x, y, z; // suppose you have empty/default c'tor

x = y + z  is equivalent to x.operaotr=(y.operator+(z))

Hope it helps you, Syndicator!