Megosztás a következőn keresztül:

C2664-fordítási hiba

"függvény": nem lehet az n argumentumot "típus1" típusról "típus2" típusra konvertálni

Megjegyzések

Ez a paraméterkonvertálási probléma akkor fordulhat elő, ha létrehoz egy osztálypéldányt, és implicit konverziót kísérel meg egy kulcsszóval explicit megjelölt konstruktoron. Explicit konverziókkal kapcsolatos további információkért lásd a Felhasználó által definiált típuskonverziókat.

Ha egy ideiglenes objektumot olyan függvénynek ad át, amely paraméterként hivatkozik egy objektumra, annak hivatkozásnak kell lennie const .

Ha a függvény olyan paramétert ad át, amely nem a függvény által várt típus, a megfelelő konstruktor használatával ideiglenes objektum jön létre. Ezt az ideiglenes objektumot ezután átadja a függvénynek. Ebben az esetben az ideiglenes objektum a hivatkozás inicializálására szolgál. A nyelv korábbi verzióiban az összes hivatkozás inicializálható ideiglenes objektumokkal.

A C2664 javításához

  • Ellenőrizze újra az adott függvény prototípusát, és javítsa ki a hibaüzenetben szereplő argumentumot.

  • Szükség esetén adjon meg egyértelmű konverziót.

A C2664 akkor is létrehozható, ha egy osztály elrejt egy tagot az egyik alaposztályában.

További információért lásd: How to: Convert System::String to wchar_t* or char*.

Példák

Az alábbi példa létrehozza a C2664-et, és bemutatja, hogyan lehet kijavítani.

// C2664.cpp
// C2664
struct A {
   void f(int i) {}
};

struct B : public A {
   // To fix, uncomment the following line.
   // using A::f;
   void f(A a) {}
};

int main() {
   B b;
   int i = 1;
   b.f(i);   // B::f hides A::f Uncomment the using declaration in B.
}

Ez a példa a C2664-et is létrehozza, és bemutatja a javítás módját.

// C2664b.cpp
// C2664 expected
struct A {
   // To fix, uncomment the following line.
   // A(int i){}
};

void func( int, A ) {}

int main() {
   func( 1, 1 );   // No conversion from int to A.
}

A következő példa bemutatja a C2664-et egy szöveges literál használatával Test hívásához, és megmutatja, hogyan javítható ki. Mivel a paraméter hivatkozás szString , a megfelelő konstruktornak létre kell hoznia egy objektumot. Az eredmény egy ideiglenes objektum, amely nem használható a hivatkozás inicializálására.

// C2664c.cpp
// compile with: /EHsc
// C2664 expected
#include <iostream>
#include <string.h>
using namespace std;

class szString {
   int slen;
   char *str;

public:
   szString(const char *);
   int len() const {
      return slen;
   }
};

// Simple reference cannot bind to temp var.
void Test(szString &a) {}

// To fix, uncomment the following line.
// void Test(const szString &a) {}

szString::szString(const char * newstr) : slen(0), str(NULL) {
   slen=strlen(newstr);
   str = new char[slen + 1];
   if (str)
      strcpy_s(str, (slen + 1), newstr);
}

int main() {
   Test("hello");
}

A fordító kikényszeríti a C++ szabvány követelményeinek alkalmazását const. Ez a példa c2664-et hoz létre:

// C2664d.cpp
// C2664 expected
#include <windows.h>

void func1(LPCSTR &s)
{

}

void func2(LPSTR &s)
{
   func1(s);
}

int main()
{
   return 0;
}

Íme egy összetettebb helyzet, amelyben a C2664 létrejön, beleértve a javításra vonatkozó útmutatást:

// C2664e.cpp
// compile with: /EHsc
// C2664 expected
#define _INTL
#include <locale>
#include <iostream>

using namespace std;
#define LEN 90

