Delen via

Compilerfout C2664

'functie': argument n kan niet worden geconverteerd van 'type1' naar 'type2'

Opmerkingen

Dit probleem met parameterconversie kan optreden als er een exemplaar van een klasse wordt gemaakt en een impliciete conversie wordt uitgevoerd op een constructor die is gemarkeerd met het explicit trefwoord. Voor meer informatie over expliciete conversies, zie User-Defined Typeconversies.

Als een tijdelijk object wordt doorgegeven aan een functie die een verwijzing naar een object als parameter gebruikt, moet deze verwijzing een const verwijzing zijn.

Als de functie wordt doorgegeven aan een parameter die niet van het type is dat de functie verwacht, wordt er een tijdelijk object gemaakt met behulp van de juiste constructor. Dit tijdelijke object wordt vervolgens doorgegeven aan de functie. In dit geval wordt het tijdelijke object gebruikt om de verwijzing te initialiseren. In eerdere versies van de taal kunnen alle verwijzingen worden geïnitialiseerd door tijdelijke objecten.

Om C2664 te herstellen,

  • Controleer het prototype voor de opgegeven functie opnieuw en corrigeer het argument dat in het foutbericht is vermeld.

  • Geef indien nodig een expliciete conversie op.

C2664 kan ook worden gegenereerd als een klasse een lid in een van de basisklassen verbergt.

Voor meer informatie, zie Hoe te: Systeem::Tekenreeks converteren naar wchar_t* of char*.

Voorbeelden

In het volgende voorbeeld wordt C2664 gegenereerd en ziet u hoe u dit kunt oplossen.

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

In dit voorbeeld wordt ook C2664 gegenereerd en wordt getoond hoe u dit kunt oplossen.

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

In het volgende voorbeeld wordt C2664 gedemonstreerd door gebruik te maken van een stringliteral om Test aan te roepen, en wordt getoond hoe dit kan worden opgelost. Omdat de parameter een szString verwijzing is, moet een object worden gemaakt door de juiste constructor. Het resultaat is een tijdelijk object dat niet kan worden gebruikt om de verwijzing te initialiseren.

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

De compiler dwingt de C++ standaardvereisten af voor het toepassen van const. In dit voorbeeld wordt C2664 gegenereerd:

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

void func1(LPCSTR &s)
{

}

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

int main()
{
   return 0;
}

Hier volgt een complexere situatie waarin C2664 wordt gegenereerd, inclusief instructies voor het oplossen ervan:

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

Een enumvariabele wordt niet geconverteerd naar het onderliggende type, zodat aan een functieaanroep wordt voldaan. Zie de enum-klasse voor meer informatie. In het volgende voorbeeld wordt C2664 gegenereerd en ziet u hoe u dit kunt oplossen.

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

Een fout in de midl-compiler zorgt ervoor dat een wchar_t type wordt verzonden als een niet-ondertekend kort in de typebibliotheek. Als u deze fout wilt oplossen, cast u het type in uw C++-broncode of definieert u het type als een tekenreeks in het idl-bestand.

// 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 treedt ook op wanneer wchar_t wordt gebruikt bij het porteren van code van Visual C++ 6.0 naar latere versies. In Visual C++ 6.0 en eerder was wchar_t een typedef voor unsigned short en daarom impliciet converteerbaar naar dat type. Na Visual C++ 6.0 is het wchar_t eigen ingebouwde type, zoals opgegeven in de C++-standaard en is deze niet langer impliciet converteerbaar naar unsigned short. Zie /Zc:wchar_t (wchar_t is systeemeigen type).

In het volgende voorbeeld wordt C2664 gegenereerd en ziet u hoe u dit kunt oplossen.

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

C2664 wordt ook veroorzaakt als de compiler geen sjabloonargumenten kan afleiden.

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