3. Container

Container

  • M

    danke erstmal...allerdings bekomme ich v[0]->get ein wrap_base object zurück, und da bekomme ich den wert nicht raus.

    0
  • N

    Kann eigentlich nicht sein. Das nennt sich kovariante Rückgabetypen in Verbindung mit virtuellen Funktionen. (Oder hab ich hier nen Denkfehler?)

    0
  • M

    Das sind die zwei fehler, die ich bekommen habe:

    error C2679: binary '<<' : no operator found which takes a right-hand operand of type 'wrap_base' (or there is no acceptable conversion)

    c:\Dokumente und error C2679: binary '<<' : no operator found which takes a right-hand operand of type 'wrap_base' (or there is no acceptable conversion)

    für die beiden cout anweisungen halt.

    0
  • N

    Hm ja klar. Einerseits gibt es keinen Ausgabeoperator für wrap_base objekte. Andererseits gibt es ein Problem mit den Rückgabetypen. Es würde zur Laufzeit zwar wrap<T>& zurückgegeben, aber das sieht der compiler net... Da fällt mir auch nichts ein.

    0
  • S

    Natürlich sieht der Compiler das nur ist ein wrap<int> kein int, da fehlt nen Umwandlungsoperator in den gewrappten Typ.

    0
  • N

    Lies dir den Fehler mal genau durch. Der compiler sieht nicht mal ein wrap<int>! Er sieht wrap_base!
    /edit: Wenn der compiler wirklich wrap<int> sieht dann solltest du zur Klasse wrap einen Umwandlungsoperator schreiben (

    operator T(){return w;};

    )

    0
  • M

    er sieht wrap_base...das mit dem umwandlungsoperator habe ich schon versucht

    0
  • N

    malignate schrieb:

    er sieht wrap_base

    Und genau da liegt der Haase im Pfeffer... Wenn einer von den "großen" eine Idee hat, dann bitte sagt uns dies. Vielleicht solltest du dir doch mal boost::variant ansehen...
    :xmas1: :xmas2:

    0
  • J

    Was spricht denn gegen boost::variant ?

    mfg JJ :xmas2:

    (zu spät)

    0
  • S

    Ness da hab ich das Problem wohl falsch verstanden.

    Habe jetzt selbst mal etwas herumgespielt und das Problem liegt wohl ganz einfach daran, dass es keinen operator<< für wrap_base gibt und der Compiler weiß zu diesem Zeitpunkt ja nicht was für ein Typ von get in Wahrheit zurückgeliefert wird.
    Was man braucht ist eine virtuelle Ausgabefunktion für das Objekt.

    Das ganze sieht dann so aus

    class wrap_base
{
public:
	virtual void print (ostream&) = 0;
};

template<class T>
class wrap : public wrap_base
{
public:
	T w;
	wrap(T t)
		:w(t){};

	virtual void print (ostream& out)
	{
		out << w;
	}
};

class node_base
{
public:
	virtual wrap_base& get()=0;
};

template<class T>
class node
	:public node_base
{
private:
	wrap<T> wrapped;
public:
	virtual wrap<T>& get(){return wrapped;};
	node(T t)
		:wrapped(t){};
}; 

ostream& operator<< (ostream& out, wrap_base& obj)
{
	obj.print (out);
	return out;
}

int main ()
{
	std::vector<node_base*> v;
	v.push_back(new node<int>(4));
	v.push_back(new node<float>(3.5));
	cout << v[0]->get();
	cout << v[1]->get();
	delete v[0];
	delete v[1];
	v.clear();

}
    0
  • N

    Ja, das ist klar, nützt aber nix. Sinn ist ja nicht das ganze auszugeben, sondern verschiedene Objekte in einem Vektor zu speichern. Ich habe versucht die Typen über eine polymorpe Schnittstelle zu wrappen und mittels kovarianten Rückgabetypen über einen Zeiger an den Wert zu kommen. Das geht aber nicht, weil der kompiler das ganze statisch prüft und man so deshalb nicht an den gewrapten typ kommt.
    Lange Rede kurzer Sinn: ich glaube das kann vom Ansatz her so nicht klappen...

    0
  • M

    Das löst nur den Sonderfall wenn man den Inhalt mit cout ausgeben will...

    Ich werde mir mal boost::variant anschauen. Dachte das wäre etwas wie das WinApi-union-gebilde...

    0
  • N

    boost::variant ist sowas wie ne union die auch für UDTs funktioniert (Was bei einer Union nicht der Fall ist). Aber ob boost::variant Platz spahrt? Keine Ahnung, aber ich glaube das ist über placement-new realisiert, dann natürlich nicht... Da wäre noch boost::any, das ist so was ähnliches, aber ich habe keine Vorstellungen was daran anders ist...

    0
  • S

    Hat sich erledigt.

    0
  • M

    Ich muss den Thread wiederbeleben. Variant scheint doch net zu gehen.

    Ich will ja float und int UND listen aus float UND int bzw listen aus float und int... einfügen können.

    Eine hierarchie sozusagen.

    Und dann müsste ich sowas machen

    std::list< Variant< float, int, Variant< float, int, Variant< float, int >... > machen. Und das hätte selbstverständlich keine ende. Hat noch jemand eine idee?

    Rtti, template-meta-programmierung, egal wie kompliziert zu verwenden. Hauptsache etwas.

    0
  • O
     

    struct List;
typedef variant<int, float, shared_ptr<List> > Node;
struct List { list<Node> nodes; };

    Wäre das eine annehmbare Lösung?

    0
Anmelden zum Antworten