[VS 2003] Probleme mit template-Klassen + globalen Operators

[Olli]

Hi,

ich habe aktuell das Problem, daß ich eine Template-Klasse habe:

Code:

   template<class T>
   class TGenPoint

Diese benutze ich mit <T = int>. Für diese Punktklasse habe ich noch ein paar globale binäre symmetrische Operatoren (+/-) überladen, damit bestimmte Operationen vereinfacht werden. Beispiel operator+():

Code:

   template<class T>
   TGenPoint<T> operator+(const TGenPoint<T>& LValue, const TGenPoint<T>& RValue)
   {
      return TGenPoint<T>(LValue.x + RValue.x, LValue.y + RValue.y);
   }

Komischerweise gibt es keinerlei Probleme dies mit VC6 zu kompilieren und auszuführen. Weil ich aber auf VS 2003 umsteigen muß, habe ich es dort versucht. Das Problem welches jetzt noch bestehen bleibt ist, daß vom Linker alle diese benutzten Operatoren nicht spezialisiert mit <T=int> gefunden werden! Aber wie gesagt: erst vom Linker!

Unter VC6 trat das Problem nie auf und es ist mir ein Rätsel. Die template-Klasse ist zusammen mit den globalen Operatoren direkt in einer Headerdatei deklariert.

Hat jemand eine Lösungsidee?

Danke,

[Olli]

Jetzt bin ich mir sicher, alle Schlechtigkeit der Welt steckt in meinem Rechner (oder Nico hat meinen Rechner gehackt ).

Habe es jetzt folgendermaßen gelöst:

Code:

   template<class T>
   class TGenPoint
   {
   // ...
      friend bool operator==(const TGenPoint<T>& LValue, const TGenPoint<T>& RValue)
      {
         return ((LValue.x == RValue.x) & (LValue.y == RValue.y));
      }

      friend bool operator!=(const TGenPoint<T>& LValue, const TGenPoint<T>& RValue)
      {
         return !(LValue == RValue);
      }

      friend ostream& operator<<(ostream& os, const TGenPoint<T>& pt)
      {
         os << pt.x << "/" << pt.y;
         return os;
      }
   };

Allerdings stellt sich mir jetzt die Frage, ob friend garantiert, daß die Funktion an sich als außerhalb des Scopes der Klasse betrachtet wird. Es sollen immerhin globale Operatoren sein!

[Olli]

Also, um meine Fragestellung nochmal anzupassen:
Gibt es eine Möglichkeit für die friend-Funktionen von template-Klassen den Funktionskörper außerhalb der Klasse zu deklarieren ohne dafür die (Template-)Funktion spezialisieren zu müssen?

[NicoDE]

Ich kann dir zwar (mangels VS71 auf diesem OS) die Frage vorerst nicht beantworten, aber bei Templates benutze ich seit geraumer Zeit .inl für die Implementation von Templates in Headern...

foo.hpp

Code:

//...
class CFoo
{
//...
};
//...
template < class ELEMENT > 
class TFoo : public CFoo
{
//...
            ELEMENT&    operator [] ( int a_iIndex );
    const   ELEMENT&    operator [] ( int a_iIndex ) const;
//...
};
//...
#include    "foo.inl"
//...

foo.inl

Code:

//...
template < class ELEMENT > 
ELEMENT& TFoo< ELEMENT >::operator [] ( int a_iIndex )
{
//...
}
template < class ELEMENT > 
const ELEMENT& TFoo< ELEMENT >::operator [] ( int a_iIndex ) const
{
//...
}
//...

Copy 'n Paste; Fehler inklusive

[Olli]

Include ist ne Idee. Allerdings macht dessen Verwendung bei mehreren Klassen in meinem Header auch mehrere Dateien oder Präprozessordirektiven (dafür müßte ich nachdenken! ) nötig. Fällt also flach wegen is nicht. Zumindest solange wie es mit der aktuellen Variante geht. Bei Template-Klassen und -Funktionen kann man sowieso nicht Implementation und Deklaration sinnvoll trennen

Außerdem geht deine Methode etwas an meiner Frage vorbei. Es geht ja nicht um Methoden der Klasse, bei denen ich Rumpf und Kopf trennen will, sondern vielmehr um friends, welche als globale Operatoren dienen sollen. Und genau da weigert sich mein VS einen solchen globalen Operator als friend-Templatefunktion zuzulassen. Der Linker findet sie einfach nicht, weil sie offenbar nicht explizit spezialisiert (<T = int>) wurde.

Die verbleibende Frage ist eben, ob mit der aktuellen Methode a.) friend ignoriert wird, oder b.) friend dazu dient daß die jeweilige Funktion als außerhalb des Scopes der Klasse betrachtet wird.

Und gib es zu, daß du's warst ...

Zitat von Olli:

(oder Nico hat meinen Rechner gehackt ).

[NicoDE]

Zitat von Olli:

Die verbleibende Frage ist eben, ob mit der aktuellen Methode a.) friend ignoriert wird, oder b.) friend dazu dient daß die jeweilige Funktion als außerhalb des Scopes der Klasse betrachtet wird.

Ich kaufe ein B.

Zitat von Olli:

Und gib es zu, daß du's warst ...

OK, erwischt

[Olli]

Zitat von NicoDE:

Ich kaufe ein B.

Jut, dann ist die Frage ja damit erledigt. Ich werde sie also jetzt als offen markieren, liebe Moderatoren