int main( ) {
   char* pszExt = "This is the string to be converted!";
   wchar_t pwszInt [LEN+1];
   memset(&pwszInt[0], 0, (sizeof(wchar_t))*(LEN+1));

   // To fix, delete the following line.
   char* pszNext;

   // To fix, uncomment the following line.
   // const char* pszNext;

   wchar_t* pwszNext;
   mbstate_t state;
   locale loc("C");
   int res = use_facet<codecvt<wchar_t, char, mbstate_t> >
      ( loc ).in( state,
      pszExt, &pszExt[strlen(pszExt)], pszNext,
      pwszInt, &pwszInt[strlen(pszExt)], pwszNext );
   // See earlier comment.
      pwszInt[strlen(pszExt)] = 0;
   wcout << ( (res!=codecvt_base::error) ?
                       L"It worked! " : L"It didn't work! " )
   << L"The converted string is:\n ["
   << &pwszInt[0]
   << L"]" << endl;

   exit(-1);
}

Az enum változók nem lesznek átalakítva a mögöttes típusra, így a függvényhívások teljesülnek. További információkért lásd az enumerálási osztályt. Az alábbi példa létrehozza a C2664-et, és bemutatja, hogyan lehet kijavítani.

// C2664f.cpp
// compile with: /clr
using namespace System;
public enum class A : Char {
   None = 0,
   NonSilent = 1,
};

void Test(Char c) {}

int main() {
   A aa = A::None;
   Test(aa);   // C2664
   Test(Char(aa));   // OK - fix by using a conversion cast
}

A midl-fordító hibája miatt a wchar_t típus unsigned short típusúként lesz kibocsátva a típus könyvtárban. A hiba megoldásához adja meg a típust a C++ forráskódban, vagy definiálja a típust szövegként az IDL fájlban.

// C2664g.idl
import "prsht.idl";

[ object, uuid(8402B8F1-BF7F-4B49-92D4-C2B9DF4543E9) ]

interface IMyObj1 : IUnknown {
   HRESULT  teststr([in, string] wchar_t *wstr);
   HRESULT  testarr([in, size_is(len)] wchar_t wstr[], [in] int len);
   HRESULT  testbstr([in] BSTR bstr);
};

[  uuid(44463307-CBFC-47A6-8B4F-13CD0A83B436) ]
library myproj1 {
   [  version(1.0), uuid(D8622C12-5448-42B8-8F0E-E3AD6B8470C1) ]
   coclass CMyObj1 { interface IMyObj1; };
}

C2664 akkor is előfordulhat, ha wchar_t-ot használnak a kód Visual C++ 6.0-ból későbbi verziókba való átültetésekor. A Visual C++ 6.0-s és korábbi verzióiban a wchar_ttypedef volt unsigned short számára, és ezért implicit módon átalakítható volt erre a típusra. A Visual C++ 6.0 után a C++ szabványban megadott önálló beépített típus, és már nem konvertálható implicit módon unsigned short-re. Lásd /Zc:wchar_t (wchar_t natív típus).

Az alábbi példa létrehozza a C2664-et, és bemutatja, hogyan lehet kijavítani.

// C2664h.cpp
#import "C2664g.tlb"
using namespace myproj1;

int main() {
   IMyObj1Ptr ptr;

   wchar_t * mybuff = 0;
   BSTR bstr = 0;
   int len;
   ptr->teststr(mybuff);
   ptr->testbstr(bstr);
   ptr->testarr(mybuff, len);   // C2664
   ptr->testarr((unsigned short *)mybuff, len);   // OK - Fix by using a cast
}

A C2664 akkor is keletkezik, ha a fordító nem tudja a sablon argumentumokat kikövetkeztetni.

// C2664i.cpp
#include <stdio.h>
template <class T, int iType=0>
class CTypedImg {
public:
   CTypedImg() {}
   void run() {}

   operator CTypedImg<T>& () {
      return *((CTypedImg<T>*)this);
    }
};

template <class t1>
void test(CTypedImg<t1>& myarg) {
   myarg.run();
}

int main() {
   CTypedImg<float,2> img;

   test((CTypedImg<float>&)img);   // OK
   test<float>(img);   // OK
   test(img);   // C2664 - qualify as above to fix
}
  • Last updated on