Problembeschreibung:
In meinen Programm wird mit dem Type Double gerechnet. Für das Schreiben und Einlesen der Daten gibt es aber Verschiedene Wertebereiche.
Als Beispiel Nehmen wir mal x/y Koordinaten. Diese können einen Wert von 1000 bis -1000 haben. Dann noch Größen width/height. Die einen Wert von 1000 bis 0 haben.
Beim Einlesen sollen diese Wertebereiche auch Überwacht werden und noch eine Werte-Abhänge Dinge gemacht werden.
Dazu wollte ich eine Template Funktion in der Stream Klassen aufnehmen bei den der Template Parameter als Schalter dient. Hier ein Funktionierendes Beispiel.

enum eType
{
  eType_Cord,
  eType_CordUnsigned,
};

struct Stream
{ 
  template < eType e >
  void attribute( double & Data ) {}
};

struct DataPacket
{
  void serialize( Stream &Stream)
  {
    Stream.attribute< eType_Cord > (mX);
    Stream.attribute< eType_CordUnsigned > (mWidth);
  }

  double  mX;
  double  mWidth;
}

int main(int Argc, char **ppArgv)
{
  Stream St;
  DataPacket Data;

  Data.serialize( St );

  return 0;
}

Soweit so gut. Funktioniert. Jetzt aber zu den Problem.
Die Serialize Funktion muss mit unterschiedlichen Streams zurecht kommen. Also wird diese als Template Versehen. Und jetzt kann der Compiler das nicht mehr Auflösen. Wieso ???

struct DataPacket
{
  template< typename stream >
  void serialize( stream &Stream)
  {
    Stream.attribute< eType_Cord > (mX);
    Stream.attribute< eType_CordUnsigned > (mWidth);
  }

  double  mX;
  double  mWidth;
}

Gemeldeter Fehler.
"kein operator '<' (eType_Cord)u0 für St.attribute gefunden"

Kann mir vielleicht jemand das Verhalten erklären?

Lichtlein

Ich habe da Mindestens 1 Stunde dran herum gemacht und war so Dicht dran.
Mein Lösungsansatz war:

Stream.template <> attribute< eType_Cord > (mX);

Achtung, man beachte die größer/kleiner Zeichen hinter den template.

Danke.

Lichtlein

PS: Vielleicht sollte man Abends um 11Uhr nicht mehr versuchen solche Probleme zu Lösen.

Stream.template attribute< eType_Cord > (mX);

Das hab ich ja noch nie gesehen? Taucht dies und ::template und ->template in der Praxis häufig auf? Nicht oder?

Hier mal mein Beispiel der Attribut Funktion wie sie dann auch fast so Benutzt wird.

template< eAppType e >
cArchivOut& attribute(const char * pName, 
                      typename sEnum2Type< e >:: type & Value,
                      const typename sEnum2Type< e >::type & DefautlValue)
{
  assert( sTypeTraits< e >::rangeCheck( Value ) );
  if(Value != DefaultValue)
  {
    mOut << pName << '=' << Value << " // "; 
    mOut << sTypeTraits< e >::attributeComment() << std::endl;
  }
  return *this;
}

Damit kann man schon einige Nette Sachen machen.

Das dann aufzurufen sieht dann im Code so aus.

template< typename archiv >
archiv& serialize( archiv &Archiv)
{
  Archiv.template attribute< eAppType_Cord >("X", mX)
        .template attribute< eAppType_Cord >("Y", mY)
        .template attribute< eAppType_CordUnsigned >("Width", mWidth)
        .template attribute< eAppType_CordUnsigned >("Height", mHeight);
  return Archiv;
}

Ich denke da kann ich mich sehr gut dran gewöhnen.

Lichtlein

Taucht dies und ::template und ->template in der Praxis häufig auf? Nicht oder?

Kommt auf deine Praxis an. Wenn du template-Member(funktionen) in deinen Klassen hast, wirst du es sicher oft benötigen. Es ist ein Element der Sprache so wie typename und man sollte sich merken, dass es das gibt. Ich habe es jedoch noch nie außerhalb des Forums benötigt.