C ++ Fehler erwarteter primärer Ausdruck vorher erwartete

Beim Schreiben eines Code kann ein Programmierer auf einige Unklarheiten stoßen. Es gibt verschiedene Arten von Fehlern wie logische Fehler, Kompilierungszeitfehler oder Syntaxfehler. Logische Fehler sind schwer zu verstehen, da es keinen Fehler anzeigt, während die Syntax- und Kompilierungszeitfehler nicht einmal ausgeführt werden. Sie generieren einen Fehler, während die Zusammenstellung des Code startet.

Heute werden wir über einen Syntaxfehler diskutieren, der aufgrund von etwas auftreten kann, das im Code fehlt oder etwas, das dem Code hinzugefügt wird. Der Fehler, den wir diskutieren werden, ist "erwarteter primärer Ausdruck". Dieser Fehler tritt hauptsächlich auf, wenn ein fehlender Schlüsselwort fehlt. Um diesen Fehler kennenzulernen, gibt es am Ende ein Schlüsselwort oder Zeichen, das den Grund für das Auftreten des Fehlers zeigt. Wenn die Syntax nicht korrekt vom Codierer gefolgt wird, wird erfolgreich ausgeführt. Es zeigt den Fehler an, der die Zeile angibt, in der sie auftritt.

Die Hauptgründe für das Auftreten des Fehlers sind:

• Wenn der Datentyp des Arguments auch mit der Variablen angegeben ist, ruft er einen Fehler auf.
• Wenn das übergebene Argument der falsche Typ ist, wie das Übergeben einer Zeichenfolge an die Funktion ein falscher Typ, da wir keine Zeichenfolge an die Funktion übergeben können.
• Wenn die lockigen Klammern fehlen, werden aus Versehen zusätzliche Zahnspangen hinzugefügt, was den Fehler erzeugt.
• Es tritt auch auf, wenn die Klammer in der IF -Aussage keinen Ausdruck oder Ergebnis hat.

Syntax:

Wie wir in der Einführung besprochen haben, ist dies ein Fehler und kein Code, das eine bestimmte Syntax haben muss. Das Folgende ist die Fehlereisenprobe dessen, wie es aussieht, wie es aussieht.

Fehler: Erwarteter primärer Ausdruck vor dem 'Element'

Im vorherigen Fehler bezeichnet "Element" das Schlüsselwort, in dem ein Ausdruck fehlt oder hinzugefügt wird. Ein Ausdruck kann ein Zeichen, ein arithmetischer Wert, Zahnspangen oder ein relationaler Ausdruck sein.

Beispiel 1:

Jetzt führen wir ein Beispiel aus, in dem wir zwei Variablen in einer benutzerdefinierten Funktion hinzufügen und dann die Summe beider Werte anzeigen. Lassen Sie uns unsere Header -Dateien "iOstream" und "String" einschließen. Mit IOstream können der Compiler die eingebauten E/A -Operationen verwenden, die von ihm bereitgestellt werden, wobei die Zeichenfolge es uns ermöglicht, mit der Sammlung von Zeichen zu arbeiten. Als Nächst. In dieser Funktion deklarieren wir eine variable namens Addition, die dafür verantwortlich ist, die Summe von „var1“ und „var2 Variablen“ zu halten.

Wenn wir nun zur Hauptfunktion gehen, bei der wir den Ganzzahlwert „Ergebnis“ definieren, dem wir die myfunct () -Methode zuweisen, indem wir zwei Ganzzahlwerte übergeben, „20“ und „30“. Danach führen wir den Rückgabewert der Funktion aus, die in der Variablen „Ergebnis“ unter Verwendung der Cout -Anweisung gespeichert ist, die von der iOstream -Bibliothek bereitgestellt wird.

#enthalten
#enthalten
Verwenden von Namespace STD;
int myfunct (int var1, int var2)

int Addition;
Addition = var1 + var2;
Rückgaberadung;

int main ()

int result = myFunct (20, 30);
std :: Cout << "addition of var1 and var2 is:"<< result << std::endl;

