Leider kann ich meine Frage n ausführlicher formulieren aber:

Was bringt es mir, den Typnamen festzulegen?

ich verstehe das Prinzip und die Anwendung von Templates aber was mich durcheinanderbringt, ist, dass man den internen Typen-vars namen geben kann.

(ich weiß nicht genau, ob ich Dich richtig verstanden habe, aber versuche es mal)
Man gibt den Typen (oder daraus abgeleiteten) Namen, damit man einfach von außerhalb darauf referenzieren kann.
Wenn Du schonmal vector<int>::const_iterator o.ä. verwendet hats, wirst Du froh gewesen sein, nicht den tatsächlich dahinter stehenden Ausdruck verwenden zu müssen.
Außerdem gibt es einem eine gewisse Flexibilität mehr..stell' es Dir einfach als eine weitere Indirektion vor.

Gruß,

Simon2.

template<typename T>
void sinn(const T& obj)
{
   typename T::iterator it;
   ...
}

Den Template-Typeparameter muss du nicht unbdingt mit typename defnieren, da kann genauso gut class stehen.

Aber in der Funktion musst du das typename schreiben, weil iterator ein Typ ist.
Stell dir mal vor du würdest sowas schreiben.

template<typename T>
void sinn(const T& obj)
{
   T::iterator *it;
   ...
}

Was siehst du ?? Einen Zeiger auf einen Iterator, aber woher soll der der Compiler wissen. Er könnte genauso gut annehmen das T::iterator eine statische Variable ist ( in der Regel geht er von Anfang an davon aus das es sicht nicht um einen Typen handelt) und it könnte ne globabale Variable sein.

Dann würde ja da eine Multiplikation stehen
Deswegen das typename davor ...

Also ich meine diese Zeile

Template <typename T> wieso kann ich hier soviele bezeichner haben für einen Typ?

wieso is (nur bsp) nicht einfach type oder ein anderes Schlüsselwort/ein anderer Bezeichner da? Es wird doch nicht ohne Grund sein, dass ich hier frei wählen kann oder?

Sry wenn das ne blöde Frage is, beschäftigt mich aba wirklich

EDIT: ist es deswegen damit man unbeschränkt viele Arten von Typen anführen kann?

sorry, wenn das jetzt hart klingt, aber ich habe den Eindruck, dass Du den Sinn von templates noch nicht verstanden hast (falls doch, darfst Du gerne mein Post hier abbrechen).

templates sind dafür da, Dinge, die man für unterschiedliche Typen machen möchte, nur einmal definieren zu müssen. Da man bei der implementierung des templates aber trotzdem hier und da den Typen benennen muß, führt man eben einen entsprechenden Bezeichner ein, der hier nicht eine Variable, sondern einen Typen bezeichnet (also nicht "laenge", sondern "int").
Minibeispiel: Ich brauche (warum auch immer) eine Art "doppelter Addition" für integer und strings. Eigentlich brauche ich dafür zwei Methoden:

int doppeltAddieren(const int& a, const int& b) {
    int ergebnis = a + b + b;
    return ergebnis;
}

std::string doppeltAddieren(const std::string& a, const std::string& b) {
    std::string ergebnis = a + b + b;
    return ergebnis;
}

... und wenn ich das nochmal für doubles brauche, schreibe ich das nochmal und für jeden anderen Typen jeweils nochmal.
Mit template schreibe ich dagegen nur einmal:

template <typename T>
T doppeltAddieren(const T& a, const T& b) {
    T ergebnis = a + b + b;
    return ergebnis;
}

... und bin fertig für alle Typen (die einen operator+() haben) !
Syntaktisch muß ich aber den Typ benennen (für den Rückgabetypen und die lokale Variable) ... also brauche ich dafür einen Namen und dafür nehme ich eben "T" (könnte auch "Simon2", "muhi" oder irgendetwas Anderes nehmen).

Syntaktisch braucht man das "typename", weil man templates auch mit konkreten Typen (z.B. int) definieren kann:

template <typename T, int V>
T doppeltAddieren(const T& a, const T& b) {
    T ergebnis = a + b + V;
    return ergebnis;
}

(ist allerdings etwas seltener zu gebrauchen).

Gruß,

Simon2.