Unterschiedliche Templates, wie speichern?

Firefighter

Morgen Leute,

für die Uni will ich mir grad etwas schreiben um mit Konsolenargumenten besser umgehen zu können. Ich weiß das es boost::spirit für sowas gibt, aber verwenden dürfen wir leider kein boost(mich regts auch massiv auf).

Jetzt hab ich mir überlegt einfach eine "Option" zu modelieren. Eine Option soll somit aus einem Namen( -r, test,-remove o.ä.) und einem Indikator ob die Option optional oder nicht ist, bestehen.

Vielleicht etwas Code zur Untermalung

class Option
{
	private:
		bool optional;
		std::string optionName;

	public:
		Option(const std::string& name, bool optional = false):optional(optional),optionName(name){};

	public:
		const std::string& getName() const {return this->optionName;}
		bool isOptional() const {return this->optional;}
		bool empty() const {return this->optionName.empty();}
};

Vielleicht kommen noch paar Sachen hinzu, mal sehen was die Modelierung noch alles bringt.

Nun ist es ja so das man eine Option am besten mit einem Options-Wert verknüpfen können sollte. Also einen Wert den die Option annehmen sollte. Da hab ich mir gedacht das ganze Als Template aufzuziehen:
Hier das gerüst, ich bin da leider noch nicht weiter gekommen:

template<class ValueType>
class OptionValue
{
	private:
		Option opt;

	public:
		typedef ValueType value_type;

};

Der Options-Wert bekommt auch noch die Fähigkeit eine Gültigkeitsprüfung für den Wert zu machen den er später darstellen soll, z.B. das sich eine Zahl nur in einem bestimmten Intervall aufhält.

Ich überleg auch die ganze Zeit die Option direkt als Template zu machen und den Optionswert da mit reinzuziehen aber das kann man ja noch nachholen.

Jetzt die eigentliche Frage, später im Code will ich mehrere Optionen mit Optionswerten erstellen.

OptionValue<int> v1;
OptionValue<double> v2;
OptionValue<std::string> v3;
//usw

Jetzt stellt sich die Frage für mich, wenn ich später einen OptionParser habe, der soll ja die diversen Optionen mit Options-Werten entgegen nehmen können und validieren, wie krieg ich nun verschiedene Klassen-Templates( oder war es Template-Klassen, ich verwechsel es immer) in den Parser?

Hoffe das war verständlich, vielleicht muss ich auch nochmal an der Modelierung etwas rumschrauben. Eventuell habt ihr ja Tipps.

boost::spirit? Ne, dafür gibts Boost.ProgramOptions: www.boost.org/doc/html/program_options.html. Vielleicht kannst du dich daran orientieren.

Und zum Problem: Du kannst auch Klassentemplates von normalen Klassen erben lassen. Wobei man das in C++11 wohl ganz anders machen würde.

Firefighter

Hm Ok, ich hab mir das mal angeschaut. Und mir ist dort etwas aufgefallen was ich auch so in etwa bei mir umsetzen wollen würde.

Dieser Mechanismus:

add("name", po::value<int>(),"")

Wie wird es gemacht das ich an die Add-Methode unterschiedliche Value-Instanzen übergeben kann, die müssen das ja intern irgendwo speichern, nur genau da kommt meine Ausgangsfrage ins Spiel. Wie speicher ich unterschiedliche Klassen-templates? Sollte ich das über nicht-templatisierte Basisklasse machen oder wie ist die Vorgehensweiße hier?

otze

Firefighter schrieb:

Sollte ich das über nicht-templatisierte Basisklasse machen oder wie ist die Vorgehensweiße hier?

Es wird normalerweise so gemacht. Alternativ kannst du auch in add() einen Wrappertyp verwenden der das übernennt. Das nennt sich Type-Erasure.

Firefighter

Hmm Type-Erasure ist aber auch nich die feine englische Art finde ich. Aber wenn es nicht anders geht dann werd ich wohl damit leben müssen.
Danke für die Infos.

Firefighter

Hmm das ist doch Kacke mit dem Type-Erasuer. Das Ding ist ja das ich später mit meinem Parser die Optionen möglichst auch füllen will wenn sie denn valide sind. Das geht aber nur wenn ich die korrekten Wert-Typen kenne. Und wenn ich das über eine nicht-templatisierte Basisklasse mache und die als Parameter nutze, gehen mir ja alle Infos flöten die ich brauche -.-

otze

dann lass halt die Option-Klasse ihren Teil parsen.