2 Fragen über Funkion Templates

Skeptar

#include <iostream>
using namespace std;

template <typename T>   //ist T frei wählbar? Wenn ja kann da auch z.B. "Tem" stehen, oder nur ein Buchstabe
void max(T& test){      //muss T vor jedem stehen oder kann dort auch int stehen?
    test += 5;
}

int main(){
    int test=9995;
    max(test);    
    cout << test;
    return 0;
}

Fragen stehen im Kommentar.

Gruß

Fytch

1. ja der name der template-argumente ist frei wählbar.
2. ja die parameter sind auch frei wählbar.

edit:
folgendes ist korrekt (ob es sinn macht sowas zu schreiben ist eine andere frage):

template<typename Foo>
void f(int Param)
{
}

wxSkip

Wenn da int stünde, dann könntest du der Funktion auch nur int-Parameter übergeben.

Skeptar

Und bei z.b. t lege ich den Typ nicht genau fest?
Sondern es wird einfach der alte übernommen?

wxSkip

Wenn du ein Funktionstemplate verwendest, willst du ja, dass die Funktion mit mehreren/allen Typen aufgerufen werden kann. Der Compiler erstellt dann praktisch für jeden Typ, mit dem die Funktion aufgerufen wird, eine eigene Funktion, bei der dann der Template-Typ T (oder wie du ihn auch immer nennst) durch den konkreten Typ ersetzt wird.

hustbaer

@Skeptar
Wenn du

template <typename T>

schreibst, dann leitest du damit die Definition eines Templates (=> Vorlage) für etwas ein. In deinem Fall ein Template für Funktionen.

Und zwar ein Template das in deinem Fall einen Parameter hat, und zwar einen "Typ-Parameter".
Du kannst dann diese Vorlage verwenden um Funktionen zu definieren.
Dazu müssen alle Template-Parameter festgelegt werden.

In deinem Beispiel ( max(test) , wobei test ein int ist), sucht der Compiler den passenden Typ für T aus, nämlich int . Beim Erzeuden der Funktions-Definition ersetzt der Compiler dann alle T mit int .
Deine Funktion wird also zu:

void max(int& test){
    test += 5;
}

Natürlich kannst du die Template Parameter auch mehrfach verwenden, z.B.

template <typename T>
void print(T a, T b){
    std::cout << a << ", " << b << "\n";
}

Dabei steht T allerdings immer für den selben Typ.
D.h. folgendes wird nicht funktionieren:

template <typename T>
void print(T a, T b){
    std::cout << a << ", " << b << "\n";
}

int main() {
    int x = 4;
    int y = 2;
    float z = 1;
    print(x, y); // OK, T = int
    print(x, z); // Was soll T jetzt werden - int oder float? => Compiler-Fehler
}

Wenn du willst dass "a" und "b" unterschiedliche Typen haben können, und beide nicht festgelegt sind, dann muss dein Template auch zwei verschiedene Typ-Parameter haben:

template <typename T, typename U>
void print(T a, U b){
    std::cout << a << ", " << b << "\n";
}

int main() {
    int x = 4;
    int y = 2;
    float z = 1;
    print(x, y); // OK, T = int, U = int
    print(x, z); // OK, T = int, U = float
}

Bzw. du kannst die zu verwendenden Template-Parameter auch explizit angeben. Dann geht auch die Variante mit nur einem Template-Parameter wieder:

template <typename T>
void print(T a, T b){
    std::cout << a << ", " << b << "\n";
}

int main() {
    int x = 4;
    int y = 2;
    float z = 1;
    print(x, y); // OK, T = int
    print<double>(x, z); // OK, T = double
}

Skeptar

Wow danke für diese ausführliche Erklärung!

Skeptar

Ich bin jedzt bei dem Überpunkt
"Spezialisierung von Templates"
Und ich hänge mal wieder

Mein Code:
Main.cpp

#include <iostream>
#include "schablonen.t"
#include <conio.h>

using std::cout;
using std::cin;

int main(){
    int a, b;
    cin >> a >> b;
    cout << maxi(a,b);
    return 0;
}

schablonen.t

#ifndef SCHABLONEN_T
#define SCHABLONEN_T

#include <string>
using std::string;

template<>
string maxi(int a, int b) {
    if(a<b){
        return "A ist groesser";
    }
    else if(a<b){
        return "B ist groesser";
    }
    else{
        return "Beide sind gleichgroß";
    }
}

#endif

Fehlermeldung: "maxi ist keine Templatefunktion"
"maxi wurde nicht in diesem Gültigkeitsbereich definiert"

Und direkt noch eine Frage: Im Buch steht eine Template Datei ist oder kann eine .t Datei sein. Was sollte ich nehmen? Eine normale .cpp oder doch .t?

Ich hoffe es guckt noch jemand in diesen Thread

...

Die erinnerung

Skeptar schrieb:

template<>
string maxi(int a, int b) {
    if(a<b){
        return "A ist groesser";
    }
    else if(a<b){
        return "B ist groesser";
    }
    else{
        return "Beide sind gleichgroß";
    }
}

Das ist ja mal das beste Template aller Zeiten.
Entweder du lässt das Template weg. Denn momentan ist deine Funktion keine Templatefunktion und der Compiler hat sein gutes Recht dir das anzukreiden!
Oder du verwendest das Templat, wie es sich gehört:

template<typename T>
string maxi(T a, T b) {
// ...
}

Skeptar schrieb:

Und direkt noch eine Frage: Im Buch steht eine Template Datei ist oder kann eine .t Datei sein. Was sollte ich nehmen? Eine normale .cpp oder doch .t?

Die einzigen zwei Endungen, die man "eigentlich" verwendet, sind .h (für Header) und .cpp (für Quelldateien). Wobei dem Compiler ist es eigentlich ziemlich egal, welche Datei welche Endung. Man verwendet diese 2 Endungen aus Prinzip.

hustbaer

Es muss if(b<a) heissen wenn die Funktion nicht lügen soll.

Und natürlich kannst du ein Template erst spezialisieren, nachdem du es definiert bzw. deklariert hast.

Also z.B.

template<typename T>
string maxi(T, T); // Wir müsen hier keine Implementierung angeben,
                   // aber bekanntmachen dass es das Template überhaupt gibt müssen wir schon.

// Und JETZT können wir das Template spezialisieren

template<>
string maxi(int a, int b) {
    if(b<a){
        return "A ist groesser";
    }
    else if(a<b){
        return "B ist groesser";
    }
    else{
        return "Beide sind gleichgroß";
    }
}

Und ich würde .h, .hpp oder .inl empfehlen. Das wären die "üblichen" Extensions.