an die profis mal eine frage:
es sollen parameter verschiedenster struktur behandelt werden. dazu wird eine klasse definiert, die alle parameter-strukturen kapseln soll. sie enthält einzig den typ-bezeichner (zb als int) der parameter-struktur:

class Param
{
	public:
		Param(int type);
		~Param();

		int getType(void);

	private:
		int type;

};
Param::Param(int t=0) : type(t) {}
Param::~Param() {}
int Param::getType() { return type; }

soweit sogut.

nun soll es abgeleitete klassen Param_1, ... , Param_n geben, welche eine beliebige innere struktur aufweisen. (immer noch nix aufregendes.)
die klassen Param_1.._n sollen aber über den ctor Param(int t) konstruierbar sein, welcher den ctor Param_t() aufruft und ein objekt vom typ Param_t liefert.

wie würdet ihr das lösen?

- rein durch ctor Param() lösbar?
- new() überschreiben?
- template Param<t>?
- gibts ein design pattern?
- oder komplett sinnlos?

grüße

moik

class Param_1 : public Param
{
public:
  Param_1(const Param& p)
  {
    if(p.getType()!=1) throw std::exception;
    ...
  }
};

(aber ich halte den Ansatz für "komplett sinnlos" - was hast du denn überhaupt vor?)

rauskommen soll eine lib, die folgenden code ermöglicht:

Param p2 = new Param(2);

(oder ähnlich. von mir aus auch mit templates)
die innere struktur von p2 soll aber durch den ctor Param_2() gegeben sein, welcher hier nicht explizit aufgerufen werden soll, sondern "geblackboxed" ist.

@any: genau in die richtung gehts (boost::any punkt 2)

auch mit bordmittel möglich?

Ob du solch eine hohe Typsicherheit wie bei boost::any willst, musst du dann für dich entscheiden.