C++: вызов перегруженного 'basic_string()' неоднозначен

Question

Я должен отправить вам свой код, потому что я не могу выбраться из-за того, почему я получаю эту ошибку!
Я знаю, что я мог бы иметь шаблоны использования ..

class Mappable { 
    typedef boost::variant<int, bool, unsigned short, float, char, timeval, 
      double, std::string, size_t> MultiType; 
private: 
    class Handler { 
     friend class Mappable; 
    public: 
     template<typename T> 
     operator T&() { 
      T t = 0; 
      try { 
       t = boost::get<T>(it); 
      } catch (...) { 
      } 
      return t; 
     } 
     template<class T> 
     Handler& operator=(const T& rhs) { 
      it = rhs; 
      return *this; 
     } 
    private: 
     Handler(MultiType& it, const std::string& key); 
     MultiType& it; 
    }; 
public: 
    Mappable(const std::string& tableName); 
    virtual ~Mappable(); 
    Handler operator[](const std::string& key) { 
     return Handler(map_[key], key); 
    } 
    std::string keyTypeToString(const std::string& key) { 
     std::stringstream ss; 
     ss << boost::get<T>(map_[key]); 
     return ss.str(); 
    } 
private: 
    typedef std::map<std::string, MultiType> MultiTypeMap; 
    std::string valueFromKey(const MultiTypeMap::iterator& it); 
    template<class T> 
    MultiTypeMap map_; 
}; 

/* Main.cpp */ 

int main() { 
    Mappable m; 
    m["x"] = 2; 
    m["data"] = "my data string value"; /* Correctly works */ 
    cout << (int)(m["x"]); /* Correctly works */ 
    cout << (string)(m["data"]); /* Error */ 
    cout << m.keyTypeToString<string>("data"); /* Correctly works */ 
} 

ошибок являются:

../src/data/Mappable.h:98:41: error: call of overloaded ‘basic_string(Mappable::Handler)’ is ambiguous 
../src/data/Mappable.h:98:41: note: candidates are: 
/usr/include/c++/4.6/bits/basic_string.tcc:214:5: note: std::basic_string<_CharT, _Traits, _Alloc>::basic_string(const _CharT*, const _Alloc&) [with _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>] 
/usr/include/c++/4.6/bits/basic_string.tcc:171:5: note: std::basic_string<_CharT, _Traits, _Alloc>::basic_string(const std::basic_string<_CharT, _Traits, _Alloc>&) [with _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>, std::basic_string<_CharT, _Traits, _Alloc> = std::basic_string<char>] 
/usr/include/c++/4.6/bits/basic_string.tcc:179:5: note: std::basic_string<_CharT, _Traits, _Alloc>::basic_string(const _Alloc&) [with _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>] 

Я не могу понять, где двусмысленность!

Answer 1

У вас есть неявные преобразования для любого типа.

template<typename T> operator T&(); 

Это означает, что любой один-пары неявного конструктор для basic_string жизнеспособен (символ сопз *, станд :: строка и т.д.)

Мантра: неявных преобразований злы.

В C++ 11 вы можете добавить ключевое слово explicit к преобразованию. Это означает, что вы будете ссылаться на static_cast<>явно

template<typename T> 
    explicit operator T&() { // throws on type mismatch 
     return boost::get<T>(it); 
    }