Programmeertalen hebben bibliotheken, functies, syntaxis en andere dingen nodig als ze ermee werken. Er is dus een kans dat onze codes fouten bevatten. Programmeren in C++ kent veel verschillende soorten fouten. We zullen hier de fout ‘int kan niet worden verwijderd in C++’ bespreken. Deze fout treedt op wanneer we de dereferentie-operator “*” proberen te gebruiken met de gegevens van het gehele getal “int” omdat “int” een primitief gegevenstype is. We kunnen de 'int' in C++-programmering niet derefereren. Hier zal de fout ‘int kan niet worden verwijderd in C++’ en de oplossing ervan zal grondig worden onderzocht. In deze handleiding worden enkele codes gegeven waarin we zullen zien hoe deze fout optreedt en hoe dit type fout in C++ moet worden afgehandeld.
Voorbeeld 1: Dereferentie Int
In deze code zullen we proberen de “int” in C++ te derefereren. Nu voegen we eenvoudigweg het “iostream” headerbestand toe om de gedefinieerde functies te gebruiken. Hieronder gebruiken we de “namespace std” en roepen hier de “main()” -methode aan. Vervolgens declareren we de variabele “my_num” met het gegevenstype “int” en wijzen we “99” toe aan deze variabele.
Nu declareren we “my_value” van het datatype “int” en initialiseren we het met “*my_num”, wat betekent dat we proberen de referentie “my_num” van het datatype “int” te derefereren. De fout wordt op deze regel gegenereerd tijdens het compileren, omdat we de 'int' niet kunnen derefereren. We willen de waarde weergeven die we krijgen na het verwijderen van de verwijzingen naar int, dus plaatsen we de 'cout' waarin we de variabele 'my_value' hebben toegevoegd.
Code1:
#include
namespace std; gebruiken;
int. hoofd ( ) {
int mijn_num = 99 ;
int mijn_waarde = * mijn_nummer;
uit << 'De waarde die we krijgen door het derefereren van de int is: ' << mijn_waarde << eind;
opbrengst 0 ;
}
Uitgang:
Hier kunnen we merken dat er geen waarde wordt weergegeven en dat er een fout optreedt die zegt dat er een ongeldig type argument is van unaire “*”. Dit betekent dat we de “int” in C++ niet kunnen derefereren.
Oplossing 1: zonder verwijzingen
Hier krijgen we de gehele waarde direct zonder dereferentie. We importeren het headerbestand “iostream” omdat er enkele functiedefinities aanwezig zijn. Vervolgens typen we de “namespace std” samen met het trefwoord “using” en roepen vervolgens hier de methode “main()” aan. Nu initialiseren we de variabele “my_num” van het gegevenstype “int” met de waarde “99”.
Vervolgens initialiseren we een andere variabele met de naam “my_value” en wijzen deze toe met de variabele “my_num” die het gehele getal bevat. Hierna krijgen we deze gehele waarde rechtstreeks zonder de verwijzingen te verwijderen door “my_value” in de “cout” te plaatsen. Hiermee wordt de gehele waarde opgehaald en weergegeven.
Code1:
#includenamespace std; gebruiken;
int. hoofd ( ) {
int mijn_num = 99 ;
int mijn_waarde = mijn_num;
uit << 'De waarde die we krijgen zonder de int te derefereren is: ' << mijn_waarde << eind;
opbrengst 0 ;
}
Uitgang:
De gehele waarde wordt hier weergegeven, die we krijgen zonder de verwijzingen in onze C++-code te verwijderen. We hebben rechtstreeks toegang tot deze gehele waarde en geven deze weer.
Oplossing 2: door de aanwijzer te derefereren
Het headerbestand “iostream” bevat bepaalde functiedefinities; wij hebben ze geïmporteerd. Vervolgens voeren we hier de functie “main()” uit nadat we “namespace std” en het trefwoord “using” hebben getypt. De variabele “my_num” van het gegevenstype “int” is nu geïnitialiseerd met de waarde “99”.
Hierna initialiseren we een “my_ptr”-pointer en wijzen we het adres van de “my_num”-variabele toe aan deze pointer. Hieronder derefereren we de aanwijzer en wijzen we de waarde die we hierdoor krijgen toe aan de variabele 'my_value', terwijl we de 'my_value' initialiseerden met de '*my_ptr'. Nu plaatsen we de 'cout' waarin we de variabele 'my_value' doorgeven om de gehele waarde weer te geven die we krijgen door de verwijzing naar de aanwijzer te derefereren.
Code2:
#includenamespace std; gebruiken;
int. hoofd ( ) {
int mijn_num = 99 ;
int * mijn_ptr = & mijn_nummer;
int mijn_waarde = * mijn_ptr;
uit << 'De waarde van int die we krijgen bij het derefereren van een pointer is: ' << mijn_waarde << eind;
opbrengst 0 ;
}
Uitgang:
De gehele waarde die we krijgen nadat we de verwijzing naar de aanwijzer in onze code hebben verwijderd, wordt nu hier weergegeven. Dit is dus de juiste manier om dereferentie toe te passen in C++.
Voorbeeld 2: Dereferentie Int
Laten we proberen de “int” in C++ in deze code te derefereren. Om de functies te gebruiken die zijn gedefinieerd in “iostream”, hoeven we alleen maar het “iostream” headerbestand op te nemen. Dit is waar we de “namespace std” gebruiken en de functie “main()” aanroepen. Vervolgens maken we de variabele “a” en geven deze het gegevenstype “int” samen met de waarde “75”.
Daaronder creëren we een pointer met de naam “newPointer” en wijzen met behulp van “&” het adres van de variabele “a” aan deze pointer toe. Vervolgens initialiseren we de “num”-variabele hieronder met “*a”, wat aangeeft dat we proberen de referentie “a”-variabele, die van het gegevenstype “int” is, te derefereren. Omdat we de “int” niet kunnen derefereren, wordt er nu tijdens het compileren een fout op deze regel geproduceerd. Hierna gebruiken we ook de “cout” waarin we de variabele “num” toevoegen.
Code2:
#includenamespace std; gebruiken;
int. hoofd ( ) {
int a = 75 ;
int * nieuwePointer = & A;
int-nummer = * A;
uit << 'De waarde voor het derefereren van de int is: ' << op een << eind;
opbrengst 0 ;
}
Uitgang:
Hier kunnen we zien dat er geen waarde wordt weergegeven en dat er een foutmelding verschijnt met de mededeling dat er een “ongeldige typeparameter van unary”*” is. Dit geeft aan dat de “int” niet kan worden verwijderd in C++.
Oplossing 1: zonder verwijzingen
We hoeven geen dereferentie uit te voeren om de gehele waarde onmiddellijk te verkrijgen. We importeren het omdat het headerbestand “iostream” bepaalde functiedefinities bevat. De functie “main()” wordt vervolgens aangeroepen nadat de trefwoorden “using” en “namespace std” zijn ingevoerd. De variabele “a” van het gegevenstype “int” wordt nu geïnitialiseerd met de waarde “75”. Daarna voegen we de “a” in de “cout” in om deze gehele waarde onmiddellijk te verkrijgen zonder dereferentie. Hiermee wordt de gehele waarde opgehaald en hier weergegeven.
Code1:
#includenamespace std; gebruiken;
int. hoofd ( ) {
int a = 75 ;
uit << 'De waarde die we krijgen zonder de verwijzingen te verwijderen is: ' << A << eind;
opbrengst 0 ;
}
Uitgang:
De gehele waarde die wordt verkregen uit onze C++-code zonder dereferentie wordt hier weergegeven. Deze gehele waarde is onmiddellijk toegankelijk en wordt hier weergegeven.
Oplossing 2:
We importeren het headerbestand “iostream” met enkele functiedefinities. Hier typen we het trefwoord “namespace std” en het trefwoord “using” voordat we de functie “main()” uitvoeren. De waarde “75” wordt toegewezen aan de variabele “a”.
Vervolgens declareren we een pointer genaamd 'mypointer' en initialiseren deze met het adres van de 'a' -variabele ernaar. Hieronder derefereren we de aanwijzer en wijzen we de waarde die we hiervan krijgen toe aan de variabele 'resultaat', terwijl we het 'resultaat' initialiseren met '*mypointer'. Nadat we de verwijzing naar de aanwijzer hebben verwijderd, plaatsen we de opdracht 'cout' en geven we de variabele 'result' door om de gehele waarde weer te geven.
Code2:
#includenamespace std; gebruiken;
int. hoofd ( ) {
int a = 75 ;
int * mijnwijzer = & A;
int-resultaat = * mijnwijzer;
uit << 'De waarde die we krijgen door het verwijderen van de verwijzingen naar de aanwijzer is: ' << resultaat << eind;
opbrengst 0 ;
}
Uitgang:
Dit is de juiste techniek om dereferentie toe te passen in C++. Het geeft de gehele waarde weer die we hebben verkregen na het derefereren van de aanwijzer in plaats van het derefereren van de 'int'.
Conclusie
We hebben onderzocht dat wanneer we proberen de waarde te verkrijgen door de verwijzing naar de “int” in C++ te derefereren, de fout “ongeldige typeparameter van unaire “*” met int” zal optreden, wat betekent dat “int niet kan worden gederefereerd in C++”. We hebben ook de oplossing voor deze fout uitgelegd. We hebben in deze handleiding de code gebruikt waarin de fouten zijn opgetreden en de codes waarin we de oplossing van die fout hebben gegeven.