Wat is een Void Pointer (void*)?
Een lege aanwijzer, ook wel generieke aanwijzer genoemd, is een aanwijzer die niet is gekoppeld aan een specifiek gegevenstype, waardoor deze geschikt is om naar elk type gegevens te verwijzen. Met andere woorden, een lege aanwijzer kan verwijzen naar een geheel getal, een teken, een tekenreeks of een ander gegevenstype. Deze flexibiliteit maakt ongeldige aanwijzers tot een krachtig hulpmiddel bij het programmeren in C en C++.
Verklaring van Void Pointer in C en C ++
In C en C++ is de lege aanwijzer wordt gedeclareerd via de volgende syntaxis:
leegte * ptr ;
Gebruik van Void Pointers in C en C++
Ongeldige aanwijzingen in C worden meestal gebruikt wanneer het gegevenstype van een variabele niet bekend is of tijdens runtime kan variëren. Ze maken een generieke manier mogelijk om gegevens op te slaan en te manipuleren zonder het specifieke gegevenstype te hoeven kennen. Het is vooral handig bij het omgaan met functies of gegevensstructuren die verschillende soorten gegevens kunnen verwerken.
Een gemeenschappelijk gebruik van lege wijzers zit in geheugentoewijzingsfuncties zoals malloc() die een leeg aanwijzerpunt retourneert naar een geheugenblok dat kan worden gebruikt om elk gegevenstype op te slaan. De programmeur kan vervolgens de lege aanwijzer naar het juiste gegevenstype casten om toegang te krijgen tot de gegevens die zijn opgeslagen in het toegewezen geheugenblok en deze te manipuleren.
Een ander gebruik van lege aanwijzers in C is in functie wijzers , dit zijn variabelen die het geheugenadres van een functie opslaan. Ongeldige pointers kunnen worden gebruikt om het geheugenadres van elke functie op te slaan, ongeacht het retourtype of de parameterlijst, waardoor er meer flexibiliteit is in het gebruik van de functie-pointer.
Het gebruik van lege wijzers in C ++ is bijna hetzelfde, maar ze kunnen ook worden gebruikt om een generieke interface te maken voor objecten van verschillende klassen. Dit wordt vaak bereikt door het gebruik van virtuele functies, waarmee objecten van verschillende klassen uniform kunnen worden behandeld. Verder biedt C ++ een strengere typecontrole dan C, wat betekent dat het gebruik van lege wijzers onjuist kan resulteren in meer fouten en bugs.
Aandachtspunten bij het gebruik van ongeldige aanwijzers in C en C ++
Hier zijn een paar punten waarmee u rekening moet houden tijdens het gebruik lege wijzers bij C en C++.
1: in C, leegte* kan worden gebruikt als een retourwaarde en functieparameter, maar in C ++ moet u een specifiek gegevenstype aanwijzer hebben.
Bijvoorbeeld:
In C wordt de code hieronder gegeven:
#include#include
leegte * voeg_nummers toe ( int A , int B ) {
int * resultaat = malloc ( De grootte van ( int ) ) ;
* resultaat = A + B ;
opbrengst ( leegte * ) resultaat ;
}
leegte print_resultaat ( leegte * resultaat ) {
int * ptr = ( int * ) resultaat ;
printf ( 'Het resultaat is: %d \N ' , * ptr ) ;
vrij ( ptr ) ;
}
int voornaamst ( ) {
int nummer1 = 5 , nummer2 = 7 ;
leegte * resultaat = voeg_nummers toe ( nummer1 , nummer2 ) ;
print_resultaat ( resultaat ) ;
opbrengst 0 ;
}
De bovenstaande code definieert een functie add_numbers() dat geeft een terug leegte* pointer naar het resultaat van het optellen van twee gehele getallen die als argumenten zijn doorgegeven. De functie afdrukresultaat() neemt een lege* aanwijzer en drukt het resultaat af. In de functie main() noemen we add_numbers() en geef het resultaat door lege* aanwijzer naar afdrukresultaat() om te printen.
In C++ is een specifiek gegevenstype vereist.
#includenamespace std; gebruiken ;
leegte printInt ( int * op een ) {
cout << 'Het gehele getal is: ' << * op een << eindel ;
}
int voornaamst ( ) {
int X = 10 ;
int * ptr = & X ;
printInt ( ptr ) ;
opbrengst 0 ;
}
2: In C kun je de lege aanwijzer via een ander type aanwijzer converteren impliciete conversie. Maar in C++ moet je de expliciete conversie om te zetten lege aanwijzer naar elk ander aanwijzertype.
Hier is een eenvoudig codevoorbeeld voor zowel C als C++ om het verschil tussen de impliciet En expliciete conversie van lege wijzers naar andere soorten aanwijzers:
In C wordt de volgende code gebruikt:
#includeleegte printChar ( leegte * ch ) {
char C = * ( char * ) ch ;
printf ( '%C \N ' , C ) ;
}
int voornaamst ( ) {
char C = 'A' ;
leegte * ptr = & C ;
printChar ( ptr ) ;
opbrengst 0 ;
}
De bovenstaande code definieert een functie printChar dat een lege aanwijzer als parameter neemt en het teken afdrukt dat op die geheugenlocatie is opgeslagen. In de hoofdfunctie een char-variabele C is gedefinieerd en het adres wordt opgeslagen in een lege aanwijzer ptr. De printChar functie wordt dan aangeroepen met de ongeldige aanwijzer 'ptr' als argument. De leegte-pointer wordt expliciet geconverteerd naar een char-pointer in het 'printChar' functie om toegang te krijgen tot de opgeslagen waarde en deze af te drukken 'C' .
In C ++ wordt de code hieronder gegeven:
#includeleegte printInt ( leegte * op een ) {
int * ptr = statische_cast < int *> ( op een ) ;
soa :: cout << * ptr << soa :: eindel ;
}
int voornaamst ( ) {
int X = 10 ;
leegte * ptr = & X ;
printInt ( ptr ) ;
opbrengst 0 ;
}
De bovenstaande code definieert een functie printInt dat neemt een lege pointer num als parameter en cast het naar een integer pointer met behulp van de static_cast-operator . De functie drukt vervolgens de waarde af van het gehele getal waarnaar wordt verwezen door de casted pointer. In de hoofdfunctie wordt een integer-variabele x gedefinieerd en het adres ervan wordt opgeslagen in a leegte aanwijzer ptr, die vervolgens wordt doorgegeven aan de printInt functie. De uitvoer van het programma is de waarde van x, wat gelijk is aan 10.
Laatste gedachten
De leegte pointers in C en C ++ bieden een krachtige manier om gegevens te manipuleren zonder het specifieke gegevenstype te hoeven kennen. Ze zijn handig voor geheugentoewijzing en functieaanwijzers, maar ook voor het maken van een generieke interface voor objecten van verschillende klassen in C ++. Het is echter belangrijk om rekening te houden met de verschillen tussen C en C++ bij het gebruik ervan lege wijzers , zoals de behoefte aan specifieke datatypes in C++ en de behoefte aan expliciete conversie bij het casten van lege pointers naar andere pointertypes. Een zorgvuldige afweging van deze punten kan leiden tot een efficiënter en effectiever gebruik van lege wijzers bij het programmeren.