Wrong overloading ambiguity error

Question

Hi,
The following compiles on Studio 7, but not on Studio 11, where an error is reported:
Error: Overloading ambiguity between "myString::operator char*&()" and "myString::operator char*()"
However, when myStr is defined const, then the code compiles.
Why this difference in the behaviour of the compilers? Is it intended? Should unaccesible operators be checked for ambiguity? Why does the compiler check for ambiguity of methods which it obviously should not select in this case?
#include <string.h>
class myString {
  private:
     char * content;
  public:
     myString(const char * str) { content = new char[strlen(str)+1]; strcpy(content,str);};
     operator char*&() { char * cpy = new char[strlen(content)+1]; strcpy(cpy,content); return cpy;};
     operator const char* () const {return content;};
  private:
     operator char*() { char * cpy = new char[strlen(content)+1]; strcpy(cpy,content); return cpy;};
int main() {
     myString myStr = "MyString Test String"; // COMPILE ERROR HERE
     const char * str = myStr;
     return 0;
};

Answer 1

The error is not on the marked line, but on the next
line:
const char * str = myStr;Yes, you are right, I marked the wrong line.
>
The rule for resolving overloaded functions is that
all visible functions that can be called with the
given arguments ("viable functions" in the
terminology of the standard) are checked, and the
best match is looked for.
If there is no single best match, the call is
ambiguous, an error.
Only if there is a best match is accessibility
checked. If the best match is not accessible, the
call is in error.In this case, wouldn't the const operator be the best match?
>
The reason for checking accessibility last is to
prevent changes in accessibility from changing the
result of operator overload resoution. One can
imagine different rules, but that is the C++ rule.
(C++ Standard, section 13.3)This should only apply here if the compiler decided not to select the constant operator over the other operators. That would mean that doing two conversions (MyString -> char*/& -> const char*) would be preferred over doing one conversion (MyString -> const char *).
Does this conform to the C++ standard rules?