boost :: variant: comportement étrange avec un type de vecteur récursif

Question

J'ai une classe avec un seul membre qui est un boost::variant de deux types: un vector d'entiers et un vector des objets de classe contenant (ce dernier doit évidemment être fait avec l'aide de recursive_wrapper). Le code de la classe est inférieure à

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

Quand j'essayer d'utiliser cette classe en créant une vector de TestVariant et: Montage d'une instance d'une instance récursive de TestVariant comme ci-dessous

std::vector<TestVariant> v; 

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

Je reçois un « accès violation "exception sous MSVS 2013 et Boost ver 1.53 (je sais que c'est une ancienne version de Boost, mais je suis contraint d'utiliser l'organisation pour le moment). Le même code sur coliru fonctionne bien (voir here).

Ce qui est encore plus étrange est que si je passe l'ordre des deux vecteurs, tout semble être bien dans MSVS 2013

std::vector<TestVariant> v; 

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

Toutes les idées? J'ai essayé de résoudre ceci pendant un jour maintenant ...

Answer 1

Cela semble en effet être l'un des nombreux bogues avec des listes d'initialisation/initialisation uniformes. Le code est « bien » (dans le sens où cela ne déclenche pas UB)

Si elle est quelque chose de semblable aux insectes je suis tombé, vous pouvez essayer de préciser les typenames explicitement:

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