Nach der Ausführung des Codes stoßen wir in Zeile 12 auf zwei Fehler. Argumente werden immer ohne den Datentyp an den Funktionsaufruf übergeben. Jetzt entfernen wir den Fehler, indem wir die Datentypen eliminieren, die wir an ihn weitergeben, und dann den Code erneut ausführen.

Nach der erneuten Ausführung haben wir den Rückgabwert des Hinzufügens erfolgreich angezeigt, wie wir im folgenden Screenshot sehen können:

Beispiel 2:

Jetzt versuchen wir ein anderes Beispiel, in dem wir die Länge des Wortes berechnen, seine Permutation berechnen und es anzeigen. Nachdem wir die Header -Dateien eingefügt haben, deklarieren wir die drei Funktionen. Die Funktion getData (), die vom Benutzer eine Zeichenfolge erhält. In dieser Methode deklarieren wir eine String -Variable, "Wort",. Mit der Anweisung "CIN" erhalten wir die Zeichenfolge vom Benutzer und geben seinen Wert zurück. Die zweite Funktion ist die "Länge_Count ()", die die Länge der Zeichenfolge anhand der Methodenlänge () berechnet und ihren Wert zurückgibt. Die dritte Funktion lautet "myfunc ()", der überprüft, ob die Stringlänge größer als "1" ist. Dann berechnet es die Permutation und gibt sie ansonsten zurück. Es gibt einfach die Länge der Zeichenfolge zurück.

Endlich wechseln wir zur Hauptfunktion, in der wir eine Zeichenfolgenvariable mit dem Namen „Wort“ deklarieren, die wir den Funktionsaufruf des getData zugewiesen haben (). Dies bedeutet, dass die Daten, die wir vom Benutzer übernommen haben mit seinem "String" -Datenatype. Mithilfe der Cout -Anweisung zeigen wir endlich das Ergebnis der Permutation der Zeichenfolge, die wir vom Benutzer entnommen haben, und führen den Code aus.

#enthalten
#enthalten
Verwenden von Namespace STD;
String getData ();
int length_count (Stringwort);
int myfunc (int WordLength);
String getData ()

Saitenwort;
Cout << "Please enter a word: ";
Cin >> Wort;
Word zurückgeben;

int length_count (Stringwort)

int wordLength;
WordLength = Wort.Länge();
WordLength zurückgeben;

int myfunc (int wordLength)

if (WordLength == 1)

WordLength zurückgeben;

anders

return wordLength * myfunc (WordLength - 1);


int main ()

String word = getData ();
int WordLength = Länge_Count (String -Wort);
Cout << word << " has " << myfunc(wordLength) << " permutations." << endl;
Rückkehr 0;

Nach der Ausführung erhalten wir diesen Fehler, der anzeigt, dass wir in Zeile 43 einen Fehler gemacht haben. Wir übergeben den Datentyp zusammen mit der Variablen an die Funktion. Wie wir wissen, können wir den Datentyp nicht an die Variable übergeben. Jetzt versuchen wir, diesen Fehler zu beheben, indem wir den Datentyp aus dem Funktionsaufruf entfernen und erneut ausführen.

Nachdem wir den Code erneut ausgeführt haben. Danach wird die Permutation des Codes wie im Folgenden gezeigt angezeigt:

Abschluss

In diesem Artikel haben wir den Fehlertyp untersucht, der beim Schreiben des Codes möglicherweise auftreten kann. Manchmal kann der Coder etwas vermissen oder er/sie kann einen Ausdruck hinzufügen oder eine falsche Syntax für die Funktionen oder Aussagen versehentlich deklarieren. Durch die Verwendung der detaillierten Überprüfung und Implementierung der Beispiele haben wir kurz den Fehler und den Grund beschrieben, aus dem dieser Fehler auftritt. Wir haben auch die Methodik zur Lösung dieser Fehler diskutiert. Wir hoffen, dass dieser Artikel für Sie hilfreich ist, um diese Art von Fehlern zu lösen.