Kompilatorfel C2666

"identifier" : antal överlastningar har liknande konverteringar

Anmärkningar

En överbelastad funktion eller operator är tvetydig. Formella parameterlistor kan vara för lika för kompilatorn för att lösa tvetydigheten. Lös det här felet genom att uttryckligen omvandla en eller flera av de faktiska parametrarna.

Examples

I följande exempel genereras C2666:

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

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

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

Det här felet kan genereras som ett resultat av kompilatorns efterlevnadsarbete som utfördes för Visual Studio 2019 version 16.1:

• En konvertering som konverterar en uppräkning vars underliggande typ är fixerad till sin underliggande typ är bättre än en som konverterar till en annan underliggande typ, om de två typerna är olika.

I följande exempel visas hur kompilatorbeteendet ändras i Visual Studio 2019 version 16.1 och senare versioner:

#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{});
}

Det här felet kan också genereras som ett resultat av kompilatorns efterlevnadsarbete som utfördes för Visual Studio .NET 2003:

• binära operatorer och användardefinierade konverteringar till pekartyper

• kvalificeringskonvertering är inte samma sak som identitetskonvertering

För de binära operatorerna <, , ><=och >=konverteras nu en godkänd parameter implicit till typen av operand om parameterns typ definierar en användardefinierad konverteringsoperator som ska konverteras till typen av operand. Det finns nu en risk för tvetydighet.

För kod som är giltig i både Visual Studio .NET 2003- och Visual Studio .NET-versionerna av Visual C++anropar du klassoperatorn explicit med hjälp av funktionssyntax.

// 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");
}

I följande exempel genereras C2666

// 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);
    }
};