Vad är en Void Pointer (void*)?
En void-pekare, även känd som en generisk pekare, är en pekare som inte är associerad med någon specifik datatyp, vilket gör den lämplig för att peka på alla typer av data. Med andra ord, a tom pekare kan peka på ett heltal, ett tecken, en sträng eller någon annan datatyp. Denna flexibilitet gör void-pekare till ett kraftfullt verktyg i C- och C++-programmering.
Declaration of Void Pointer i C och C++
I C och C++ är tom pekare deklareras genom följande syntax:
tomhet * ptr ;
Användning av Void Pointers i C och C++
Tom pekare i C används mest när datatypen för en variabel inte är känd eller kan variera under körning. De möjliggör ett generiskt sätt att lagra och manipulera data utan att behöva känna till dess specifika datatyp. Det är användbart särskilt när det handlar om funktioner eller datastrukturer som kan hantera olika typer av data.
En vanlig användning av tomma pekare finns i minnesallokeringsfunktioner som t.ex malloc() som returnerar en void-pekare till ett minnesblock som kan användas för att lagra vilken datatyp som helst. Programmeraren kan sedan kasta tomrumspekaren till lämplig datatyp för att komma åt och manipulera data lagrad i det tilldelade minnesblocket.
En annan användning av void-pekare i C är in funktionspekare , som är variabler som lagrar minnesadressen för en funktion. Void-pekare kan användas för att lagra minnesadressen för vilken funktion som helst, oavsett dess returtyp eller parameterlista, vilket möjliggör mer flexibilitet vid användning av funktionspekare.
Användningen av tomma pekare i C++ är nästan likadana, men de kan också användas för att skapa ett generiskt gränssnitt för objekt av olika klasser. Detta uppnås ofta genom användning av virtuella funktioner, som gör att objekt av olika klasser kan behandlas enhetligt. Vidare erbjuder C++ mer strikt typkontroll än C, vilket innebär att man använder tomma pekare felaktigt kan resultera i fler fel och buggar.
Punkter att tänka på när du använder Void Pointers i C och C++
Här är några punkter som du bör tänka på när du använder tomma pekare i C och C++.
1: I C, tomhet* kan användas som ett returvärde och funktionsparameter men i C++ måste du ha en specifik datatyp av pekare.
Till exempel:
I C ges koden nedan:
#include#include
tomhet * add_numbers ( int a , int b ) {
int * resultat = malloc ( storlek av ( int ) ) ;
* resultat = a + b ;
lämna tillbaka ( tomhet * ) resultat ;
}
tomhet print_result ( tomhet * resultat ) {
int * ptr = ( int * ) resultat ;
printf ( 'Resultatet är: %d \n ' , * ptr ) ;
fri ( ptr ) ;
}
int huvud ( ) {
int nummer1 = 5 , nummer2 = 7 ;
tomhet * resultat = add_numbers ( nummer1 , nummer2 ) ;
print_result ( resultat ) ;
lämna tillbaka 0 ;
}
Ovanstående kod definierar en funktion add_numbers() som returnerar en tomhet* pekare till resultatet av att lägga till två heltal som skickas som argument. Funktionen print_result() tar en tom* pekare och skriver ut resultatet. I main()-funktionen anropar vi add_numbers() och passera resultatet tom* pekare till print_result() för utskrift.
I C++ krävs en specifik datatyp.
#includeanvänder namnutrymme std ;
tomhet printInt ( int * på ett ) {
cout << 'Heltalet är:' << * på ett << endl ;
}
int huvud ( ) {
int x = 10 ;
int * ptr = & x ;
printInt ( ptr ) ;
lämna tillbaka 0 ;
}
2: I C kan du konvertera void-pekaren till en annan pekartyp implicit konvertering. Men i C++ måste du använda explicit konvertering att konvertera tom pekare till någon annan typ av pekare.
Här är ett enkelt kodexempel för både C och C++ för att illustrera skillnaden mellan implicit och explicit konvertering av tomma pekare till andra pekartyper:
I C används följande kod:
#includetomhet printChar ( tomhet * kap ) {
röding c = * ( röding * ) kap ;
printf ( '%c \n ' , c ) ;
}
int huvud ( ) {
röding c = 'a' ;
tomhet * ptr = & c ;
printChar ( ptr ) ;
lämna tillbaka 0 ;
}
Ovanstående kod definierar en funktion printChar som tar en void-pekare som en parameter och skriver ut tecknet som är lagrat på den minnesplatsen. I huvudfunktionen en char-variabel c är definierad och dess adress lagras i en void-pekare ptr. De printChar funktionen anropas sedan med void-pekare 'ptr' som ett argument. Void-pekaren omvandlas uttryckligen till en teckenpekare i 'printChar' funktion för att komma åt och skriva ut värdet lagrat i 'c' .
I C++ ges koden nedan:
#includetomhet printInt ( tomhet * på ett ) {
int * ptr = static_cast < int *> ( på ett ) ;
std :: cout << * ptr << std :: endl ;
}
int huvud ( ) {
int x = 10 ;
tomhet * ptr = & x ;
printInt ( ptr ) ;
lämna tillbaka 0 ;
}
Ovanstående kod definierar en funktion printInt som tar ett void pointer num som en parameter och castar det till en heltalspekare med hjälp av static_cast-operator . Funktionen skriver sedan ut värdet på det heltal som den kastade pekaren pekar på. I huvudfunktionen definieras en heltalsvariabel x och dess adress lagras i a void pointer ptr, som sedan skickas till printInt fungera. Utdata från programmet är värdet på x, vilket är 10.
Slutgiltiga tankar
De tomhet pekare i C och C++ ger ett kraftfullt sätt att manipulera data utan att behöva känna till dess specifika datatyp. De är användbara för minnesallokering och funktionspekare, såväl som för att skapa ett generiskt gränssnitt för objekt av olika klasser i C++. Det är dock viktigt att överväga skillnaderna mellan C och C++ i deras användning av tomma pekare , såsom behovet av specifika datatyper i C++ och behovet av explicit konvertering när tomrumspekare sänds till andra pekartyper. Noggrant övervägande av dessa punkter kan leda till en mer effektiv och effektiv användning av tomma pekare i programmering.