&& Operator in C++ überladen???



  • Hi ich bin noch recht unerfahren im Umgang mit C++, habe allerdings eine Aufgabe bei der ich einen Operator vom Typ && also einen logischen zum addieren zweier Klassen nutzen soll.

    [cpp]
    //Deklaration in der Klasse:

    CVierpol_H operator&&(CVierpol_H H_Vierpol);

    //Definition des Operators

    CVierpol_H CVierpol_H::operator&&(CVierpol_H H_Vierpol)
    {
    // H = H+H --> entspricht H&&H
    // temp = this + Übergabeparameter
    CVierpol_H temp; //Vierpol der für das Ergebnis angelegt wird(lokal und statisch)

    temp.V_11 = this->V_11+H_Vierpol.V_11;
    //Das Objekt auf das der this Zeiger zeigt ist der linke Operand
    temp.V_12 = this->V_12+H_Vierpol.V_12;
    //beiden Vierpole vom Typ H einfach addieren und H_Vierpol als Ergebnis ausgeben
    temp.V_21 = this->V_21+H_Vierpol.V_21;
    //Der Übergabeparameter hier:H_Vierpol ist der rechte Operand
    temp.V_22 = this->V_22+H_Vierpol.V_22;

    return temp; //Rückgabe eines H_Vierpols als Ergebnis
    }

    Aufgerufen werden soll das ganze dann in einer andern Methode in die 2 Zeiger geliefert werden einer für jeden Vierpol.

    Wie kann man den Operator richtig überladen wenn man 2 Zeiger auf Objekte als Ausgangsbasis hat. Und was hat es mit dem Operator && aufsich, der liefert ja eigentlich nen bool bzw. wandelt in bool um, das soll er aber nicht ich möchte ja aufrufen "Zeiger_auf_VP1"&&"Zeiger_auf_VP2". Ist das möglich?

    Vielen Dank für eure Hilfe:-)



  • benmar007 schrieb:

    Wie kann man den Operator richtig überladen wenn man 2 Zeiger auf Objekte als Ausgangsbasis hat. Und was hat es mit dem Operator && aufsich, der liefert ja eigentlich nen bool bzw. wandelt in bool um, das soll er aber nicht ich möchte ja aufrufen "Zeiger_auf_VP1"&&"Zeiger_auf_VP2". Ist das möglich?

    Nein. zeiger1 && zeiger2 ist schon wohldefiniert. Du kannst den &&-Operator nur für benutzerdefinierte Typen (zB enum, class, struct) überladen.

    Das Überladen von || und && ist oft eine schlechte Idee. Es gibt Ausnahmen, aber das, was Du damit machen willst, ist IMHO keine solche Ausnahme.



  • Vielen Dank schonmal,

    das das keine gute Idee ist den Operator zu überladen hab ich zwischenzeitlich leider auch gemerkt, da jedes Buch auch meint das besser zu lassen. Leider wird das von meinem Prof so gefordert.

    Im Grunde sind es ja zwei Klassen die ich damit verbinden will. Der Operator soll nur intern die beiden Klassen addieren.

    CVierpol_H operator&&(CVierpol_H Rechter_Operand);

    Wie kann ich das genau anstellen bei der Definition. Muss ich da irgendwas als const deklarieren ?



  • Wie wärs wenn ihr stattdessen den operator+ nutzt? Klingt deutlich sinnvoller als ein logisches und.



  • Auh wenns Eigenwerbung ist, folgender Artikel sollte dir einige Antworten geben und scheint auch gut angekommen zu sein 😉
    http://magazin.c-plusplus.net/artikel/�berladung von Operatoren in CPlusPlus (Teil 1)



  • Ok, Vielen Dank für die Hilfe, ich habe meinen Fehler gefunden.

    Ich habe 2 Zeiger "verUNDen" wollen, aber die Zeiger die auf 2 Kindklassenobjekte zeigen, waren vom Typ der Elternklasse, somit wurde ein Operator in der Elternklasse gesucht, der allerding in der Kindklasse steht, bzw mit Kindklasseobjekten überladen wurde.

    Ich werds nochmal überdenken und dann die Lösung so wie sie funzt posten.

    Grüße

    PS.: anderer Operator mag sinnvoller erscheinen, es sei den man bedenkt das ich auch 2 Vierpole "parallel" schalten soll was dem || Operator(&& für Reihenparallel) schon sehr nahe kommt:-)
    außerdem ist die Aufgabenstellung fix.



  • ok die Lösung war das ich mit einer Typeinfo der Typ herrausbekommen habe welcher entstanden ist (zb H_vierpol).
    Dann wird der Vierpol auf den Typ gecastet (also der Zeiger auf den Vierpol).

    Somit funktionieren die Operatoren.
    D.h das
    H = H&&H geht
    H = H&&Y geht

    aber es muss auch
    H = Y&&H und
    H = Y&&Y gehen.

    Hier ist allerdings das linke Element nicht vom Typ der Klasse in der der Operator überladen wird. Gibts ne Möglichkeit das ganze irgendwie umzusetzen?

    Einen Operator der H = Y; und Y = H; realiesiert habe ich schon erstellt der funktioniert auch.



  • benmar007 schrieb:

    ok die Lösung war das ich mit einer Typeinfo der Typ herrausbekommen habe welcher entstanden ist (zb H_vierpol).
    Dann wird der Vierpol auf den Typ gecastet (also der Zeiger auf den Vierpol).

    Explizite Typunterscheidung ist nahezu immer ein Designfehler.

    benmar007 schrieb:

    Gibts ne Möglichkeit das ganze irgendwie umzusetzen?

    Möglicherweise, aber könntest du vielleicht deine aktuelle Struktur etwas verdeutlichen? Also die Klassenhierarchie und die sinnvollen &&-Operatoren zwischen den Klassen. Mit Y und H kann ich recht wenig anfangen.



  • Ok, also:

    Basisklasse Vierpol.
    Von dieser Basisklasse erben 4 Kindklassen (Vierpol A,H,Z,Y).

    Diese Kindklasse sollen mittels && Operator reihe bzw. mittel || Operator parallel geschaltet werden können.

    D.h. ich benötige die Operationen H = H&&H H = H&&Y(geht)
    H = Y&&H und H = Y&&Y(geht nicht)
    Y = Y||Y Y = Y||H(geht)
    Y = H||Y und Y = H||H(geht nicht)
    Die ersten beiden Varianten funktionieren bereits, das Problem bei den letzen beiden Varianten ist das als linkes Element eine Y_Kindklassenobjekt steht aber als Ergebnis ein H_Klassenobjekt entstehen muss. Das ich diese Operatoren verwende ist nicht meine Idee, sondern die meines Prof., allerdings sollte die Wahl des Operators keine Rolle spielen, da das überladen im Prinzip gleich dem von anderen Operatoren sein sollte(binären).



  • Naja im schlimmsten Fall musst du eben je 4 mal den Operator überladen.

    H operator && (H const&, H const&);
    H operator && (H const&, Y const&);
    H operator && (Y const&, H const&);
    H operator && (Y const&, Y const&);
    
    // Selbiges für ||
    

    Du kannst aber natürlich andere überladene Versionen wiederverwenden, z.B.:

    H operator && (Y const& y, H const& h)
    {
        return h && y;
    }
    


  • benmar007 schrieb:

    Basisklasse Vierpol.
    Von dieser Basisklasse erben 4 Kindklassen (Vierpol A,H,Z,Y).

    Wozu soll das gut sein? Ich meine das mit der Vererbung?



  • krümelkacker schrieb:

    benmar007 schrieb:

    Basisklasse Vierpol.
    Von dieser Basisklasse erben 4 Kindklassen (Vierpol A,H,Z,Y).

    Wozu soll das gut sein? Ich meine das mit der Vererbung?

    Vielleicht, damit man im Operator mal ein wenig mit switch rumspielen kann, um die 16 Fälle zu dispatchen. Aber dann darf man nicht mehr Objektorientierte Programmierung für Dummies | ISBN: 3826629841 lesen, weil da steht, daß man sowas nicht tun soll.



  • Ok vielen Dank.

    Das ist dann also global als friend Funktion. Habe das nun mal so umgesetzt allerding gibt es bei der letzten Variante nun das Problem das selbst bei dieser Art den Operator zu überladen mindestens eines der Objekte ein Objekt der Kindklasse sein muss in der der Operator überladen wird. D.h. bei mir muss min. ein Objekt ein H_Vierpol Objekt sein, was bei H = Y&&Y nicht der Fall ist.

    Deshalb erhalt ich auch da einen Compilerfehler:

    1>c:\users\benmar007\desktop\komplexpraktikumneu\visual code\vierpol\vierpol\cvierpol_h.cpp(112) : error C2086: 'const CVierpol_Y &Y_Vierpol': Neudefinition
    1> c:\users\benmar007\desktop\komplexpraktikumneu\visual code\vierpol\vierpol\cvierpol_h.cpp(112): Siehe Deklaration von 'Y_Vierpol'
    1>c:\users\benmar007\desktop\komplexpraktikumneu\visual code\vierpol\vierpol\cvierpol_h.cpp(113) : error C2805: Binärer Operator '&&' hat zu wenig Parameter



  • Das mit dem Vererben ist meiner Meinung nach sinnvoll, da man einen allgemeinen Vierpol hat. Die Arten H,Z,Y,A unterscheiden sich von Ihren Attributen nicht, nur die Operatoren sind unterschiedlich, deswegen habe ich die 4 Kindklassen angelegt und die Operatoren in der Elternklasse virtual deklariert, so ist es möglich die Operatoren unterschiedlich zu überladen.(sollte zumindest so sein)

    Das das Ganze so ausufert hätte ich auch nicht gedacht aber nun muss es was werden da die Prüfung bald ist.



  • nebenbei, danke an alle für die rege Beteiligung an diesem Thread.:-)



  • benmar007 schrieb:

    // H = H+H	--> entspricht H&&H
    

    Hi,

    dir is schon bewusst das, dass eig 0 Sinn macht und nicht zur Verstaendlichkeit deiner Klasse beitraegt da das && eig eine logische Verknuepfung ist und entweder 0(false) oder 1(true) zurueck liefern sollte.

    Gruessle C0de4Fun



  • C0de4Fun schrieb:

    dir is schon bewusst das, dass eig 0 Sinn macht und nicht zur Verstaendlichkeit deiner Klasse beitraegt da das && eig eine logische Verknuepfung ist und entweder 0(false) oder 1(true) zurueck liefern sollte.

    Wenn && und || immer true oder false zurückgeben sollten, wäre eine Überladung dieser Operatoren in den meisten Fällen sinnlos. Was nicht heisst, dass es sich hier um eine semantisch gut gewählte Überladung handelt, aber ich wüsste andere Beispiele.

    Davon abgesehen hat benmar007 ja schon erwähnt, dass er die Aufgabe bekommen hat.



  • Nexus schrieb:

    C0de4Fun schrieb:

    dir is schon bewusst das, dass eig 0 Sinn macht und nicht zur Verstaendlichkeit deiner Klasse beitraegt da das && eig eine logische Verknuepfung ist und entweder 0(false) oder 1(true) zurueck liefern sollte.

    Wenn && und || immer true oder false zurückgeben sollten, wäre eine Überladung dieser Operatoren in den meisten Fällen sinnlos. Was nicht heisst, dass es sich hier um eine semantisch gut gewählte Überladung handelt, aber ich wüsste andere Beispiele.

    Joa is mir schon klar. Deswegen hab ich ja auch geschrieben "eig 0 Sinn" und "zurueck liefern sollte". Sorry wenn das ein bissle unverstaendlich rueber gekommen ist.

    Greetz C0de4Fun


Log in to reply