Gibt es eine Möglichkeit, das Standardverhalten von Klammern zu überschreiben?

Question

Ich möchte den Operator , überladen, so dass ich meinen Bruch mit dieser Syntax zuweisen kann: frac = 1, 2. Es funktionierte gut ohne () Operatoren.

#include <iostream> 

using namespace std; 

class fraction { 
private: 
    int m_num; 
    int m_den; 

public: 
    fraction(int num, int den) 
     :m_num(num), m_den(den) { 

    } 

    fraction& operator =(int num) { 
     m_num = num; 
     return *this; 
    } 

    fraction& operator ,(int den) { 
     m_den = den; 
     return *this; 
    } 

public: 
    friend 
     ostream& operator <<(ostream& out, const fraction& rhs) { 
     return out << rhs.m_num << ", " << rhs.m_den; 
    } 
}; 

int main() { 
    fraction f(1, 2); 
    cout << "original f = " << f << endl; 

    f = 4, 5; 
    cout << "expected = " << f << endl; 

    f = (10, 11); 
    cout << "unexpected = " << f << endl; 
} 

** OUTPUT

$ prog.exe 
original f = 1, 2 
expected = 4, 5 
unexpected = 11, 5 

Ich habe versehentlich eine () um num und den, und von dem Ausgang erkannte ich den Vorrang operator() das tatsächliche Ergebnis beeinflusst. Es ausgewertet mit nur operator ,, die ungerade ist. Also meine Frage ist, gibt es einen Weg (Makro vielleicht?), Um den Einfluss des Betreibers () in dieser besonderen Situation zu ignorieren?

Answer 1

Sie können Operatoren nur überladen, wenn mindestens eines der Argumente benutzerdefiniert ist. In Ihrem Fall wären beide Argumente int s, also können Sie nichts tun.

(andere als fragwürdige Verwendung von operator, vermeiden!)