Boost :: Variante: seltsames Verhalten mit einem rekursiven Vektor Typ

Question

Ich habe eine Klasse mit einem einzigen Mitglied, das ist ein boost::variant von zwei Typen: ein vector von ganzen Zahlen und ein vector der enthaltenen Klassenobjekte (Letzteres muss offensichtlich sein getan mit Hilfe von recursive_wrapper). Der Code für die Klasse ist unter

#include <boost/variant/variant.hpp> 
#include <boost/variant/recursive_wrapper.hpp> 

#include <vector> 

class TestVariant 
{ 
public: 

    typedef boost::variant< std::vector<int>, boost::recursive_wrapper<std::vector<TestVariant> > > StorageType; 

    TestVariant(): 
     m_value{ std::vector<int>{} } 
    {} 

    TestVariant(const TestVariant& other): 
     m_value{ other.m_value } 
    {} 

    TestVariant& operator=(const TestVariant& other) 
    { 
     m_value = other.m_value; 

     return *this; 
    } 

    TestVariant(TestVariant&& other): 
     m_value{ std::move(other.m_value) } 
    {} 

    TestVariant& operator=(TestVariant&& other) 
    { 
     m_value = std::move(other.m_value); 

     return *this; 
    } 

    TestVariant(const std::vector<int>& value): 
     m_value{ value } 
    {} 

    TestVariant(std::vector<int>&& value): 
     m_value{ std::move(value) } 
    {} 

    TestVariant(const std::vector<TestVariant>& value): 
     m_value{ value } 
    {} 

    TestVariant(std::vector<TestVariant>&& value): 
     m_value{ std::move(value) } 
    {} 

private: 

    StorageType m_value; 
}; 

Wenn ich diese Klasse Versuchen Sie es mit durch eine vector von TestVariant zu schaffen und eine Instanz einer rekursiven Instanz von TestVariant emplacing wie unten

std::vector<TestVariant> v; 

v.emplace_back(std::vector<TestVariant>{ std::vector<TestVariant>{}, std::vector<int>{} }); // access violation! 

ich einen „Zugang erhalten Verletzung "Ausnahme unter MSVS 2013 und Boost ver 1.53 (Ich weiß, dies ist eine alte Version von Boost, aber ich bin organisatorisch beschränkt, um es im Moment zu verwenden). Derselbe Code auf Coliru funktioniert einwandfrei (siehe here).

Was noch seltsamer ist, dass, wenn ich die Reihenfolge der beiden Vektoren zu wechseln, alles in MSVS 2013

std::vector<TestVariant> v; 

v.emplace_back(std::vector<TestVariant>{std::vector<int>{}, std::vector<TestVariant>{} }); // works! 

Irgendwelche Ideen in Ordnung zu sein scheint? Ich habe versucht, dies für einen Tag jetzt zu lösen ...

Answer 1

Dies scheint in der Tat einer von vielen Bugs mit einheitlichen Initialisierung/Initialisierung Listen. Der Code ist „fein“ (in dem Sinne, dass das nicht UB auslöst)

Wenn es etwas ähnlich den Fehler, das ich lief in, Sie könnten versuchen, die typenames explizit angeben:

v.emplace_back(std::vector<TestVariant>{ 
    TestVariant(std::vector<TestVariant>{}), 
    TestVariant(std::vector<int>{}) });