Grundverständnis bei templates



  • Hallo liebe Programmierer, Ich habe eine Verständnisfrage zu Funktionstemplates,
    Funktions-Templates:
    Erklärung aus Wikipedia

    Ein Funktions-Template (auch fälschlich Template-Funktion genannt) verhält sich wie eine Funktion, die Argumente verschiedener Typen akzeptiert oder unterschiedliche Rückgabetypen liefert. Die C++-Standardbibliothek enthält beispielsweise das Funktions-Template std::max(x, y), welches das größere der beiden Argumente zurückgibt. Es könnte etwa folgendermaßen definiert sein:

    template <typename T>
    T max(T x, T y)
    {
      T value;
      if (x < y)
        value = y;
      else
        value = x;
      return value;
    }
    
    template <typename T>
    bool isPositive(T x)
    {
        return x > 0;
    }
    

    Ich habe das Grundprinzip wie es für Funktions-Templates erklärt ist verstanden, habe aber Probleme mit
    der Syntax, also die Syntax richtig zu interpretieren. Damit meine Ich : Es ist mir klar ein template
    kann den Funktionsauftrag für unterschiedliche Datentypen ausführen , ist also eine Vereinfachung/Weiterentwicklung
    beim Programmieren etc. ...
    in der Syntax sind hierbei template und typename Schlüsselwörter, aber was bedeutet das T
    kann Ich es beliebig wählen oder ist es eine Vorgabe. Der Compiler bräuchte doch nur -ein- Schlüsselwort um
    zu wissen ok , was jetzt kommt kann halt jeder Datentyp sein ?
    Die Funktion oben hat doch schon in dem template einen Namen nämlich max(T x ...
    ?


  • Mod

    T ist ein beliebiger Name, der die gleichen Regeln wie alle anderen identifier zu befolgen hat. Jedoch ist T für Typ-Parameter in Templates dasselbe wie i für ints.



  • Ok, also ein Überbegriff/Name für die Sammlung an Funktionen in dem template ? wenn es z.B inkludiert wird ist ja eine Bezeichnung nötig? Danke!
    Das der Compiler bei der Sammlung von Funktionen in dem jeweiligen template alle Datentypen akzeptieren soll, folgt dann sehrwahrscheinlich
    aus dem Schlüsselwort selbst.

    muss das T in Typparameter mit dem Namen übereinstimmen ?
    wobei das kann Ich im Zweifel dann auch ausprobieren
    Danke für die Hilfe!



  • Man kann auch Templates mit mehreren (verschiedenen) Template-Parametern erstellen und damit man diese eindeutig unterscheiden kann, muß man dann dieselben Identifer im Code wie im Kopf verwenden:

    template<typename T, typename U>
    void f(T a, U b)
    {
      T x = a;
      U y = b;
    
      // ...
    }
    


  • wo ist dann der Unterschied zu

    template<typename T>
    void f(T a, T b)
    {
      T x = a;
      U y = b;
    
      // ...
    }
    

    template bedeutet doch, dass man der Funktion jeden Datentyp übergeben kann
    ohne diesen vorher festzulegen? So hatte Ich es verstanden
    ob typename T oder U beides steht für alle Datentypen ?
    man kann das glaube Ich nur durch programmieren verstehen ?



  • template<typename T>
    void f(T a, T b);
    
    // ...
    f(0, 0); // wird ausgewertet zu f<int>(0, 0)
    
    f(0, 0.0); // wird zu f<double>(0.0, 0.0)
    

    Wenn die Argumente keine passende implizite Konvertierung aufweisen, dann gibts en Fehler. Z.B.:

    f(0, nullptr) // Compiler denkt "??"
    

    Hingegen:

    template<typename T, typename U>
    void f(T a, U);
    

    Da können beide Argumente komplett unabhängig sein, d.h. das geht alles:

    f(0, 0); // -> f<int, int>
    f(0, 0.0); // -> f<int, double>
    f(0, Foo()); // -> f<int, Foo>
    


  • Danke!


Log in to reply