Mögliche Laufzeitprobleme, die durch das Verschieben eines temporären Objekts auf ein Heap-zugewiesenes Objekt entstehen ⇐ C++

[Guest]

Dies ist ein sehr kompliziertes Beispiel, das wahrscheinlich selten vorkommt, aber ich bin bei der folgenden Ausführung auf Probleme gestoßen:

Code: Select all

class MyClass{
public:
SubClass1 object1; //has pointers/smart-pointers to objects that have pointers to SubClass2
SubClass2* object2; //has pointers/smart-pointers to objects that have pointers/smart-pointers to SubClass1
MyClass(){ object2 = new SubClass2(&object1); }; //SubClass2 constructor establishes the relationship between object1 and object2 pointed-to-objects.
};
/*....*/
MyClass* ptr = new MyClass(std::move(MyClass()));

Ich habe herausgefunden, dass einige Zeiger in Objekt2 ungültig waren. Ich würde gerne die Definitionen von SubClass1 und SubClass2 teilen, aber leider darf ich diesen Code nicht teilen.

Meine Frage ist, gibt es bestimmte Checklisten, die ein Klassenobjekt enthält muss erfüllt sein, um Probleme beim Verschieben eines temporären Objekts auf ein neues Heap-zugewiesenes Objekt zu vermeiden?
Gibt es Möglichkeiten, im Voraus zu wissen, ob ein Verschiebungsvorgang von fehlschlägt?

Das ursprüngliche Problem war darauf zurückzuführen, dass falsch geschrieben wurde:

Code: Select all

std::shared_ptr ptr = std::make_shared(MyClass());

wenn ich alle meine shared_ptr-Instanzen so ändere, dass sie über make_shared statt über new erstellt werden. Am Ende habe ich das Problem auf Rohzeiger, std::move und eine temporäre R-Wert-Referenz eingegrenzt.

Beim Ausführen:

Code: Select all

std::shared_ptr ptr = std::make_shared();

es hat perfekt funktioniert.

Seltsamerweise gab es bei Folgendem keine Probleme:

Code: Select all

MyClass stack_obj{};
MyClass* ptr = new MyClass(std::move(stack_obj));

Es scheint etwas Besonderes zu sein, ein temporäres Objekt auf den Heap zu verschieben?

Das habe ich auch herausgefunden Wenn ich Objekt1 so geändert hätte, dass es stattdessen ein Zeiger von SubClass1 ist, hatte ich auch keine Probleme.
d. h.

Code: Select all

class MyClass{
public:
SubClass1* object1;
SubClass2* object2;
MyClass(){ object1 = new SubClass1(); object2 = new SubClass2(object1); };
};
/*....*/
MyClass* ptr = new MyClass(std::move(MyClass())); //worked fine

Das einzige Problem, das ich mir vorstellen konnte, bestand darin, dass Objekt1 auf dem Stapel für das temporäre Objekt MyClass() erstellt wurde und das Problem dann durch das Verschieben von Objekt1 aus dem lokalen Objekt entstand Stapel auf den Heap während der Zeigerzuweisung.

Zur Vervollständigung sind dies weitere Möglichkeiten, mit denen ich das gleiche Problem für die ursprüngliche Klasse replizieren konnte:

Code: Select all

template 
std::shared_ptr make_shared_test(Args&& ... args)
{
return std::shared_ptr(new MyClass(std::forward(args)...));
}

MyClass&& forward_test(MyClass&& param){
return static_cast(param);
}

/*....*/
MyClass* obj1(new MyClass(std::move(MyClass())));
std::shared_ptr obj2 = make_shared_test(MyClass());
std::shared_ptr obj3 = std::shared_ptr(new MyClass(forward_test(MyClass())));
std::shared_ptr obj4 = std::shared_ptr(new MyClass(std::move(MyClass())));
std::shared_ptr obj5(new MyClass(std::move(MyClass())));