Errore del compilatore C2143

errore di sintassi: mancante 'token1' prima di 'token2'

Il compilatore prevedeva un token specifico( ovvero un elemento del linguaggio diverso da uno spazio vuoto) e trovato un altro token.

Controllare il riferimento al linguaggio C++ per determinare dove il codice è sintatticamente errato. Poiché il compilatore può segnalare questo errore dopo aver rilevato la riga che causa il problema, controllare diverse righe di codice che precedono l'errore.

C2143 può verificarsi in situazioni diverse.

Può verificarsi quando un operatore che può qualificare un nome (::, -> e .) deve essere seguito dalla parola chiave template, come nel seguente esempio:

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

Per impostazione predefinita, in C++ si presuppone che Ty::PutFuncType non è un modello; pertanto, < viene interpretato come segno minore di. È necessario indicare al compilatore in modo esplicito che PutFuncType è un modello in modo da poter analizzare correttamente la parentesi angolare. Per correggere questo errore, utilizzare la parola chiave template sul nome del tipo dipendente, come illustrato di seguito:

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

C2143 può verificarsi quando si usa /clr e una using direttiva presenta un errore di sintassi:

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

Può verificarsi anche quando si tenta di compilare un file di codice sorgente usando la sintassi CLR senza usare anche /clr:

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

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

Il primo carattere diverso da uno spazio vuoto successivo a un'istruzione if deve essere una parentesi di apertura. Il compilatore non può tradurre altro:

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

   // OK
   if (j < 25)
      ;

   if (j < 25)   // C2143
}

C2143 può verificarsi quando sulla riga in cui viene rilevato l'errore o su una delle righe immediatamente precedenti quando manca una parentesi graffa o tonda di chiusura oppure un punto e virgola:

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

In alternativa, quando è presente un tag non valido in una dichiarazione di classe:

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

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

In alternativa, quando un'etichetta non è collegata ad un'istruzione. Se è necessario inserire un'etichetta per se stessa, ad esempio, alla fine di un'istruzione composta, allegarla a un'istruzione Null:

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

   end2:   // C2143
}

L'errore può verificarsi quando viene effettuata una chiamata non qualificata a un tipo nella libreria standard C++:

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

In alternativa, c'è una parola chiave typename mancante:

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

In alternativa, se si tenta di definire una creazione di istanza esplicita:

// 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 un programma C, le variabili devono essere dichiarate all'inizio della funzione e non possono essere dichiarate dopo che la funzione esegue istruzioni non di dichiarazione.

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