habe grad mal das ausprobiert:

template<template<typename T> typename U>
class bla
{

};

Fehler: Template Argumente müssen eine Klasse bezeichnen

Also wie muss es richtig lauten?

Aber viel wichtiger ist die frage, für was braucht man templates in templates wirklich sinnvoll?

Kann mir vielleicht jmd mal ein gut verständliches beispiel geben?

#include <iostream>
#include <list>
using namespace std;

template<typename T>
struct Summierer
{
	template<template<typename> class TContainer>
	T operator()(const TContainer<T> &container)
	{
		T ergebnis = 0;
		for(typename TContainer<T>::const_iterator iter = container.begin(); iter!=container.end(); ++iter)
			ergebnis += (*iter);
		return ergebnis;
	}
};

int main()
{
	Summierer<int> summiere;
	list<int> test;
	test.push_back(32);
	test.push_back(8);
	test.push_back(10);

	cout << summiere(test) << endl;
	cin.get();
}

#include <iostream>
#include <list>
using namespace std;

struct Summierer
{
    template<typename TContainer>
    typename TContainer::value_type operator()(const TContainer &container)
    {
        typename TContainer::value_type ergebnis = 0;
        for(typename TContainer::const_iterator iter = container.begin(); iter!=container.end(); ++iter)
            ergebnis += (*iter);
        return ergebnis;
    }
};

int main()
{
    Summierer summiere;
    list<int> test;
    test.push_back(32);
    test.push_back(8);
    test.push_back(10);

    cout << summiere(test) << endl;
    cin.get();
}

#include <iostream>
#include <list>
using namespace std;

template<typename T>
struct Summierer
{
    template<template<typename> class TContainer>
    T operator()(const TContainer<T> &container)
    {
        T ergebnis = T();
        for(typename TContainer<T>::const_iterator iter = container.begin(); iter!=container.end(); ++iter)
            ergebnis += (*iter);
        return ergebnis;
    }
};

int main()
{
    Summierer<int> summiereNurTemplateTypenMitIntAlsTemplateTyp;
    Summierer<double> summiereNurTemplateTypenMitDoubleAlsTemplateTyp;

    list<int> test;
    test.push_back(32);
    test.push_back(8);
    test.push_back(10);

	//ok! list<int> als Template-Typ mit int als Template-Typ!
    cout << summiereNurTemplateTypenMitIntAlsTemplateTyp(test) << endl;

    //folgendes geht nicht!!! Template-Typen mit double als Template-Typ sind gefordert!
    //cout << summiereNurTemplateTypenMitDoubleAlsTemplateTyp(test) << endl;

    cin.get();
}

PS: Und noch eine Option: Die STL bietet auch Algorithmen an - z.B. accumulate(), der hier wohl ideal einzusetzen wäre.

#include <iostream>
using namespace std;

class Wurst
{
public:
	static const char *produkt() { return "Wurst"; }
};

class Gehacktes
{
public:
	static const char *produkt() { return "Gehacktes"; }
};

template<typename TProdukt>
class SchweineMetzger
{
public:
	static void produkt() { cout << "Schweine-" << TProdukt::produkt() << endl; }
};

template<typename TProdukt>
class RinderMetzger
{
public:
	static void produkt() { cout << "Rinder-" << TProdukt::produkt() << endl; }
};

template<template<typename> class TMetzger>
class Metzgerei
{
public:
    static void wurst() { TMetzger<Wurst>::produkt(); }
    static void gehacktes() { TMetzger<Gehacktes>::produkt(); }
};

int main()
{
	Metzgerei<SchweineMetzger>::wurst();
	Metzgerei<SchweineMetzger>::gehacktes();
	Metzgerei<RinderMetzger>::wurst();
	Metzgerei<RinderMetzger>::gehacktes();

    cin.get();
}

Die Metzgerei nimmt einen Metzger als Template-Template-Parameter. Dieser kann dann von der Metzgerei mit Produkten konfiguriert werden, indem sie ihm als Template-Parameter übergeben werden.

//...
template<template<typename> class TMetzger>
class Metzgerei
{
public:
    template<typename TProdukt>
    static void produkt() { TMetzger<TProdukt>::produkt(); }
};

int main()
{
    Metzgerei<SchweineMetzger>::produkt<Wurst>();
    Metzgerei<SchweineMetzger>::produkt<Gehacktes>();
    Metzgerei<RinderMetzger>::produkt<Wurst>();
    Metzgerei<RinderMetzger>::produkt<Gehacktes>();

    cin.get();
}