Compilador erro C2440

Mensagem de erro

'conversão de': não é possível converter de 'tipo' para 'type2'

O compilador não é possível converter de ' type1'para'type2'.

C2440 pode ocorrer sistema autônomo resultado de conformidade e o trabalho de atualização que foi concluído na biblioteca C++ padrão.Consulte Alterações de biblioteca C++ padrão: O Visual C++ .NET 2003 e Alterações de biblioteca nas versões do Visual C++ para mais informações.

Exemplo

C2440 pode ser causado se você tentar converter um ponteiro para o membro para void *.O exemplo a seguir gera 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);
   }
};

Os erros C2440 nas linhas de 15 e 16 da próxima amostra serão qualificados com o Incompatible calling conventions for UDT return value mensagem. (Um UDT é um tipo definido pelo usuário, sistema autônomo uma classe, struct ou união.) Esses tipos de erros de incompatibilidade são causados quando a convenção de chamada de um UDT especificada no tipo de retorno de uma declaração de reenvio conflitos com a convenção de chamada real de UDT e quando um ponteiro de função está envolvido.

No exemplo, primeiro precisamos encaminhar declarações para uma struct e para uma função que retorna o struct; o compilador pressupõe que a estrutura usa a convenção de chamada de C++.Em seguida, temos a definição de struct, que, por padrão, usa a convenção C de chamada.Visto que o compilador não sabe a convenção de chamada da estrutura até terminar de ler a estrutura inteira, a convenção de chamada para struct no tipo de retorno de get_c2 será também pressuposta ser C++.

O struct é seguido por outra declaração de função que retorna o struct, mas neste ponto, o compilador sabe que convenção de chamada do struct é C++.Da mesma forma, o ponteiro de função, que retorna o struct, é definido após a definição de struct para que o compilador sabe que a estrutura usa a convenção de chamada de C++.

Para resolver C2440 causa de convenções de chamada incompatíveis, declare funções que retornam um UDT após a definição de UDT.

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

C2440 também pode ocorrer se você atribuir zero a um ponteiro 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
}

C2440 também pode ocorrer por um uso incorreto de uma conversão definida pelo usuário.Para obter mais informações sobre conversões definidas pelo usuário, consulte User-Defined Conversions). O exemplo a seguir gera 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);
}

C2440 também pode ocorrer se você tentar criar uma instância de uma matriz do Visual C++ cujo tipo é um Array. Para obter mais informações, consulte matriz (Visual C++). O exemplo a seguir gera 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));
}

C2440 também pode ocorrer devido às alterações no recurso de atributos.O exemplo a seguir gera 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 erro também pode ser gerado sistema autônomo resultado do compilador conformidade trabalho foi realizado em Visual C++ 2005: o compilador do Visual C++ não permite mais o const_cast Operador para baixo de conversão durante a compilação de código-fonte que usa programação CLR.

Para resolver este C2440, use o operador de conversão correto (para obter mais informações, consulte Projetando uma operadores). Consulte Quebrar alterações no compilador de 2005 Visual C++ para obter mais informações.

O exemplo a seguir gera 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
}

C2440 também pode ser gerada usando /clr:oldSyntax. O exemplo a seguir gera 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
}