Hallo,

ich habe folgendes Problem:

Gesucht ist eine Klasse TypelessSortedDynArray;

Wie der Name schon sagt soll die Klasse ein dynamisches Array darstellen, dass Objekte von der Klasse CompareableInt, CompareableStrin usw. aufnehemen kann, die von der abstrakten Klasse Compareable erben.

Also das ganze ist jetzt noch nicht sortierte, will einfach mal Elemente einfügen können, vorerst nur int;

class Compareable

{

public:

virtual int compareTo(Compareable*) = 0;

virtual int get() const = 0;

};

class CompareableInt: public Compareable

{

public:

int compareTo(Compareable*);

void set(int);

int get() const { return x; };

private:

int x;

};

class TypelessSortedDynArray

{

private:

Compareable *a;

int num;

public:

TypelessSortedDynArray()

{

num = 0;

a = NULL;

}

~TypelessSortedDynArray()

{

if(a != NULL)

delete [] a;

}

Compareable* elementAt(int index) const;

void add(int);

int get(int index)

{

CompareableInt *temp = dynamic_cast <CompareableInt *> (&a[index]);

return temp->get();

}

};

void TypelessSortedDynArray::add(int value)

{

CompareableInt temp;

temp.set(value);

std::cout << temp.get() << " ";

if(a == NULL)

{

a = new CompareableInt;

num = 1;

}

else

{

num++;

a = (Compareable*)realloc(a, sizeof(a) + sizeof(CompareableInt));

}

a[num-1] = temp;

}

void CompareableInt::set(int value)

{

x = value;

}

Wenn ich jetzt folgendes Hauptprogramm verwende:

int main()

{

TypelessSortedDynArray array;

array.add(20);

std::cout << array.get(0);

}

bekomm ich folgende Ausgabe:

20 10027204

//20 ist der Wert der eingefügt wird und die andere Zahl ist mein Problem

Hat villeicht jemand ne ahnung was da nicht stimmt?

Entweder überseh ich was oder, naja weiß auch nicht ...

Du kannst hinter einem Compareable* kein Array von Objekten einer abgeleiteten Klasse ablegen, das funktioniert nur in speziellen Ausnahmefällen.

Und auf gar keinen Fall darfst du realloc für Speicher benutzen, der nicht mit new angefordert wurde. Auf die C-Speicherverwaltungsfunktionen solltest du komplett verzichten, wenn du mit C++-Klassen arbeitest, weil malloc & Co. nichts von Klassen wissen, und dementsprechend auch keine Konstruktoren aufrufen.

Mmhh ok Danke!

Vielleicht noch eine Idee wie ich das sonst machen könnte?

Hast du irgendwelche Einschränkungen? Darfst du std::vector benutzen? boost? Hat dein Compiler schon irgendwelche C++0x-Features?

Ja einschränkungen hab ich eigentlich schon ... ^^

sollte eigentlich nichts von dem oben genannten verwendet werden...

mehr oder weniger sollte der kern der sache einfach nur ein voidpointer sein ...

mehr oder weniger sollte der kern der sache einfach nur ein voidpointer sein ...

Dann muss dieser Voidpointer auf ein dynamisch alloziiertes Array von Compareable* zeigen (also ein Array von Zeigern).

Und verpass Compareable einen virtuellen Destruktor. Du wirst die Objekte über einen Basisklassenzeiger freigeben müssen, und nur so kannst du sicherstellen, dass der Destruktor der abgeleiteten Klasse auch aufgerufen wird.

Danke für die Tipps hab jetzt eine passende Lösung gefunden