ich kämpfe gerade mit einem Problem in Visual C++; mit LLVM und GCC tritt der Fehler nicht auf. Und zwar geht es um virtuelle Vererbung. Gegeben sei folgendes, eingedummtes Beispiel:

#include <iostream>

#define where_am_i std::cout << __FUNCTION__ << std::endl;

namespace test
{

    class disp_base
    {
    public:
        disp_base()
        {
            where_am_i
        }
        virtual ~disp_base()
        {
            where_am_i
        }
    };

    class disp : public virtual disp_base
    {
    public:
        disp()
        {
            where_am_i
        }
        virtual ~disp()
        {
            where_am_i
        }
    };

    class refl : public virtual disp_base
    {
    public:
        refl()
        {
            where_am_i
        }
        virtual ~refl()
        {
            where_am_i
        }
    };

    class foo : public virtual disp, public refl
    {
        void *something;
    public:
        foo() : foo(static_cast<void *>(this))
        {
            where_am_i
        }
        foo(void *test) : something(test)
        {
            where_am_i
        }
        virtual ~foo()
        {
            where_am_i
        }
    };

    class bar : public virtual foo
    {
    public:
        bar()
        {
            where_am_i
        }
        virtual ~bar()
        {
            where_am_i
        }
    };

}

int main()
{
    test::bar fail;
}

Mit GCC-4.9.2 erhalte ich folgenden Output:

disp_base
disp
refl
foo
foo
bar
~bar
~foo
~refl
~disp
~disp_base

Auch LLVM frisst den Code problemlos. Mit Visual C++ 2013 hingegen erhalte ich folgendes:

disp_base
disp
disp_base
disp
refl
foo
foo
bar
~bar
~foo
~refl
~disp
~disp_base

disp_base, base wird am Anfang 2x aufgerufen (!) und der Code stürzt mit einer Access Violation ab. Ich habe mit dem Debugger verifiziert, dass der Konstruktor-Aufruf den Stack zerschiesst und darum alles abstürzt.

Ist das ein Compilerfehler oder ist am Code per se etwas falsch?

$edit: Es scheint sich tatsächlich um eine Art Bug zu handeln? Habe gerade mit Visual C++ 2015 getestet und dort bekomme ich den Fehler nicht mehr und der Output ist derselbe wie beim GCC/LLVM.

FG

Allerdings ist die Hierarchie schon etwas pervers