Programmiersprachen benötigen Bibliotheken, Funktionen, Syntax und andere Dinge, wenn sie mit ihnen arbeiten. Daher besteht die Möglichkeit, dass unsere Codes Fehler enthalten. Beim Programmieren in C++ gibt es viele verschiedene Arten von Fehlern. Wir werden hier über den Fehler „int kann in C++ nicht dereferenziert werden“ diskutieren. Dieser Fehler tritt auf, wenn wir versuchen, den Dereferenzierungsoperator „*“ mit den Ganzzahldaten „int“ zu verwenden, da „int“ ein primitiver Datentyp ist. Wir können „int“ in der C++-Programmierung nicht dereferenzieren. Hier wird der Fehler „int kann in C++ nicht dereferenziert werden“ und seine Lösung eingehend untersucht. In diesem Handbuch werden einige Codes angegeben, in denen wir sehen, wie dieser Fehler auftritt und wie mit dieser Art von Fehler in C++ umgegangen wird.
Beispiel 1: Dereferenzierung von Int
In diesem Code werden wir versuchen, das „int“ in C++ zu dereferenzieren. Jetzt fügen wir einfach die Header-Datei „iostream“ ein, um die definierten Funktionen zu nutzen. Darunter nutzen wir den „namespace std“ und rufen hier die Methode „main()“ auf. Anschließend deklarieren wir die Variable „my_num“ mit dem Datentyp „int“ und weisen dieser Variablen „99“ zu.
Jetzt deklarieren wir „my_value“ vom Datentyp „int“ und initialisieren ihn mit „*my_num“, was bedeutet, dass wir versuchen, die Variable „my_num“ zu dereferenzieren, die vom Datentyp „int“ ist. Der Fehler wird beim Kompilieren in dieser Zeile generiert, da wir „int“ nicht dereferenzieren können. Wir möchten den Wert anzeigen, den wir nach der Dereferenzierung von int erhalten, also platzieren wir den „cout“, in dem wir die Variable „my_value“ hinzugefügt haben.
Code 1:
#include
Verwenden des Namensraums std;
int main ( ) {
int my_num = 99 ;
int my_value = * meine_num;
cout << „Der Wert, den wir durch die Dereferenzierung des int erhalten, ist:“ << mein_wert << endl;
zurückkehren 0 ;
}
Ausgabe:
Hier stellen wir möglicherweise fest, dass kein Wert angezeigt wird und ein Fehler auftritt, der besagt, dass es ein ungültiges Typargument des unären „*“ gibt. Das bedeutet, dass wir „int“ in C++ nicht dereferenzieren können.
Lösung 1: Ohne Dereferenzierung
Hier erhalten wir den ganzzahligen Wert direkt ohne Dereferenzierung. Wir importieren die Header-Datei „iostream“, da einige Funktionsdefinitionen vorhanden sind. Dann geben wir den „namespace std“ zusammen mit dem Schlüsselwort „using“ ein und rufen dann hier die Methode „main()“ auf. Nun initialisieren wir die Variable „my_num“ vom Datentyp „int“ mit dem Wert „99“.
Anschließend initialisieren wir eine weitere Variable mit dem Namen „my_value“ und weisen ihr die Variable „my_num“ zu, die die Ganzzahl enthält. Danach erhalten wir diesen ganzzahligen Wert direkt ohne Dereferenzierung, indem wir „my_value“ in „cout“ einfügen. Dadurch wird der ganzzahlige Wert abgerufen und angezeigt.
Code 1:
#includeVerwenden des Namensraums std;
int main ( ) {
int my_num = 99 ;
int my_value = my_num;
cout << „Der Wert, den wir ohne Dereferenzierung des int erhalten, ist:“ << mein_wert << endl;
zurückkehren 0 ;
}
Ausgabe:
Hier wird der ganzzahlige Wert gerendert, den wir ohne Dereferenzierung in unserem C++-Code erhalten. Wir greifen direkt auf diesen ganzzahligen Wert zu und zeigen ihn an.
Lösung 2: Durch Dereferenzierung des Zeigers
Die Header-Datei „iostream“ enthält bestimmte Funktionsdefinitionen; wir haben sie importiert. Als nächstes führen wir hier die Funktion „main()“ aus, nachdem wir „namespace std“ und das Schlüsselwort „using“ eingegeben haben. Die Variable „my_num“ vom Datentyp „int“ wird nun mit dem Wert „99“ initialisiert.
Danach initialisieren wir einen „my_ptr“-Zeiger und weisen diesem Zeiger die Adresse der „my_num“-Variablen zu. Darunter dereferenzieren wir den Zeiger und weisen den Wert, den wir dadurch erhalten, der Variablen „my_value“ zu, während wir „my_value“ mit „*my_ptr“ initialisiert haben. Jetzt platzieren wir den „cout“, in dem wir die Variable „my_value“ übergeben, um den ganzzahligen Wert anzuzeigen, den wir durch die Dereferenzierung des Zeigers erhalten.
Code 2:
#includeVerwenden des Namensraums std;
int main ( ) {
int my_num = 99 ;
int * my_ptr = & meine_num;
int my_value = * my_ptr;
cout << „Der Wert von int, den wir durch die Dereferenzierung eines Zeigers erhalten, ist:“ << mein_wert << endl;
zurückkehren 0 ;
}
Ausgabe:
Hier wird nun der ganzzahlige Wert angezeigt, den wir nach der Dereferenzierung des Zeigers in unserem Code erhalten. Dies ist also die richtige Methode zum Anwenden der Dereferenzierung in C++.
Beispiel 2: Dereferenzierung von Int
Versuchen wir in diesem Code, das „int“ in C++ zu dereferenzieren. Um die in „iostream“ definierten Funktionen nutzen zu können, müssen wir lediglich die Header-Datei „iostream“ einbinden. Hier verwenden wir den „namespace std“ und rufen die Funktion „main()“ auf. Als nächstes erstellen wir die Variable „a“ und geben ihr den Datentyp „int“ zusammen mit dem Wert „75“.
Darunter erstellen wir einen Zeiger namens „newPointer“ und weisen diesem Zeiger mit Hilfe von „&“ die Adresse der Variablen „a“ zu. Dann initialisieren wir die Variable „num“ unten mit „*a“, was anzeigt, dass wir versuchen, die Variable „a“ zu dereferenzieren, die vom Datentyp „int“ ist. Da wir „int“ nicht dereferenzieren können, wird beim Kompilieren nun in dieser Zeile ein Fehler erzeugt. Danach verwenden wir auch den „cout“, in dem wir die Variable „num“ hinzufügen.
Code 2:
#includeVerwenden des Namensraums std;
int main ( ) {
int a = 75 ;
int * newPointer = & A;
int Zahl = * A;
cout << „Der Wert der Dereferenzierung des int ist:“ << Auf eins << endl;
zurückkehren 0 ;
}
Ausgabe:
Hier können wir sehen, dass kein Wert angezeigt wird und eine Fehlermeldung mit dem Hinweis „ungültiger Typparameter von unär“* erscheint. Dies weist darauf hin, dass „int“ in C++ nicht dereferenziert werden kann.
Lösung 1: Ohne Dereferenzierung
Wir müssen nicht dereferenzieren, um den ganzzahligen Wert sofort zu erhalten. Wir importieren es, da die Header-Datei „iostream“ bestimmte Funktionsdefinitionen enthält. Die Funktion „main()“ wird dann aufgerufen, nachdem die Schlüsselwörter „using“ und „namespace std“ eingegeben wurden. Die Variable „a“ vom Datentyp „int“ wird nun mit dem Wert „75“ initialisiert. Anschließend fügen wir das „a“ in „cout“ ein, um diesen ganzzahligen Wert sofort ohne Dereferenzierung zu erhalten. Dadurch wird der ganzzahlige Wert abgerufen und hier angezeigt.
Code 1:
#includeVerwenden des Namensraums std;
int main ( ) {
int a = 75 ;
cout << „Der Wert, den wir ohne Dereferenzierung erhalten, ist:“ << A << endl;
zurückkehren 0 ;
}
Ausgabe:
Hier wird der ganzzahlige Wert dargestellt, der aus unserem C++-Code ohne Dereferenzierung erhalten wird. Dieser ganzzahlige Wert ist sofort zugänglich und wird hier angezeigt.
Lösung 2:
Wir importieren die Header-Datei „iostream“, die einige Funktionsdefinitionen enthält. Hier geben wir das „namespace std“ und das Schlüsselwort „using“ ein, bevor wir die Funktion „main()“ ausführen. Der Variablen „a“ wird der Wert „75“ zugewiesen.
Als nächstes deklarieren wir einen Zeiger namens „mypointer“ und initialisieren ihn mit der Adresse der Variablen „a“. Darunter dereferenzieren wir den Zeiger und weisen den Wert, den wir daraus erhalten, der Variablen „result“ zu, während wir das „result“ mit „*mypointer“ initialisieren. Nach der Dereferenzierung des Zeigers platzieren wir den Befehl „cout“ und übergeben die Variable „result“, um den ganzzahligen Wert anzuzeigen.
Code 2:
#includeVerwenden des Namensraums std;
int main ( ) {
int a = 75 ;
int * mypointer = & A;
int Ergebnis = * mypointer;
cout << „Der Wert, den wir durch die Dereferenzierung des Zeigers erhalten, ist:“ << Ergebnis << endl;
zurückkehren 0 ;
}
Ausgabe:
Dies ist die richtige Technik, um die Dereferenzierung in C++ anzuwenden. Es gibt den ganzzahligen Wert wieder, den wir nach der Dereferenzierung des Zeigers erhalten haben, anstatt „int“ zu dereferenzieren.
Abschluss
Wir haben untersucht, dass, wenn wir versuchen, den Wert durch Dereferenzierung von „int“ in C++ zu erhalten, der Fehler „Ungültiger Typparameter von unärem „*“ mit int“ auftritt, was bedeutet, dass „int in C++ nicht dereferenziert werden kann“. Wir haben auch die Lösung für diesen Fehler erklärt. Wir haben in diesem Handbuch den Code verwendet, in dem die Fehler aufgetreten sind, und die Codes, in denen wir die Lösung für diesen Fehler bereitgestellt haben.