Strange ambiguity from Intellisense - c++

Question

I've got the following code (reduced from the actual application, of
course):
class Reader
{
class Proxy
{
Reader* myOwner;
public:
Proxy( Reader* owner ) : myOwner( owner ) {}
template <typename T>
operator T() const
{
T tmp;
myOwner->Read( &tmp );
return tmp;
}
};
public:
void Read( bool* dest );
void Read( int* dest );
void Read( std::string* dest );
// ...
Proxy Read();
};
void
testIt( Reader& r )
{
std::string s = r.Read(); // Issue on this line.
}
The code compiles fine with both MSC and g++, but Intellisense
highlights the line in question, with an error message to the effect
that more than one user defined conversion from Reader::Proxy to
std::string applies, and cites all or most of the constructors of
std::string which can be called with a single argument.
My real question is: who is right? My feeling is that because I'm using
the copy initialization form of initialization, the compiler should
first convert Reader::Proxy to an std::string, then copy this.
And that the instantiation Proxy::operator std::string() does the conversion
with a single user defined conversion, where as an instantiation like
Proxy::operator char const*() would require two: the conversion
operator and the conversion constructor of std::string, and would thus
be illegal. (If I'd used direct initialization, of course, the compiler
would search for all of the conversions which could be used to call
a constructor of std::string, and the statement would be ambiguous.)
So is this a bug in Intellisense? Or is it a case of Intellisense being
closer to the standard, and that my code might stop compiling when we
upgrade, and the newer version follows the standard more closely?

Answer 1

Generally if it works in MSVC and g++ but not Intellisense, it's probably Intellisense that's at fault.
That said, I believe the code you posted is fine.
There is actually an MSVC warning for this (C4928), though it's off by default:
http://msdn.microsoft.com/en-us/library/cwck4ta9.aspx
You can enable it by using /w44928 on the command line or in 'extra compile options' in the IDE, or by using #pragma warning(4:4928).
EDIT: Having read the MSDN docs on that warning, it looks like they're suggesting that changing your code to std::string s(r.Read()); will work without warning. So I guess their wording of the warning isn't quite right (or we're just misreading it?) and they really mean "user-defined conversion and copy initialization being done in one statement". I don't know if that's allowed by the standard or not, sorry.