Fragen stehen im Kommentar.

Gruß

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

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

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
}

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

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.

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.