HeaderFile

class SortElement {
public:    
    void Print(TContainerItor first, TContainerItor last, std::ostream &out);
    TVectOfPairs mVect;
private:
};

CPP File

template<typename TContainerItor> void SortElement::Print(TContainerItor first, TContainerItor last, std::ostream &out) {
    std::copy(first, last, std::ostream_iterator<TPairOfValues>(out, " "));
}

main

Elements.Print(Elements.mVect.begin(),Elements.mVect.end(), std::cout);

erkennt der compiler um welchen typen es sich handelt oder muss ich beim aufruf der funktion den typen noch mitgeben ? und wenn ja wie ?

herzlichen dank schon mal im voraus

Header:

class XYZ{
    template<typename Type>
    void foo(const Type& );
};

#include "myimpl.impl"

.impl-Datei:

template<typename Type>
void XYZ::foo(const Type& ){
    ...
}

definiere können dann andere funktion keine template variablen besitzen ? und kann ich es dann im cpp initialisieren ?

Wenn Du eine Template-Klasse hast, kannst Du diese Klasse nur im Header, oder in einer .impl-Datei definieren. Auch wenn die Template-Klasse keine Template-Methoden besitzt.

Und ja, eine Template-Klasse darf auch eine Template-Methode besitzen. Sieht dann so aus:

template<typename A>
class XYZ{
    template<typename B>
    void foo(const B& );
};

template<typename A>
template<typename B>
class XYZ<A>::foo(const B& ){
    ...
}

Bei meinem Beispiel: Ersetze in Zeile 9 das Schlüsselwort class durch void.
Die Beispiele die ich hier vorzeige sind dahingekritzelt und ungetestet.

Danke das hab ich dann doch verstanden und wenn nun die klasse noch eine membervariable hat die als typ ein template hat ?

ahh okey ich seh ein licht am ende des tunnels... noch eine frage hat die endung irgend einen einfluss .impl oder könnte das jede endung haben ?

Sollte *.impl sein. Es gibt auch noch andere Dateiendungen die das Gleiche bewerkstelligen, aber diese kannst Du auch gut selber googeln

und wenn nun die klasse noch eine membervariable hat die als typ ein template hat ?

Ja, was soll damit sein? Wenn die Frage auf "funktioniert das?" hindeutet, dann ja.

Sowas wie

template<typename Type>
class XYZ{
    std::vector<Type> vector;
};

kompiliert einwandfrei.

Danke das hab ich dann doch verstanden und wenn nun die klasse noch eine membervariable hat die als typ ein template hat ?

Ein Template ist kein Typ, sondern ein Template. Ein Template musst du spezialisieren um einen Typ zu haben.

Ein Template musst du spezialisieren um einen Typ zu haben.

instanziieren

Sone schrieb:

Ein Template musst du spezialisieren um einen Typ zu haben.

instanziieren

template <...> class T;

T ist das Template, T<4> o.ä. wäre die Spezialisierung. Du spezialisierst das Template mit einer Parameterliste und hast den Typ - die Klasse T<4>.

Oder was hab ich da falsch verstanden?

// Allgemeiner Fall
template <typename T, int N>
struct X {};

// Partielle Template-Spezialisierung
// Ein Teil der Template-Parameter ist eingesetzt
template <typename T>
struct X<T, 5> {};

// Vollständige Template-Spezialisierung
// Alle Template-Parameter sind eingesetzt
template <>
struct X<int, 5> {};

An instantiated template specialization can be either implicitly instantiated for a given argument
list or be explicitly instantiated. A specialization is a class, function, or class member that is either
instantiated or explicitly specialized.

Instantiierung ist der Prozess, um eine Spezialisierung zu erzeugen - explizite Spezialisierung gibt die Spezialisierung vor.

Dann hast du Recht. Ich hätte das dranhängen einer Parameterliste an einen Templatenamen als spezialisieren bezeichnet, aber das ist dann verwirrend wenn man von expliziter Spezialisierung redet.

Instantiierung ist der Prozess, um eine Spezialisierung zu erzeugen

Hä?

Sone schrieb:

Instantiierung ist der Prozess, um eine Spezialisierung zu erzeugen

Hä?

Lies das Zitat. Eine instantiierte Spezialisierung ist eine vom Compiler generierte Spezialisierung eines Templates. Eine Spezialisierung kann aber auch durch eine explizite Spezialisierung vom User vorgegeben werden, dann muss der Compiler diese Spezialisierung nicht instantiieren.

template<typename> class T {}; // Template-Deklaration eines Klassentemplate T.

template<> class T<int> {}; // Explizite Spezialisierung.

template class T<char>; // Explizite Instantiierung - die Instantiierung von T<char> wird erzwungen. 
                        // Da meine explizite Inst. nicht mit extern beginnt, ist es eine explizite Instantiierungsdefinition - 
                        // daher würden theoretisch alle Member von T<char> ebenfalls instantiiert werden.

T<T<int>> t; // Implizite Instantiierung: Genau hier wird vom Compiler anhand der simple-template-id festgestellt, dass die vollständige Definition der Spezialisierung T<int> benötigt wird.
          // >> [...] the class template specialization is implicitly instantiated when the specialization is referenced in a context that requires a completely-defined object type [...]

