Przeładowanie operatora

#include "Money.h"
#include <iostream>
int Currency::USD = 1;
int Currency::PLN = 0; 

int main() {
  using namespace std;
  Money x(1034179*Currency::USD); // w jakis sposob konstruktor z USD musi odroznic PLN
  cout << Currency::type(x) << endl;
  
  const Money y(5633*Currency::PLN); 
  cout << Currency::type(y) << endl;
 

class Currency{
	public:
	static int USD;
	static int PLN;
	static char * type(const Money & obj);
};

void operator*(const Money & obj, int typ_waluty) {
	obj.typ_waluty = typ_waluty;
	

char * Currency::type(const Money & obj) {
	//cout<<obj.typ_waluty<<endl;
	if(obj.typ_waluty == 1) {
		return "USD";
	} else return "PLN";
}

#include <map>
#include <string>

class Currency
{
public:
	enum ISO { PLN, USD, EUR };
	static std::map<ISO, std::string> name;
	static const std::string& type(ISO code) { return name[code]; }
};

std::map<Currency::ISO, std::string> Currency::name = {{PLN, "PLN"}, {USD, "USD"}, {EUR, "EUR"}};

class Money
{
public:
	double amount;
	Currency::ISO code;
	Money(const double &amount, Currency::ISO code) : amount(amount), code(code) {}
	const std::string& type() const { return Currency::type(code); }
};