Problème avec boost :: variant, linker donnant une erreur de segmentation

Question

J'ai une variante boost avec 7 types. Lorsque j'essaie d'utiliser les deux derniers types, les segings de l'éditeur de liens. J'utilise g ++ (version gcc 3.3.3 sur SuSE Linux) sur une machine Linux 64 bits et l'erreur que je reçois est

collect2: ld terminated with signal 11 [Segmentation fault] 

Il n'a pas d'importance quel ordre je mets les types dans, les deux derniers causeront un segfault quand j'essaie de les utiliser. Des idées pourquoi cela se passerait-il?

code:

typedef boost::tuple<std::string, Class1::Ptr> Class1Tuple; 
typedef boost::tuple<std::string, Class2::Ptr> Class2Tuple; 
typedef boost::tuple<std::string, Class3::Ptr> Class3Tuple; 
typedef boost::tuple<std::string, Class4::Ptr> Class4Tuple; 
typedef boost::tuple<std::string, Class5::Ptr> Class5Tuple; 
typedef boost::tuple<std::string, Class6::Ptr> Class6Tuple; 
typedef boost::tuple<std::string, Class7::Ptr> Class7Tuple; 

typedef boost::variant< Class1Tuple, Class2Tuple, Class3Tuple, 
         Class4Tuple, Class5Tuple, Class6Tuple, 
         Class7Tuple > ClassTupleItem; 

ClassX :: Ptr est un coup de pouce pointeur partagé à cette classe. PTR est défini comme un typedef dans la classe elle-même comme ci-dessous

struct Class1 
{ 
typedef boost::shared_ptr<Class1> Ptr; 
    ... 
    ... 
} 

lorsque je tente d'utiliser les deux derniers types dans la variante de boost comme dans

Class1Tuple tup("str", pointer); 
ClassTupleItem(tup); // works fine since I used Class1Tuple 

Class6Tuple tup2("str", pointer2); 
ClassTupleItem(tup2); // causes a segfault. 

si je définis le boost :: Variant (échange Class6 et Class1)

typedef boost::variant< Class6Tuple, Class2Tuple, Class3Tuple, 
         Class4Tuple, Class5Tuple, Class1Tuple, 
         Class7Tuple > ClassTupleItem; 

puis je reçois une erreur de segmentation lors de la compilation de ce code

Class1Tuple tup("str", pointer); 
ClassTupleItem(tup); // worked earlier 

Answer 1

Cela ressemble à un bogue de compilateur/éditeur de liens: aucun code C++ ne doit jamais provoquer de segfault dans le compilateur/éditeur de liens. Par ailleurs, comment obtenez-vous ce code pour compiler? Comment est déclaré pointer?

Class1Tuple tup("str", pointer); 
ClassTupleItem(tup); // works fine since I used Class1Tuple 

Class6Tuple tup2("str", pointer); 
ClassTupleItem(tup2); // causes a segfault. 

Si les classes sont déclarées comme celui-ci, pour Class1Tuple, pointer devrait être un shared_ptr<Class1>, et pour Class6Tuple il devrait être d'un type différent, shared_ptr<Class6>.

struct Class1 
{ 
    typedef boost::shared_ptr<Class1> Ptr; 
    /* ... */ 
}; 

/* ... */ 

struct Class6 
{ 
    typedef boost::shared_ptr<Class6> Ptr; 
    /* ... */ 
}; 

Edit: Le code suivant compile correctement avec g ++ 3.3.6. Je ne suis pas capable de le tester sur gcc 3.3.3 et SUSE Linux pour le moment. S'il vous plaît essayer de compiler ceci et voir si l'éditeur de liens donne toujours un segfault.

#include <boost/shared_ptr.hpp> 
#include <boost/tuple/tuple.hpp> 
#include <boost/variant.hpp> 
#include <string> 

struct Class1 
{ 
    typedef boost::shared_ptr<Class1> Ptr; 
    /* .... */ 
}; 

struct Class2 
{ 
    typedef boost::shared_ptr<Class2> Ptr; 
    /* .... */ 
}; 

struct Class3 
{ 
    typedef boost::shared_ptr<Class3> Ptr; 
    /* .... */ 
}; 

struct Class4 
{ 
    typedef boost::shared_ptr<Class4> Ptr; 
    /* .... */ 
}; 

struct Class5 
{ 
    typedef boost::shared_ptr<Class5> Ptr; 
    /* .... */ 
}; 

struct Class6 
{ 
    typedef boost::shared_ptr<Class6> Ptr; 
    /* .... */ 
}; 

struct Class7 
{ 
    typedef boost::shared_ptr<Class7> Ptr; 
    /* .... */ 
}; 

typedef boost::tuple<std::string, Class1::Ptr> Class1Tuple; 
typedef boost::tuple<std::string, Class2::Ptr> Class2Tuple; 
typedef boost::tuple<std::string, Class3::Ptr> Class3Tuple; 
typedef boost::tuple<std::string, Class4::Ptr> Class4Tuple; 
typedef boost::tuple<std::string, Class5::Ptr> Class5Tuple; 
typedef boost::tuple<std::string, Class6::Ptr> Class6Tuple; 
typedef boost::tuple<std::string, Class7::Ptr> Class7Tuple; 

typedef boost::variant< Class1Tuple, Class2Tuple, Class3Tuple, 
         Class4Tuple, Class5Tuple, Class6Tuple, 
         Class7Tuple > ClassTupleItem; 

int main() 
{ 
    Class1::Ptr pointer; 
    Class1Tuple tup("str", pointer); 
    (ClassTupleItem(tup)); // Temporary object 
    ClassTupleItem item(tup); 

    Class6::Ptr pointer2; 
    Class6Tuple tup2("str", pointer2); 
    (ClassTupleItem(tup2)); // Temporary object 
    ClassTupleItem item2(tup2); 
}