T<char> t2; // Da bereits eine Intantiierung der entsprechenden Spezialisierung durch explizite Instantiierung erzwungen wurde, wird hier nichts mehr instantiiert.
            // >> Unless a class template specialization has been explicitly instantiated (14.7.2) or explicitly specialized (14.7.3),
            // >> the class template specialization is implicitly instantiated [...]

@Nexus: Ahh, hier sind die Begrifflichkeiten:

Template arguments can be specified when referring to a function template specialization by qualifying the
function template name with the list of template-arguments

Ich meinte, du musst den Templatenamen mit der Argumentenliste qualifizieren um einen Typ zu haben.
Was ich nebenbei auch fand: Eine schöne Bezeichnung für Klassentemplates, parametrisierte Typen.

Halte dich einfach an die üblichen Bezeichnungen, dann wirst du auch verstanden. Mit "parametrisierte Typen" verwirrst du erstmal jeden...

Ich fand nur die Bezeichnung schön, ich würde doch niemals parametrisierte Typen statt Klassentemplate sagen!
(Mit schön meinte ich, nicht gut verständlich und jedem bekannt o.ä., sondern trefflich beschreibend)

Gerri84 schrieb:

ok thx damit sind alle unklarheiten beseitigt

Ignorier' einfach die letzten Posts, mein Fehler. (Sonst kommen wieder Unklarheiten auf)

Omen2 schrieb:

Gerri84 schrieb:

ahh okey ich seh ein licht am ende des tunnels... noch eine frage hat die endung irgend einen einfluss .impl oder könnte das jede endung haben ?

Sollte *.impl sein. Es gibt auch noch andere Dateiendungen die das Gleiche bewerkstelligen, aber diese kannst Du auch gut selber googeln

GCC nutzt .tcc - was heißt das überhaupt? template....?

template <typename T, typename U> struct foo; // Primärtemplate
template <typename T, typename U> struct foo<T,U>; // ill-formed, Argumentliste ist identisch zur (impliziten) Liste des Primärtemplates
template <typename T, typename U> struct foo<U,T>; // ok, aber wahrscheinlich sinnlos
template <typename T, typename U, typename V> struct foo<T(U), V>; // Parameterliste ist länger

Eine explizite Spezialisierung eines (Klassen-, Funktions-, Alias-) Templates ist eine Klasse/Funktion/Typ, in dem die formalen Argumente des Templates mit konkreten Argumenten ersetzt wurden.

In der Deklaration eines Primärtemplates folgt dem Namen des Templates keine Argumentliste.
In der Deklaration eine Spezialisierung eines Templates folgt dem Namen des Templates eine Argumentliste.
Ist in der Deklaration die Parameterliste einer Spezialisierung leer, handelt es sich um eine explizite (vollständige) Spezialisierung.

Abgesehen von den obigen Umständen, verweist ein Templatename, dem eine Argumentliste folgt, stets auf eine explizite Spezialisierung (also Klasse/Funktion/Typ).
Wird ein Templatename nicht von einer solchen Liste gefolgt, so verweist er in der Regel auf das Template, aber u.U. auch ggf. auf eine explizite Spezialisierung (der Name eines Klassentemplates innerhalb seiner Definition ggf. auf die gegenwärtige Instanz, bzw. bei einem Funktionstemplate, wenn die Templateargumente deduziert werden können), wenn der Kontext das verlangt.

Die Instantiierung eines (expliziten) Templatespezialisierung ist äquivalent zur Verarbeitung der Definition einer normalen Klasse/Funktion (eine formale Definition wird nicht gegeben), aus einer gegeben Templatedefinition heraus. Eine solche Instantiierung kann implizit oder explizit erfolgen.
Wurde eine explizite Templatespezialisierung deklariert, so erfolgt keine Instantiierung dieser Spezialisierung (bzw. das Programm ist ggf. ill-formed, falls die Instantiierung bereits vor der Deklaration/in einer anderen ÜE erfolgte); bei Verwendung dieser Spezialisierung muss sie auch separat (vom Template) definiert werden.

Verwirrung stiftet wahrscheinlich die Tatsache, dass das Wort Spezialisierung allein mehrdeutig sein könnte: ist die jeweilige Entität (Klasse/Funktion/Typ) gemeint, oder aber die Deklaration derselben. Im Standard ist immer Ersteres gemeint. Aus diesem Grund taucht specialize auch nicht als Verb auf (außer in zwei Beispielen, deren Text sicher irgendwann mal überarbeitet wird).

danka danke für so viel input und trotzdem bleiben fragen kann ich ein template auch für liste/vector verwenden ?

Frage bitte präzisieren.

class Tst
{
  std::vector<int> bla;
  std::list<int> blubb;
};

template <class T>
class Tst
{
  std::vector<T> bla;
  std::list<T> blubb;
};

als liste oder vector

Listen willst du eigentlich nie. Listen sind oberlahm verglichen mit anderen Container.

Verwende std::vector wenn möglich, std::deque (std::stack/std::queue) oder std::map/std::set bei Spezialwünschen. Wenn du meinst, eine std::list zu brauchen, frag nochmal hier im Forum nach.