wie funktioniert das mit den Template parametern

TDO

hoi... ich weiss auch ned wie man das prob am besten formuliert also verzeiht mal bitte den wenigaussagenden Topic-Titel.

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

LordJaxom

Du könntest sowas machen:

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

TDO

hi, wars nicht so ,dass man innerhalb der template klasse selbst den template parameter weglassen kann? also der Compiler (GCC 4.0 naja G++ halt) meckert ned...

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

CStoll

Fast:

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.

TDO

hmmm ... dieses gebilde mit den 2. template aufrufen hab ich bisjetzt noch nicht gesehen ... koenntest vielleicht bitte erklaeren was genau das macht?

danke dir TDO

CStoll

Kurz: Das erste ordnet die Parameter für die Template-Klasse zu, das zweite für die Methode add_item().