Error del compilador C2440
Actualización: noviembre 2007
Mensaje de error
'conversión' : no se puede realizar la conversión de 'tipo1' a 'tipo2'
'conversion' : cannot convert from 'type1' to 'type2'
El compilador no puede realizar la conversión de 'type1' a 'type2'.
El error C2440 se puede producir como el resultado de un trabajo de conformidad y actualización realizado en la Biblioteca estándar de C++. Para obtener más información, vea Cambios en la biblioteca estándar de C++: Visual C++ .NET 2003 y Cambios de biblioteca en las versiones de Visual C++.
Ejemplo
El error C2440 puede producirse al intentar convertir un puntero a miembro a void*. El ejemplo siguiente genera el error C2440.
// C2440.cpp
class B {
public:
void f(){;}
typedef void (B::*pf)();
void f2(pf pf) {
(this->*pf)();
void* pp = (void*)pf; // C2440
}
void f3() {
f2(f);
}
};
Los errores C2440 en las líneas 15 y 16 del ejemplo siguiente se calificarán con el mensaje Incompatible calling conventions for UDT return value . Los tipos definidos por el usuario (UDT) son por ejemplo class, struct, o union. Estos tipos de errores de incompatibilidad se producen cuando la convención de llamada de un tipo definido por el usuario y especificado en el tipo de valor devuelto de una declaración adelantada entra en conflicto con la convención de llamada real del tipo definido por el usuario, y cuando hay implicado un puntero a función.
En el ejemplo, primero tenemos declaraciones adelantadas para struct y para una función que devuelve struct; el compilador supone que struct utiliza la convención de llamada de C++. A continuación tenemos la definición de struct, la cual, de forma predeterminada, utiliza la convención de llamada de C. Dado que el compilador no conoce la convención de llamada de struct hasta que termina de leerla por completo, también se supone que la convención de llamada de struct en el tipo de valor devuelto de get_c2 es C++.
Struct tiene detrás otra declaración de función que devuelve struct, pero en este momento el compilador sabe que su convención de llamada es C++. De igual forma, el puntero de función, que devuelve struct, se define a continuación de la definición de struct para que el compilador sepa que struct usa la convención de llamada de C++.
Para resolver este error producido a consecuencia de convenciones de llamada incompatibles, declare funciones que devuelvan un tipo definido por el usuario después de la definición del tipo.
// C2440b.cpp
struct MyStruct;
MyStruct get_c1();
struct MyStruct {
int i;
static MyStruct get_C2();
};
MyStruct get_C3();
typedef MyStruct (*FC)();
FC fc1 = &get_c1; // C2440, line 15
FC fc2 = &MyStruct::get_C2; // C2440, line 16
FC fc3 = &get_C3;
class CMyClass {
public:
explicit CMyClass( int iBar)
throw() {
}
static CMyClass get_c2();
};
int main() {
CMyClass myclass = 2; // C2440
// try one of the following
// CMyClass myclass(2);
// CMyClass myclass = (CMyClass)2;
int *i;
float j;
j = (float)i; // C2440, cannot cast from pointer to int to float
}
El error C2440 también se puede producir si se asigna el valor cero a un puntero interior:
// C2440c.cpp
// compile with: /clr
int main() {
array<int>^ arr = gcnew array<int>(100);
interior_ptr<int> ipi = &arr[0];
ipi = 0; // C2440
ipi = nullptr; // OK
}
El error C2440 también se puede deber a un uso incorrecto de una conversión definida por el usuario. Para obtener más información sobre las conversiones definidas por el usuario, vea User-Defined Conversions. El ejemplo siguiente genera el error C2440.
// C2440d.cpp
// compile with: /clr
value struct MyDouble {
double d;
// convert MyDouble to Int32
static explicit operator System::Int32 ( MyDouble val ) {
return (int)val.d;
}
};
int main() {
MyDouble d;
int i;
i = d; // C2440
// Uncomment the following line to resolve.
// i = static_cast<int>(d);
}
El error C2440 también se puede producir si se intenta crear una instancia de una matriz de Visual C++ cuyo tipo es Array. Para obtener más información, vea array (Visual C++). El ejemplo siguiente genera el error C2440.
// C2440e.cpp
// compile with: /clr
using namespace System;
int main() {
array<int>^ intArray = Array::CreateInstance(__typeof(int), 1); // C2440
// try the following line instead
// array<int>^ intArray = safe_cast<array<int> ^>(Array::CreateInstance(__typeof(int), 1));
}
El error C2440 también se puede deber a cambios en la función de atributos. El ejemplo siguiente genera el error C2440.
// c2440f.cpp
// compile with: /LD
[ module(name="PropDemoLib", version=1.0) ]; // C2440
// try the following line instead
// [ module(name="PropDemoLib", version="1.0") ];
Este error también se puede generar como resultado de un trabajo de conformidad del compilador efectuado para Visual C++ 2005: el compilador de Visual C++ ya no permite el const_cast Operator para realizar una conversión a un tipo inferior al compilar código fuente que utiliza programación /clr.
Para resolver el error C2440, utilice el operador de conversión correcto (para obtener más información, vea Casting Operators). Vea Cambios importantes en el compilador de Visual C++ 2005 para obtener más información.
El ejemplo siguiente genera el error C2440.
// c2440g.cpp
// compile with: /clr
ref class Base {};
ref class Derived : public Base {};
int main() {
Derived ^d = gcnew Derived;
Base ^b = d;
d = const_cast<Derived^>(b); // C2440
d = dynamic_cast<Derived^>(b); // OK
}
El error C2440 también se puede generar utilizando /clr:oldSyntax. El ejemplo siguiente genera el error C2440.
// c2440h.cpp
// compile with: /clr:oldSyntax
__gc class Base {};
__gc class Derived : public Base {};
int main() {
Derived *d = new Derived;
Base *b = d;
d = const_cast<Derived*>(b); // C2440
d = dynamic_cast<Derived*>(b); // OK
}