Przeładowanie(lewostronne) operatora +.

Szanowni forumowicze, pisząc program napotkałem pewien problem, którego za nic nie potrafię rozwiązać. Liczę, że z waszym doświadczeniem i wiedzą poradzicie sobie z nim bez trudu. Uczę się dopiero programować dlatego proszę o wyrozumiałość. Przejdę od razu do rzeczy. Otóż, piszę prosty program wykorzystujący klasy, gdzie chciałbym przeładować operator +(plusa). Wszystko jest ładnie i pięknie gdy później(w main'ie) chcę dodać do obiektu(klasy Pieniądze) liczbę(int'a), jednak na odwrót już pojawia się problem. Proszę was o pomoc w rowiązaniu tego problemu, jak dodać do liczby(int'a) obiekt(klasy Pieniadze). Wiem, że wiąże się to z przeładowaniem operatora, jednak ta wiedza nie wiele mi pomaga. Ponadto zależy mi na rozwiązaniu, które mieściło by się w obrębie klasy, nie poza nią.

#include <iostream>

using namespace std;

class Pieniadze
{
private:
    int grosze;
    int zlotowki;

public:
    int get_g(){return grosze;}	//Getter.//
    int get_z(){return zlotowki;}	//Getter.//
    int ustaw(int g)	//Setter.//
    {
        if(g<0)
        {
            zlotowki = 0;
            grosze = 0;
        }
        else
        {
            zlotowki = g/100;
            grosze = g%100;
        }
    }
    void wypisz(){cout << grosze << " " << zlotowki << endl;}	//Funkcja wypisująca dane składowe klasy.//

    Pieniadze operator+(Pieniadze p)	//Przeładowanie operatora +(plusa).//
    {
        return Pieniadze(grosze + p.grosze, zlotowki + p.zlotowki);
    }
    Pieniadze(int g, int z)	//Konstruktor dwu-argumentowy.//
    {
        if((z*100 + g)<0)
        {
            zlotowki = 0;
            grosze = 0;
        }
        else
        {
            zlotowki = (z*100 + g)/100;
            grosze = (z*100 + g)%100;
        }
    }
    Pieniadze(int g)	//Konstruktor jedno-argumentowy.//
    {
        if(g<0)
        {
            zlotowki = 0;
            grosze = 0;
        }
        else
        {
            zlotowki = g/100;
            grosze = g%100;
        }
    }
    Pieniadze()	//Konstruktor bez-argumentowy.//
    {
        zlotowki = 0;
        grosze = 0;
    }
    ~Pieniadze(){}	//Destruktor.//
};

int main()
{
    Pieniadze tysiac(1000);

    Pieniadze suma1 = tysiac + 20;	//To się ładnie kompiluje.//
    suma1.wypisz();
    Pieniadze suma2 = 20 + tysiac;	//Tu już jest problem, o który mi się rozchodzi :/.//
    suma2.wypisz();

    return 0;
}

Z góry dziękuję i pozdrawiam :).

Można też tak:

Pieniadze operator+ (Pieniadze p, int i) {
//...
}
Pieniadze  operator+ (int i, Pieniadze p) {
//...
}

Zdefiniuj dwuargumentowy operator+ poza klasą.

Dziękuję ślicznie wszystkim zainteresowanym, za pomocne odpowiedzi :). Pytanie dla poszerzenia wiedzy ogólnej, czy istnieje rozwiązanie, które mieściłoby się w obrębie klasy? Jeśli tak, to czy jest ono trudne dla początkującego? Pozdrawiam :).

Możesz mieć przeładowany operator, który jest metodą, ale wtedy znajdziesz się dokładnie w sytuacji, której chcesz uniknąć.

Co prawda można sobie zrobić własne suffixy i mieć na ten przykład:

Piniondz p {30};
auto = 20_piniendzy + p;

Ale to nie zmienia faktu, że 20 + p ani 20 + 25_piniendzy już nie zabangla. ;)