Function return type

I have just started learning c++ and I have a question.
In the following example is confusing to me why function Add have return type Cents and why are c1 and c2 are passed by reference.

Code:

class Cents
{
private:
    int m_nCents;
 
public:
    Cents(int nCents) { m_nCents = nCents; }
 
    int GetCents() { return m_nCents; }
};
 
Cents Add(Cents &c1, Cents &c2)
{
Cents cTemp(c1.GetCents() + c2.GetCents());
return cTemp;
}

int main()
{
Cents cCents1(6);
Cents cCents2(8);
Cents cCentsSum = Add(cCents1, cCents2);
std::cout << "I have " << cCentsSum.GetCents() << " cents." << std::endl;
 
return 0;
}

There's no particular reason that the Add function has to return a Cents object. It could just as well have returned an int. However, the way it is used later in the program requires that it return a Cents object.

The reason the Add function passes by reference is probably to avoid the overhead of having to create three temporary Cents objects. The way it is implemented now it only needs to recreate one. I personally would have declared it such that it like this:

Code:

Cents Add(const Cents &objectOne, const Cents &objectTwo)
{
.....
}

The reason is that the Add function does not need to modify the objects, but it wants a reference. The const keyword promises us that it will never modify our objects.

Zach_the_Lizard's advice is sound, and it points out another flaw: your GetCents member function is not declared const, so you cannot call it through a const Cents object/reference/pointer. The fix is to declare GetCents as const by adding the const keyword, e.g.,

Code:

int GetCents() const { return m_nCents; }

Making GetCents const makes sense since GetCents() does not modify the observable state of the Cents object.