class A abstract
{
  void f() = 0;
}
class B : public A
{
   void f();
}

main
{
  A * a = new B;
  void * ptr = ausreichend_speicher;
  memcpy ( ptr, a, sizeof(B) );
  A * a2 = (A*) ptr;
  //funktioniert folgendes ?
  a2->f();  
}

class A abstract
{
  void f() = 0;
  A* create() = 0;
}
class B : public A
{
   void f();
   A* create(){return new B(this);}
}

main
{
  A * a = new B;
  A * a2 = (A*) B.create();
  //funktioniert folgendes ?
  a2->f();  
}

oder übersehe ich da einen Sinn vom memcpy?

kk

B ist kein POD, da es von A erbt.

A ist auch kein POD. Virtuelle Funktionen oder gar abstrakte Klassen gehen gar nicht.
Allerdings wollte er das ja abgesehen davon wissen (darum "angenommen A und B..").

B ist kein POD, da es von A erbt.
Ich denke, Dein memcpy läuft daher auf undefiniertes Verhalten hinaus.
Es gibt dann eventuell noch ein Alignment-Problem.

Ach, A soll wohl auch noch eine pur-virtuelle Funkion enthalten, was? Das ist dann schon lange kein POD mehr. Du hast dann aber das "virtual" keyword vergessen.

krümelkacker schrieb:

B ist kein POD, da es von A erbt.
Ich denke, Dein memcpy läuft daher auf undefiniertes Verhalten hinaus.
Es gibt dann eventuell noch ein Alignment-Problem.

Ach, A soll wohl auch noch eine pur-virtuelle Funkion enthalten, was? Das ist dann schon lange kein POD mehr. Du hast dann aber das "virtual" keyword vergessen.

Ich denke er wollte da in der Tat eine abstrakte Klasse, daher das "abstract" (was so natürlich syntaktisch völlig falsch ist, aber der Rest ist ja auch nicht korrekt).

Mein Kernproblem ist im Grunde aber folgendes. Die Klasse B wird memcpy serialisiert und an einen anderen Prozess übertragen. Bedeutet es existiert im zweiten Prozess eine fertiges B-Objekt im Speicher.
Ich benötige nur noch einen korrekten (polymorphen) A-Zeiger auf dieses Objekt.

Mein Kernproblem ist im Grunde aber folgendes. Die Klasse B wird memcpy serialisiert und an einen anderen Prozess übertragen. Bedeutet es existiert im zweiten Prozess eine fertiges B-Objekt im Speicher.
Ich benötige nur noch einen korrekten (polymorphen) A-Zeiger auf dieses Objekt.

Polymorphie und memcpy() sind unvereinbar. Sobald du virtuelle Funktionen einsetzt, ist deine Klasse kein POD mehr, wodurch aus sämtlichen bitweisen Operationen im Speicher undefiniertes Verhalten resultiert.

Auf dein Beispiel angewandt heisst das, du darfst gar nie mit memcpy() serialisieren. Warum verwendest du nicht den Kopierkonstruktor?

Die Klasse B wird memcpy serialisiert und an einen anderen Prozess übertragen. Bedeutet es existiert im zweiten Prozess eine fertiges B-Objekt im Speicher.
Ich benötige nur noch einen korrekten (polymorphen) A-Zeiger auf dieses Objekt.

Das geht dann garantiert nicht mehr. Prozessintern mag's vielleicht noch funktionieren, aber sobald du polymorphe Objekte hast, haben die auch einen vtable-Zeiger und den kannst du nicht kopieren (bzw. kannst du schon, der bringt dir im anderen Prozess aber nichts).

Scheinbar bedeutet der Begriff POD nicht genau das was ich meinte.
A und B seien flache Objekte, haben keine Pointer als member..

Nein das ist es nicht.

Lies am besten mal das hier durch:
http://www.c-plusplus.net/forum/viewtopic-var-t-is-194356.html

Warum verwendest du nicht den Kopierkonstruktor?

Daran hatte ich auch schon gedacht.
Ist es möglich ausschließlich die vTable initialisieren ?

Ist es möglich ausschließlich die vTable initialisieren ?

Der C++ Standard verliert kein Wort über "vTable". Wenn Du dahingehend etwas versuchst, wird es ein Compiler-spezifischer Hack werden, der mit der nächsten Version des Compilers schon nicht mehr funktionieren könnte.