Kein Duplikat vonAufrufen von virtuellen Funktionen und rein virtuellen Funktionen aus einem Konstruktor:

Die frühere Frage bezieht sich auf C ++ 03, nicht auf das neue Verhalten der Konstruktordelegierung in C ++ 11, und die Frage befasst sich nicht mit der Verringerung undefinierten Verhaltens, indem mithilfe der Delegierung eine ordnungsgemäße Konstruktion sichergestellt wird, bevor rein virtuelle Implementierungen ausgeführt werden.

Welche Gefahren birgt der Aufruf von Pure Virtual-Funktionen in einem Klassenkonstruktor in C ++ 11 während der Konstruktion, nachdem die Klasse / das Objekt jedoch über die Konstruktordelegation "vollständig konstruiert" wurde?

Anscheinend existiert irgendwo in der C ++ 11-Spezifikation eine solche Einschränkung.

Elementfunktionen (einschließlich virtueller Elementfunktionen, 10.3) können für ein Objekt im Bau aufgerufen werden. Ebenso kann ein Objekt im Aufbau der Operand des Operators typeid sein. - 12.6.2 # 13 des [C ++ Working Draft] (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3242.pdf) Kann die "Fair Use" -Version der veröffentlichten Spezifikation nicht finden.

C ++ 11 betrachtet ein Objekt, das erstellt wurde, sobald ein Konstruktor die Ausführung beendet hat. Da mehrere Konstruktoren ausgeführt werden dürfen, bedeutet dies, dass jeder Delegate-Konstruktor auf einem vollständig erstellten Objekt seines eigenen Typs ausgeführt wird. Abgeleitete Klassenkonstruktoren werden ausgeführt, nachdem alle Delegierungen in ihren Basisklassen abgeschlossen sind. -Wikipedia zu sagen, dass dies eine C ++ 11-Sache ist.

Aktuelle C ++ 11 Referenz unbekannt.

Die folgenden Beispiele werden kompiliert und im Nov CTP des Visual Studio 2012 C ++ - Compilers ausgeführt:

#include <string>

/**************************************/
class Base
{
public:
    int sum;
    virtual int Do() = 0;

    void Initialize()
    {
        Do();
    }
    Base()
    {
    }
};

/**************************************/
// Optionally declare class as "final" to avoid
// issues with further sub-derivations.
class Derived final : public Base
{
public:

    virtual int Do() override final
    {
        sum = 0 ? 1 : sum;
        return sum / 2 ; // .5 if not already set.
    }

    Derived(const std::string & test)
        : Derived() // Ensure "this" object is constructed.
    {
        Initialize(); // Call Pure Virtual Method.
    }
    Derived()
        : Base()
    {
        // Effectively Instantiating the Base Class.
        // Then Instantiating This.
        // The the target constructor completes.
    }
};




/********************************************************************/
int main(int args, char* argv[])
{
    Derived d;
    return 0;
}