Problem ist folgendes

template<class Aktion>
    class MenuItem
    {

        int id;
        Aktion action;
        std::string title;
		std::vector<MenuItem> childs;

    public:
        /*Konstruktoren*/
	//Nur zum testen
	MenuItem(){}

        MenuItem(Aktion &act) :action(act), title("")
        {}
        MenuItem(std::string &moep, Aktion &act): action(act), title(moep)
        {}

        /*Destruktor*/
        ~MenuItem(){}

        /*Getter*/
        const std::string& get_title() const { return title; }
        int get_id()const { return id; }

        /*Setter*/
        void set_title(const std::string& foo) { title = foo; }

        /*Sonstige Methoden*/
        void add_child(const std::string &title_, Aktion &act);
        void add_child(const MenuItem &);
        // wird grad eigentlich ned gebraucht koennte aber evl. noch
        // nuetzlich sein
        /*bool operator<(const MenuItem &child)const {
            return id < child.get_id();
        } */
		typename std::vector<MenuItem>::const_iterator end()const;
		typename std::vector<MenuItem>::const_iterator begin()const;
		bool empty()const;
        void print()const;
    };

so sieht erstmal die klasse der Menuelemente aus.
und so die des menues an sich:

template<class T>
    class ConsoleMenu
    {
        std::vector<T> items;

    public:
        ConsoleMenu(const T &foo) : items() {
            items.push_back(foo);
        }
        ConsoleMenu() : items(){}
        ~ConsoleMenu(){}
        void add_item(const std::string &);
        void add_item(const T &);
        void draw();
	private:
		void do_draw(const T &);
    };

Problem is nu folgendes ... in den methoden add_item() von Menu::ConsoleMenu muesste ich ja noch das Template argument von MenuItem mit uebergeben so das es ca. so aussehen muesste:

void add_item(const std::string &, Aktion &);

aber dazu muesste ich ja zur Menu::ConsoleMenu Klasse noch einen zusaetzlichen Template parameter hinzufuegen.

Die frage lautet also ... kann man diesen zusaetzlichen Template parameter irgendwie vermeiden/umgehen ?

ich hoffe irgendjemand hat verstanden was ich zu fragen versuche

aufjedenfall erstmal nen danke fuers lesen

gruesse TDO

template<class Aktion> void add_item(const std::string &, Aktion &);

Der Kompiler ersetzt den Templateparameter dann selbst, wenn Du als zweiten Parameter eine Aktion angibst.

Hier liegt übrigens ein Fehler:

std::vector<MenuItem> childs;

Es gibt keine Klasse MenuItem, nur eine Klasse MenuItem<Aktion>...
EDIT: Bzw. pro Aktion eine Klasse MenuItem<Aktion>, also mehrere

aber ,dass mit dem ersetzen hab ich ned gewusst .. danke werd ich gleich ausprobieren sobald ich wieder daheim bin.

also ist es richtig ,dass das ganze dann ca so ausehen wuerde:

in der classe:

template<class Aktion> void add_item(const std::string &, Aktion &);

und ausserhalb der Klasse dann die Definition:

template<class T, class Aktion> 
void Menu::ConsoleMenu<T>add_item(const std::string &moep, Aktion &blub)
{ /* ... */ }

danksche ... und gruesse TDO

template<class T> template<class Action>
void ConsoleMenu<T>::add_item(const string& name,Action& act)
{
  ...
}

btw könnte dein Design ein Problem damit haben, daß unterschiedliche MenuItem-Spezialisierungen voneinander unabhängig sind.

danke dir TDO