Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (ANSI-Standard) » Operatoren überladen

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 < [ 2 ]
000
09.11.2004, 10:54 Uhr
virtual
Sexiest Bit alive
(Operator)


Hallo,

also folgende Nonsense Template ist gegeben:

C++:
template<typename T>
class integer {
    T i;
public:
    integer(T i_) :i(i_) { }

friend integer<T> operator + <>(const integer<T>&, const integer<T>&);
};

template<typename T>
integer<T> operator + (const integer<T>& a, const integer<T>& b) {
    return integer<T>(a.i+b.i);
}

int main() {
    integer<long> a(100);

    a = ::operator +<long>(4, a); // Geht
    a = 4 + a; // Geht nicht!
}


Wäre integer kein template, sondern eine normale Klasse, so würde dieser Code funktionieren.
Mir will einfach kein Weg einfallen, wie man den op+ bei einem Template so definieren kann, daß es tickt.
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
09.11.2004, 11:12 Uhr
Tommix



Hallo,
ich nehme mal an, so was ist Dir zu umständlich:

C++:
template<typename T>
class integer {
    T i;
public:
    integer(T i_) :i(i_) { }
    friend integer<T> operator + (const integer<T>&, const integer<T>&);
    friend integer<T> operator + (const T&, const integer<T>&);
};

template<typename T>
integer<T> operator + (const integer<T>& a, const integer<T>& b) {
    return integer<T>(a.i+b.i);
}

template<typename T>
integer<T> operator + (const T& a, const integer<T>& b) {
    return integer<T>(a+b.i);
}

int main() {
    integer<long> a(100);

    a = 4L + a;

    return 0;
}



Gruß, Tommix
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
09.11.2004, 11:21 Uhr
virtual
Sexiest Bit alive
(Operator)


@Tommix
Genau: das ist, was ich vermeiden möchte: ich möchte den Operator nicht zweimal definieren.
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
09.11.2004, 14:55 Uhr
(un)wissender
Niveauwart


Also erstmal fehlt die Deklararion des operator+, bevor du für all spezialisieren kannst:


C++:

//fwd
template<typename T>
class integer;

//Deklaration des Operators
template<typename T>
integer<T> operator +(const integer<T>&, const integer<T>&);

template<typename T>
class integer {
    T i;
public:
    integer(T i_) :i(i_) { }

    friend integer<T> operator + <>(const integer<T>&, const integer<T>&);
};

template<typename T>
integer<T> operator + (const integer<T>& a, const integer<T>& b) {
    return integer<T>(a.i+b.i);
}

int main() {
    integer<long> a(100);

    a = ::operator +<long>(4, a); // Geht

    a = integer<long>(4) + a; // Geht!
}



Das funzt, aber ist noch nicht ganz das was du willst vermute ich mal.
--
Wer früher stirbt ist länger tot.

Dieser Post wurde am 09.11.2004 um 14:56 Uhr von (un)wissender editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
09.11.2004, 15:06 Uhr
(un)wissender
Niveauwart



Bearbeitung:

Hier stand Blödsinn...



Ansonsten fällt mir nichts ein, das Problem besteht darin, das der Compiler erkennen muss, dass für die 4 ein template-Konstruktor vorhanden ist. Ich vermute jetzt mal, das der Standard erlaubt, an dieser Stelle die Suche abzubrechen.

Wenn es da überhaupt eine Lösung gibt, dann würde sie mich echt interessieren.
--
Wer früher stirbt ist länger tot.

Dieser Post wurde am 09.11.2004 um 15:11 Uhr von (un)wissender editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
09.11.2004, 15:17 Uhr
Tommix



Was mir gerade noch durch den Kopf geht:

C++:
    integer<long> a(100);
    integer<short> b(4);

    a+b;


In so einer Situation kann der Compiler gar nicht wissen, was wohin konvertiert werden sollte. Ähnliches gilt, wenn man einen Operator

C++:
  operator T() {return i;}


in die Klasse einbaut. Dann funktioniert zwar alles, aber vermutlich nicht im Sinne des Erfinders.

- Tommix
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
006
09.11.2004, 15:27 Uhr
(un)wissender
Niveauwart


Mit operator T() {return i;} wird halt der eingebaute operator + aufgerufen, nicht virtuals.

C++:
integer<long> a(100);
    integer<short> b(4);

    a+b;



Das geht nicht. a und b sind unterschiedliche Typen.
--
Wer früher stirbt ist länger tot.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
007
09.11.2004, 15:31 Uhr
(un)wissender
Niveauwart


Der Compiler könnte a = 4 + a; schon auflösen, aber:
-er müsste alle Operator+ durchgehen, die ein Objekt vom Typ von a erwarten und ein beliebiges.
- Dann müsste er schauen, wohin er a konverieren kann
-Dann müsste er von alle Optionen raten

In diesem Fall könnte der Compiler das Problem eindeutig lösen, aber allgemein nicht.
Dieser Tempate-Typ-Match-algo ist eh recht kompliziert...
--
Wer früher stirbt ist länger tot.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
008
09.11.2004, 15:50 Uhr
Tommix



Naja, eindeutig kann der Compiler es auflösen, wenn es genau eine mögliche Konvertierung gibt. Du schreibst:

Zitat:

er müsste alle Operator+ durchgehen, die ein Objekt vom Typ von a erwarten und ein beliebiges.


4 ist aber nix beliebiges, ebensogut kann der Compiler versuchen a nach int zu konvertieren. Spätestens beim allgemeinen a+b kann sein, daß die Konvertierung a nach b möglich ist und/oder b nach a oder keins von beiden.

- Tommix
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
009
09.11.2004, 15:54 Uhr
(un)wissender
Niveauwart


Das war auf einen allgemeinen Ansatz bezogen. Ich sag ja, hier konkret kann es der Compiler tun, wenn er es denn könnte.
--
Wer früher stirbt ist länger tot.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 < [ 2 ]     [ C / C++ (ANSI-Standard) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: