C2666-os fordítási hiba

"azonosító": a túlterhelések száma hasonló konverzióval rendelkezik

Megjegyzések

Egy túlterhelt függvény vagy operátor nem egyértelmű. A formális paraméterlisták túl hasonlóak lehetnek ahhoz, hogy a fordító feloldja a kétértelműséget. A hiba megoldásához explicit módon kell megadnia egy vagy több tényleges paramétert.

Példák

Az alábbi példa c2666-ot hoz létre:

// C2666.cpp
struct complex {
   complex(double);
};

void h(int,complex);
void h(double, double);

int main() {
   h(3,4);   // C2666
}

Ez a hiba a Visual Studio 2019 16.1-es verziójához készült fordítómegformelési munka eredményeként hozható létre:

• Az olyan átalakítás, amely egy enumerációt annak rögzített mögöttes típusára alakít át, jobb, mint az, amely az előléptetett mögöttes típusra alakít át, ha a kettő eltérő.

Az alábbi példa bemutatja, hogyan változik a fordító működése a Visual Studio 2019 16.1-es és újabb verzióiban:

#include <type_traits>

enum E : unsigned char { e };

int f(unsigned int)
{
    return 1;
}

int f(unsigned char)
{
    return 2;
}

struct A {};
struct B : public A {};

int f(unsigned int, const B&)
{
    return 3;
}

int f(unsigned char, const A&)
{
    return 4;
}

int main()
{
    // Calls f(unsigned char) in 16.1 and later. Called f(unsigned int) in earlier versions.
    // The conversion from 'E' to the fixed underlying type 'unsigned char' is better than the
    // conversion from 'E' to the promoted type 'unsigned int'.
    f(e);
  
    // Error C2666. This call is ambiguous, but previously called f(unsigned int, const B&). 
    f(e, B{});
}

Ez a hiba a Visual Studio .NET 2003-hoz készült fordítómegformelési munka eredményeként is létrejön:

• bináris operátorok és felhasználó által definiált konverziók mutatótípusokra

• A képesítés konvertálása nem ugyanaz, mint az azonosság átalakítása

A bináris operátorok <, = ><és >=esetében a rendszer implicit módon konvertálja az átadott paramétert az operandus típusára, ha a paraméter típusa egy felhasználó által definiált konverziós operátort határoz meg az operandus típusára való konvertáláshoz. Most már lehetséges a kétértelműség.

A Visual Studio .NET 2003 és a Visual Studio .NET Visual C++ verzióiban egyaránt érvényes kód esetén hívja meg az osztály operátorát kifejezetten függvényszintaxis használatával.

// C2666b.cpp
#include <string.h>
#include <stdio.h>

struct T
{
    T( const T& copy )
    {
        m_str = copy.m_str;
    }

    T( const char* str )
    {
        int iSize = (strlen( str )+ 1);
        m_str = new char[ iSize ];
        if (m_str)
            strcpy_s( m_str, iSize, str );
    }

    bool operator<( const T& RHS )
    {
        return m_str < RHS.m_str;
    }

    operator char*() const
    {
        return m_str;
    }

    char* m_str;
};

int main()
{
    T str1( "ABCD" );
    const char* str2 = "DEFG";

    // Error - Ambiguous call to operator<()
    // Trying to convert str1 to char* and then call
    // operator<( const char*, const char* )?
    //  OR
    // trying to convert str2 to T and then call
    // T::operator<( const T& )?

    if( str1 < str2 )   // C2666

    if ( str1.operator < ( str2 ) )   // Treat str2 as type T
        printf_s("str1.operator < ( str2 )\n");

    if ( str1.operator char*() < str2 )   // Treat str1 as type char*
        printf_s("str1.operator char*() < str2\n");
}

Az alábbi példa C2666-ot hoz létre

// C2666c.cpp
// compile with: /c

enum E
{
    E_A,   E_B
};

class A
{
    int h(const E e) const {return 0; }
    int h(const int i) { return 1; }
    // Uncomment the following line to resolve.
    // int h(const E e) { return 0; }

    void Test()
    {
        h(E_A);   // C2666
        h((const int) E_A);
        h((int) E_A);
    }
};