C2440 ошибка c как зафиксить

// C2440s.cpp // Build: cl /Zc:strictStrings /W3 C2440s.cpp // When built, the compiler emits: // error C2440: 'initializing' : cannot convert from 'const char [5]' // to 'char *' // Conversion from string literal loses const qualifier (see // /Zc:strictStrings) int main() { char* s1 = "test"; // C2440 const char* s2 = "test"; // OK }

// C2440u8.cpp // Build: cl /std:c++20 C2440u8.cpp // When built, the compiler emits: // error C2440: 'initializing' : cannot convert from 'const char8_t [5]' // to 'const char *' // note: Types pointed to are unrelated; conversion requires // reinterpret_cast, C-style cast or function-style cast) int main() { const char* s1 = u8"test"; // C2440 under /std:c++20 or /Zc:char8_t, OK in C++17 const char8_t* s2 = u8"test"; // OK under /std:c++20 or /Zc:char8_t, C4430 in C++17 const char* s3 = reinterpret_cast<const char*>(u8"test"); // OK }

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

// c2440a.cpp struct Base { }; // Defined struct Derived; // Forward declaration, not defined Base * func(Derived * d) { return static_cast<Base *>(d); // error C2440: 'static_cast' : cannot convert from 'Derived *' to 'Base *' }

// 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(2); int *i; float j; j = (float)i; // C2440, cannot cast from pointer to int to float }

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

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

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

// c2440f.cpp // compile with: /LD [ module(name="PropDemoLib", version=1.0) ]; // C2440 // try the following line instead // [ module(name="PropDemoLib", version="1.0") ];

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

// c2440h.cpp template<int *a> struct S1 {}; int g; struct S2 : S1<&g> { }; int main() { S2 s; static_cast<S1<&*&g>>(s); // C2440 in VS 2015 Update 3 // This compiles correctly: // static_cast<S1<&g>>(s); }

// C2440j.cpp struct A { explicit A(int) {} A(double) {} }; int main() { const A& a2 = { 1 }; // error C2440: 'initializing': cannot // convert from 'int' to 'const A &' }

// C2440k.cpp struct A { explicit A(int) {} A(double) {} }; int main() { const A& a2{ 1 }; }

struct S { S(int); operator int(); }; int i = (const S)0; // error C2440

// C2440s.cpp
// Build: cl /Zc:strictStrings /W3 C2440s.cpp
// When built, the compiler emits:
// error C2440: 'initializing' : cannot convert from 'const char [5]'
// to 'char *'
//        Conversion from string literal loses const qualifier (see
// /Zc:strictStrings)

int main() {
   char* s1 = "test"; // C2440
   const char* s2 = "test"; // OK
}

// C2440u8.cpp
// Build: cl /std:c++20 C2440u8.cpp
// When built, the compiler emits:
// error C2440: 'initializing' : cannot convert from 'const char8_t [5]'
// to 'const char *'
// note: Types pointed to are unrelated; conversion requires
// reinterpret_cast, C-style cast or function-style cast)

int main() {
   const char* s1 = u8"test"; // C2440 under /std:c++20 or /Zc:char8_t, OK in C++17
   const char8_t* s2 = u8"test"; // OK under /std:c++20 or /Zc:char8_t, C4430 in C++17
   const char* s3 = reinterpret_cast<const char*>(u8"test"); // OK
}

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

// c2440a.cpp
struct Base { }; // Defined

struct Derived; // Forward declaration, not defined

Base * func(Derived * d) {
    return static_cast<Base *>(d); // error C2440: 'static_cast' : cannot convert from 'Derived *' to 'Base *'
}

// 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(2);

   int *i;
   float j;
   j = (float)i;   // C2440, cannot cast from pointer to int to float
}

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

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

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

// c2440f.cpp
// compile with: /LD
[ module(name="PropDemoLib", version=1.0) ];   // C2440
// try the following line instead
// [ module(name="PropDemoLib", version="1.0") ];

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

// c2440h.cpp

template<int *a>
struct S1 {};

int g;
struct S2 : S1<&g> {
};

int main()
{
    S2 s;
    static_cast<S1<&*&g>>(s); // C2440 in VS 2015 Update 3
    // This compiles correctly:
    // static_cast<S1<&g>>(s);
}

// C2440j.cpp
struct A
{
    explicit A(int) {}
    A(double) {}
};

int main()
{
    const A& a2 = { 1 }; // error C2440: 'initializing': cannot
                         // convert from 'int' to 'const A &'
}

// C2440k.cpp
struct A
{
    explicit A(int) {}
    A(double) {}
};

int main()
{
    const A& a2{ 1 };
}

struct S
{
    S(int);
    operator int();
};

int i = (const S)0; // error C2440