Templates für spezielle Typen anders implementieren

pumuckl

Moin.
Ich habe eine template-funktion (bzw. Methode) etwa folgender Art:

template<class T>
T dosomething(const char* arg1, T& defreturn = T())
  {
  //standardverarbeitung für alle möglichen Typen
  }

Nun möchte ich für den Fall, das T bool ist, eine etwas andere Implementierung schreiben. Wie geht das vonstatten?

C Newbie

Stichwort Template Spezialisierung

template<>
bool dosomething<bool>(const char* arg1, bool& defreturn)
{
  //verarbeitung für bool
}

Was versuchst du denn mit dem Defaultparameter zu bezwecken? Wenn du möchtest dass
der Benutzer bei dem Parameter nichts übergeben muss würde ich lieber einen Zeiger
anstat der Referenz nehmen.

pumuckl

muss ich das auch extra deklarieren in der Klassendefinition?

zum defaultparameter:
T soll vor allem int, float etc. sein. Wenn ich da einen Pointer nehme, müsste ich beim Aufruf was schreiben wie

float dr = 3.24;
float myvalue = marg.dosomething("foo", &dr);

so wies bisher ist sollte es wie folgt gehn:

float myvalue = marg.dosomething("foo", 3.24);

Werner Salomon

Hallo Pumuckl,

So sollte es gehen:

template<class T>
T dosomething(const char* arg1, const T& defreturn = T())
{
    std::cout << "T: " << arg1 << std::endl;
    return defreturn;
}

template<>
bool dosomething< bool >(const char* arg1, const bool& defreturn )
{
    std::cout << "bool: " << arg1 << std::endl;
    return defreturn;
}

int main()
{
    dosomething( "ein int", 42 );
    dosomething( "ein bool", false );
    return 0;
}

wichtig ist noch das 'const Referenz', da Du keine temporäre Variable als nicht const Referenz übergeben kannst. Und bei der Spezialisierung musst Du den optionalen Parameter weglassen; sonst ist es doppelt definiert.

möglich wäre auch die explizite Angabe des Typs beim Aufruf, also etwa so

dosomething< int >( "ein int" );
    dosomething< bool >( "ein bool" );

.. nur beim Microsoft-VC6-Compiler funktioniert das nicht bei der Spezialisierung.

Gruß
Werner

pumuckl

also für meinen Fall ginge das dann wie folgt:
die foo.hpp

class Foo
  {
  //...
  public:
  template <class T>
  T dosomething(const char* name, const T& defreturn = T());
  };

  #include foo_tpl.cxx

foo_tpl.cxx

template <class T>
T Foo::dosomething(const char* name, const T& defreturn)
  {
  //...
  }

template <>
bool Foo::dosomething<bool>(const char* name, const bool& defreturn)
  {
  //...
  }

oder muss ich das "bool dosomething" in der Klassendefinition auch nochmal deklarieren? btw: ist irgendwo festgelegt, was der "defaultkonstruktor" von bool liefert? (also wie defreturn im bool-fall aussieht wenns nicht angegeben wird)

Werner Salomon

Ja, so sollte es funktionieren; wenn Du einen vernünftigen Compiler hast (nicht auf VC6)

das bool() ist definiert mit 0'en gefüllt, also false. Gilt für alle Default-Konstruktoren der eingebauten Typen, sobald der Default-Konstruktor explizit aufgerufen wird.
(soweit ich mich richtig erinnere ; steht irgendwo im Standard)

Gruß
Werner

pumuckl

thx, genau das, was ich brauche