ich baue gerade ein Template, dass intern Listen und Vektoren bearbeiten und verwalten soll. Dazu müsste ich aber bei meiner Funktion Iterator-Suchen ein paar Typen unterscheiden. Folgendes habe ich nun versucht:

// Auszug .h
template <typename Arg_Type, typename Inlay_Type>
class ListSort
{
protected:
  Arg_Type* arg1; // Zeiger auf das Objekt, dass verwaltet werden soll.

public:
  /* c'tor */
  ListSort(Arg_Type* newArg);

  /* Position suchen */
  typename Arg_Type::iterator& ListeFindIterator(const size_t& thePosToMove);

  // .. viele andere Funktionen
};

// Auszug .cpp

/* Position suchen */
// -> Für alles was ich nicht unterstütze
template <typename Arg_Type, typename Inlay_Type>
typename Arg_Type::iterator& ListSort<Arg_Type, Inlay_Type>::ListeFindIterator(const size_t& /* thePosToMove */)
{
  return arg1->end();
  // Suchfunktion nicht unterstützt, also end(),
  // damit Funktionsaufrufer aussteigen.
}
// -> Vector
template <typename Arg_Type, typename Inlay_Type>
typename Arg_Type::iterator& ListSort<std::vector<Inlay_Type>, Inlay_Type>::ListeFindIterator(const size_t& /* thePosToMove */)
{
  // Hier kommt dann die eigene Find-Funktion für vector hin.
  return arg1->end();
}
// -> List
// -> etc

// Beispiel für Definition:
typedef MLObject* MLObjectListeInlay;
typedef std::vector<MLObjectListeInlay> MLObjectListe;

MLObjectListe MyListe;
ListSort<MLObjectListe, MLObjectListeInlay> ListeVerwaltung(&MyListe);

Leider stigt mir mein Visual Studio Por 2008 hier mit dem Fehler aus:

error C3860: Eine template-Argumentliste, die dem Klassen-template-Namen folgt, muss Parameter in der in der template-Parameterliste verwendeten Reihenfolge auflisten.
error C2995: "Arg_Type::iterator &ListSort<Arg_Type,Inlay_Type>::ListeFindIterator(const size_t &)": Funktionsvorlage wurde bereits definiert.

Natürlich weiß ich das ein Template universal gestaltet sein soll und das ist auch die einzige Funktion in dem ganzen Klassen-Teplate, die ich für die Typen vector, list, etc unterschiedlich gestalten muss.

Ich hab diese Schreibweise aus verschiedenen Internetseiten und Tutorials übernommen. Leider gibt mir aber keines meiner schlauen Bücher (so aus Papier und gebunden) ein Beispiel dafür, so dass ich vermute, "das Internet lügt".

Wie müsste ich denn richtig schreiben? Wo finde ich (brauchbare) Lektüre für diesen Fall?

Danke,
Stefan

im Prinzip versuchst du ja das hier:

#include <vector>

template <typename T, typename U>
class C {
    void F();
};

template <typename T, typename U>
void C<T, U>::F() {
}

// Geht nicht.
template <typename T, typename U>
void C<std::vector<U>, U>::F() {
}

int main() {
    return 0;
}

(Member-)Funktionstemplates kann man aber nicht einfach so partiell spezialisieren. Dafür muss man erst die Klasse partiell spezialisieren.

Das säh in dem Beispiel dann so aus:

#include <vector>

template <typename T, typename U>
class C {
    void F();
};

template <typename T, typename U>
void C<T, U>::F() {
}

template <typename U>
class C<std::vector<U>, U> {
    void F();
};

template <typename U>
void C<std::vector<U>, U>::F() {
}

In welchem Buch du sowas findest, kann ich dir jetzt auch leider nicht sagen.
Ich denke mal "C++ Templates: The Complete Guide" oder "Modern C++ Design: Generic Programming and Design Patterns Applied" könnten das aber drin haben.

Edit: Hier stehts auch:
http://www.gotw.ca/publications/mill17.htm

Gruß
Dobi

PS: Weiß jemand, ob im neuen Standard (Member-)Funktionstemplates partiell spezialisiert werden können?

Jetzt kommt noch der Praxis-Test.

Grüße,
Stefan

Gruß
Dobi

PS: Es sieht so aus, als sei es mit 0x auch nicht anders.

Glücklicherweise hab ich mein Tamplate jetzt auch so hingekommen, dann ich es nicht mehr spezialisieren muss. std::advance sei dank.