No un duplicado deInvocar la función virtual y la función virtual pura desde un constructor:

La primera pregunta se relaciona con C ++ 03, no con el nuevo comportamiento de Delegación de constructor en C ++ 11, y la pregunta no aborda la mitigación de un comportamiento indefinido mediante el uso de la delegación para garantizar una construcción adecuada antes de que se ejecuten las implementaciones virtuales puras.

En C ++ 11, ¿cuáles son los peligros de invocar funciones virtuales puras en un constructor de clase, durante la construcción, pero después de que la clase / objeto se haya "construido completamente" a través de la delegación de constructores?

Aparentemente, en algún lugar de la especificación de C ++ 11 existe tal restricción,

Las funciones miembro (incluidas las funciones miembro virtuales, 10.3) se pueden llamar para un objeto en construcción. De manera similar, un objeto en construcción puede ser el operando del operador typeid. - 12.6.2 # 13 del [Borrador de Trabajo de C ++] (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3242.pdf) No puedo encontrar la versión "Uso Justo" de las Especificaciones publicadas.

C ++ 11 considera un objeto construido una vez que cualquier constructor termina la ejecución. Como se permitirá la ejecución de múltiples constructores, esto significará que cada constructor delegado se ejecutará en un objeto completamente construido de su propio tipo. Los constructores de clases derivadas se ejecutarán después de que se complete toda la delegación en sus clases base. -Wikipedia diciendo que esto es una cosa de C ++ 11

Actual C ++ 11 Referencia desconocida.

El siguiente ejemplo compila y ejecuta en el CTP de noviembre de Visual Studio 2012 C ++ Compiler:

#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;
}