BUG: Function that Inherits Through Dominance Fails

• The Microsoft C/C++ Compiler (CL.EXE) included with: - Microsoft C/C++ for MS-DOS, version 7.0 - Microsoft Visual C++ for Windows, versions 1.0, 1.5 - Microsoft Visual C++ 32-bit Edition, versions 1.0, 2.0, 4.0, 4.1, 4.2,

       5.0
  

SYMPTOMS

Code that makes use of the C++ implicit invocation of a user-defined conversion causes the C/C++ compiler to generate the following error message:

   error C2594: '=' : ambiguous conversions from 'class ::E ' to 'int '

   warning C4250: 'E' : inherits 'B::operator`int'' via dominance
   error C2679: binary '=' : no operator defined which takes a right-
      hand operand of type 'class E' (or there is no acceptable conversion)
   error C2594: '=' : ambiguous conversions from 'class E' to 'int'

RESOLUTION

Explicitly invoke the user-defined conversion, as demonstrated in the sample code in the "MORE INFORMATION" section below, rather then depending on the implicit invocation.

STATUS

Microsoft has confirmed this to be a bug in the products listed at the beginning of this article. We are researching this bug and will post new information here in the Microsoft Knowledge Base as it becomes available.

MORE INFORMATION

Suppose a virtual-base class A is defined and classes B and C inherit from class A. Furthermore, a class E inherits from both B and C. The two classes, A and B, each provide a virtual user-defined conversion function to "int". The relationship may be represented by the following directed acyclic graph:

                        A { int () }
                          ^      ^
                         /        \
                        /          \
                  B { int () }    C {}
                       ^           ^
                         \        /
                          \      /
                           E { }

As demonstrated by the following sample code, the compiler accurately identifies and invokes the correct user-defined conversion function when using the explicit call syntax. However, when attempting to make use of the implicit conversion, the compiler produces an error, citing an ambiguity in its search for the correct user-defined conversion function.

Sample Code

   /* Compile options needed: /W3
   */
   #include <iostream.h>

   class A
   {
   public:
       virtual operator int () { return 2; }
   };

   class B : virtual public A
   {
   public:
       virtual operator int () { return 3; }
   };

   class C : virtual public A {};

   class E : public B, public C {};

   void main(void)
   {
      int i;
      int error=0;

      E eObject;

      // Both of the invocations below should call B's
      // operator int ().

      if ((i = eObject) != 3)                // Fails to compile
         error = 1;

      if ((i = eObject.operator int()) != 3) // Compiles OK
         error = 1;

      if (!error)
         cout << "PASSED" << endl;
      else
         cout << "FAILED" << endl;
   }

REFERENCES

The Annotated C++ Reference Manual (ARM), Ellis and Stroustrup, section 10.1.1, "Ambiguities," section 10.2, "Virtual Functions," and section 12.3, "Conversions."