Compilerfout C2143

syntaxisfout: token1 ontbreekt voor 'token2'

Opmerkingen

De compiler verwachtte een specifiek token (een taalelement anders dan witruimte) en vond in plaats daarvan een ander token.

Controleer de C++-taalverwijzing om te bepalen waar code syntactisch onjuist is. Omdat de compiler deze fout kan melden nadat deze de regel tegenkomt die het probleem veroorzaakt, controleert u verschillende regels code die voorafgaan aan de fout.

C2143 kan in verschillende situaties optreden.

Voorbeelden

Dit kan gebeuren wanneer een operator die een naam kan kwalificeren (::, ->en .) moet worden gevolgd door het trefwoord template, zoals in dit voorbeeld:

class MyClass
{
    template<class Ty, typename PropTy>
    struct PutFuncType : public Ty::PutFuncType<Ty, PropTy> // error C2143
    {
    };
};

Standaard wordt in C++ ervan uitgegaan dat dit Ty::PutFuncType geen sjabloon is. Daarom wordt het volgende < geïnterpreteerd als een kleiner teken. U moet de compiler expliciet vertellen dat PutFuncType dit een sjabloon is, zodat deze de hoekhaak correct kan parseren. Als u deze fout wilt corrigeren, gebruikt u het template trefwoord op de naam van het afhankelijke type, zoals hier wordt weergegeven:

class MyClass
{
    template<class Ty, typename PropTy>
    struct PutFuncType : public Ty::template PutFuncType<Ty, PropTy> // correct
    {
    };
};

C2143 kan optreden wanneer /clr wordt gebruikt en een using instructie een syntaxisfout heeft:

// C2143a.cpp
// compile with: /clr /c
using namespace System.Reflection;   // C2143
using namespace System::Reflection;

Dit kan ook gebeuren wanneer u probeert een broncodebestand te compileren met behulp van CLR-syntaxis zonder eveneens /clr te gebruiken.

// C2143b.cpp
ref struct A {   // C2143 error compile with /clr
   void Test() {}
};

int main() {
   A a;
   a.Test();
}

Het eerste niet-witruimteteken dat volgt op een if statement, moet een linkerhaakje zijn. De compiler kan niets anders vertalen:

// C2143c.cpp
int main() {
   int j = 0;

   // OK
   if (j < 25)
      ;

   if (j < 25)   // C2143
}

C2143 kan optreden wanneer een accolade, haakje of puntkomma ontbreekt op de regel waarop de fout wordt gedetecteerd of op een van de bovenstaande regels:

// C2143d.cpp
// compile with: /c
class X {
   int member1;
   int member2   // C2143
} x;

Of wanneer er een ongeldige tag in een klassedeclaratie staat:

// C2143e.cpp
class X {
   int member;
} x;

class + {};   // C2143 + is an invalid tag name
class ValidName {};   // OK

Of wanneer een label niet is gekoppeld aan een instructie. Als u een label zelf moet plaatsen, bijvoorbeeld aan het einde van een samengestelde instructie, voegt u het toe aan een null-instructie:

// C2143f.cpp
// compile with: /c
void func1() {
   // OK
   end1:
      ;

   end2:   // C2143
}

De fout kan optreden wanneer een niet-gekwalificeerde aanroep wordt gedaan naar een type in de standaardbibliotheek van C++ :

// C2143g.cpp
// compile with: /EHsc /c
#include <vector>
static vector<char> bad;   // C2143
static std::vector<char> good;   // OK

Of er ontbreekt typename een trefwoord:

// C2143h.cpp
template <typename T>
struct X {
   struct Y {
      int i;
   };
   Y memFunc();
};
template <typename T>
X<T>::Y X<T>::memFunc() {   // C2143
// try the following line instead
// typename X<T>::Y X<T>::memFunc() {
   return Y();
}

Of als u een expliciete instantiëring probeert te definiëren:

// C2143i.cpp
// compile with: /EHsc /c
// template definition
template <class T>
void PrintType(T i, T j) {}

template void PrintType(float i, float j){}   // C2143
template void PrintType(float i, float j);   // OK

In een C-programma moeten variabelen aan het begin van de functie worden gedeclareerd en kunnen ze niet worden gedeclareerd nadat de functie niet-declaratie-instructies heeft uitgevoerd.

// C2143j.c
int main()
{
    int i = 0;
    i++;
    int j = 0; // C2143
}