问题
The Boost Variant documentation says the following of the constructor that accepts arbitrary type:
template<typename T> variant(T & operand);
- Requires: T must be unambiguously convertible to one of the bounded types (i.e., T1, T2, etc.).
The same is true of the constructors accepting const T& and T&&. So I expect that the following code won't compile:
boost::variant<std::string, bool> v = "text";
But the code compile, and v becomes a bool, which is something I definitely did not want. Of course the solution is to wrap the string literal in a std::string constructor. My question is:
- Why does this code compile?
- How does it choose the type (as
const char*is convertible to bothstd::stringandbool)?
回答1:
Generally, user-defined conversions lose overload resolution process to standard conversions.
There is a built-in conversion from const char pointers to bool which is preferred over the non-built-in conversion from const char * to std::string (e.g. see Implicit conversions).
std::string, while part of the standard library, is not a built-in type so its conversion constructors are considered only after conversions to built-in types.
Some references:
- Why does the compiler choose bool over string for implicit typecast of L""?
- Why is my overloaded C++ constructor not called?
来源：https://stackoverflow.com/questions/25802885/boost-variant-ambiguous-construction