Es geht darum: Ich habe eine wrapper klasse (angenommen Base sei diese), die von CParent eine funktion aufrufen soll. Mit dem o.g. code würde das momentan ohne probleme klappen (ihr könnte gerne eine CParent-Methode erstellen [diese darf aber keine attribute von CParent ansteuern] und diese dann z.b. beim cout << copy aufrufen). Wenn ich jetzt aber CParent wieder von Base ableite, klappt es nicht mehr, da das offset nicht mehr stimmt.
Wie bekomm ich das richtige offset von m_Sub, wenn ich jetzt noch von Base ableite (also das offset von Base zu m_Sub)?

MfG Krauzi

P.s.: Da sowieso wieder die frage gestellt wird, was ich damit bezwecken will: Ich habe über 200 klassen zu wrappen, von denen alle mindestens 10 constructoren haben (max. ableitungen: 3 mal), ich möchte nicht bei jedem constructor hinschreiben: INITIALIZE(<Klassenname>)!
Da aber alle klassen bereits wegen reflection mit einem macro ausgestattet sind kann ich durch das hinzufügen des im beispiel gezeigten codes diese methode der CParent klasse aufrufen ohne irgendwas im constructor zu ändern.

The macro offsetof accepts a restricted set of type arguments in this International Standard. If type is not a POD structure or a POD union the results are undefined.

Abschnitt 9 Absatz 4:

...A POD-struct is an aggregate that has no non-static data members of type non-POD-struct, non-POD-union (or array of such types) or reference, and has no user-declared copy assignment operator and no user-declared destructor...

Abschnitt 8.5.1 Absatz 1:

An aggregate is an array or a class with no user-declared constructors, no private or protected non-static data members, no base classes, and no virtual functions.

--- was mir nicht gerade weiterhilft. Es muss möglich sein!

std::string ist kein POD, damit ist CParent kein POD, damit ist offsetof undefiniert. Punkt. Alles andere interessiert nicht.

in meinem beispiel klappt es aber für's erste.

Trotzdem kann dir auf deine Frage keiner eine verlässliche Antwort geben. Wenn im Standard steht dass es undefiniert ist, dann geht es mit Standard-C++ eben nicht.

Wie dein verwendeter Compiler die Sache konkret handhabt, ist eine andere Frage. Das müsstest du den Hersteller fragen. Dass dein Beispiel funktioniert kann auch nur Zufall sein. Es ist eben undefiniert.

habs jetzt noch auf mingw oder wie der compiler heißt kompiliert und da hats auch geklappt. Zufall ist das jetzt eher nicht...

wenn etwas undefiniert ist, ists einfach nicht definiert.
wenn 2 compiler zufällig das selbe machen, hat das nichts damit zu tun, was "normalerweise" passiert und heißt auch noch lang nicht, dass es nicht "zufällig" ist...

void main()
{
;
}

wetten, ich finde mehr als einen compiler, der das hier compiliert?
ist es dadurch definiert?

bb

habs jetzt noch auf mingw oder wie der compiler heißt kompiliert und da hats auch geklappt. Zufall ist das jetzt eher nicht...

dann heißts, das mehrere compiler ähnliche Dinge machen. Es ändert aber gar nichs daran, dass der Standard ganz klar sagt, dass das jeder Compiler so mchen kann wie er will. Und insbesondere bei Vererbung geht dort alles querbeet durcheinander. Da ändert sich auch gerne mal was zwischen 2 Compilerversionen.

Da kannst du noch so sehr mit dem Fuß aufstampfen und rumflennen, dass es doch gehen muss: der Standard sagt nein. Und der Standard hat in jeder Diskussion das letzte Wort.

Da kannst du noch so sehr mit dem Fuß aufstampfen und rumflennen, dass es doch gehen muss: der Standard sagt nein. Und der Standard hat in jeder Diskussion das letzte Wort.

Außer da wo es geändert wurde.

test.cc: In constructor »CParent::CSub::CSub()«:
test.cc:23: Warnung: invalid access to non-static data member »CParent::m_Sub«  of NULL object
test.cc:23: Warnung: (vielleicht wurde das Makro »offsetof« falsch verwendet)

...und du solltest das beachten.

Die Sprache sieht solchen Blödsinn schlicht nicht vor, und es gibt dementsprechend keinen zuverlässigen Weg, das zu machen.

Wenn du dich auf wilde Hacks einlassen willst: --copy erniedrigt copy um sizeof(*copy). Du könntest es mit

size_t offset = offsetof(CParent, CParent::m_Sub);
CParent* copy = reinterpret_cast<CParent*>(reinterpret_cast<char*>(this) - offset);

versuchen, aber ich übernehme keine Garantie dafür. Sobald das auseinanderfliegt - und das wird es - bist du selbst schuld. Und ganz ehrlich, wenn mir jemand Software andrehen wollte, von der ich wüsste, dass sie solchen Code enthält, könnte der gleich wieder abschwirren.

Sorry, dass ich nochmal nachfrage, aber ich verstehe das Problem nicht wirklich...

Ich habe über 200 klassen zu wrappen, von denen alle mindestens 10 constructoren haben (max. ableitungen: 3 mal), ich möchte nicht bei jedem constructor hinschreiben: INITIALIZE(<Klassenname>)!

Meintest du da ein template? ... weil als Makro kann ich mir das nicht vorstellen

Da aber alle klassen bereits wegen reflection mit einem macro ausgestattet sind kann ich durch das hinzufügen des im beispiel gezeigten codes diese methode der CParent klasse aufrufen ohne irgendwas im constructor zu ändern.

Ich kann in dem Code keine Initialisierung entdecken, sondern nur den Versuch erkennen den Pointer des CParent-Objektes aus dem Member heraus zu bekommen (und wie @seldon schon sagte funktioniert das so nicht immer) ...

Wenn es um Initialisierung geht, kannst du ja templates und deren Spezialisierung benutzen.

template<class T> struct Initer;

template<> struct Initer<Base> : public Base
{
  Initer() // Initer<Base> ist ja zugleich auch Base ;)
  {
    this->attr1 = 12;
    this->attr2 = 0;
    this->attr3 = "Hello World";
  }
};
template<> struct Initer<Base2> : public Base2
{
  Initer() { ... }
};
...
Base * ptrBase = new Initer<Base>;
Base2 * ptrBase2 = new Initer<Base2>;

cu

Vorschlag: zeig mal den Code ohne offsetof() , den du vermeiden willst, der aber sicher funktionieren würde. Also die triviale Implementierung.

Vielleicht kann dir dann jmd. einen besseren Vorschlag als den von dir geplanten Hack machen.