Hvad er en Void Pointer (void*)?
En void pointer, også kendt som en generisk pointer, er en pointer, der ikke er forbundet med nogen specifik datatype, hvilket gør den velegnet til at pege på enhver type data. Med andre ord, a tom markør kan pege på et heltal, et tegn, en streng eller enhver anden datatype. Denne fleksibilitet gør void pointers til et effektivt værktøj i C- og C++-programmering.
Declaration of Void Pointer i C og C++
I C og C++ er tom markør er erklæret gennem følgende syntaks:
ugyldig * ptr ;
Brug af Void Pointers i C og C++
Ugyldige pointer i C bruges mest, når datatypen for en variabel ikke er kendt eller kan variere under kørsel. De giver mulighed for en generisk måde at lagre og manipulere data på uden at skulle kende dens specifikke datatype. Det er nyttigt, især når man har at gøre med funktioner eller datastrukturer, der kan håndtere forskellige typer data.
En almindelig brug af ugyldige pointer er i hukommelsestildelingsfunktioner som f.eks malloc() som returnerer et void pointer-punkt til en hukommelsesblok, der kan bruges til at gemme enhver datatype. Programmeringsenheden kan derefter kaste tomrumsmarkøren til den passende datatype for at få adgang til og manipulere dataene, der er lagret i den tildelte hukommelsesblok.
En anden brug af void pointers i C er in funktionsvisere , som er variabler, der gemmer hukommelsesadressen for en funktion. Void pointers kan bruges til at gemme hukommelsesadressen for enhver funktion, uanset dens returtype eller parameterliste, hvilket giver mulighed for mere fleksibilitet i brug af funktionsmarkør.
Brugen af ugyldige pointer i C++ er næsten ens, men de kan også bruges til at skabe en generisk grænseflade til objekter af forskellige klasser. Dette opnås ofte ved at bruge virtuelle funktioner, som gør det muligt at behandle objekter af forskellige klasser ensartet. Ydermere tilbyder C++ mere streng typekontrol end C, hvilket betyder, at brug ugyldige pointer forkert kan resultere i flere fejl og fejl.
Punkter at overveje, mens du bruger void pointers i C og C++
Her er et par punkter, som du bør overveje, mens du bruger ugyldige pointer i C og C++.
1: I C, ugyldig* kan bruges som en returværdi og funktionsparameter, men i C++ skal du have en bestemt datatype pointer.
For eksempel:
I C er koden givet nedenfor:
#include#include
ugyldig * tilføje_numre ( int -en , int b ) {
int * resultat = malloc ( størrelse på ( int ) ) ;
* resultat = -en + b ;
Vend tilbage ( ugyldig * ) resultat ;
}
ugyldig print_result ( ugyldig * resultat ) {
int * ptr = ( int * ) resultat ;
printf ( 'Resultatet er: %d \n ' , * ptr ) ;
gratis ( ptr ) ;
}
int vigtigste ( ) {
int nummer1 = 5 , nummer 2 = 7 ;
ugyldig * resultat = tilføje_numre ( nummer1 , nummer 2 ) ;
print_result ( resultat ) ;
Vend tilbage 0 ;
}
Ovenstående kode definerer en funktion tilføje_numre() der returnerer en ugyldig* pointer til resultatet af at tilføje to heltal, der er sendt som argumenter. Funktionen print_result() tager en tom* pointer og udskriver resultatet. I main()-funktionen kalder vi tilføje_numre() og bestå det resulterende tom* pointer til print_result() til udskrivning.
I C++ kræves en bestemt datatype.
#includebruger navneområde std ;
ugyldig printInt ( int * på en ) {
cout << 'Heltallet er: ' << * på en << endl ;
}
int vigtigste ( ) {
int x = 10 ;
int * ptr = & x ;
printInt ( ptr ) ;
Vend tilbage 0 ;
}
2: I C kan du konvertere void-markøren til en anden pointertype igennem implicit konvertering. Men i C++ skal du bruge eksplicit konvertering at konvertere tom markør til enhver anden pointertype.
Her er et simpelt kodeeksempel for både C og C++ for at illustrere forskellen mellem implicit og eksplicit konvertering af ugyldige pointer til andre pointertyper:
I C bruges følgende kode:
#includeugyldig printChar ( ugyldig * ch ) {
char c = * ( char * ) ch ;
printf ( '%c \n ' , c ) ;
}
int vigtigste ( ) {
char c = 'en' ;
ugyldig * ptr = & c ;
printChar ( ptr ) ;
Vend tilbage 0 ;
}
Ovenstående kode definerer en funktion printChar der tager en void-markør som en parameter og udskriver tegnet, der er gemt på denne hukommelsesplacering. I hovedfunktionen er en char-variabel c er defineret, og dens adresse er gemt i en void pointer ptr. Det printChar funktionen kaldes så med void pointer 'ptr' som et argument. Tommarkøren konverteres eksplicit til en tegnmarkør i 'printChar' funktion for at få adgang til og udskrive værdien gemt i 'c' .
I C++ er koden givet nedenfor:
#includeugyldig printInt ( ugyldig * på en ) {
int * ptr = static_cast < int *> ( på en ) ;
std :: cout << * ptr << std :: endl ;
}
int vigtigste ( ) {
int x = 10 ;
ugyldig * ptr = & x ;
printInt ( ptr ) ;
Vend tilbage 0 ;
}
Ovenstående kode definerer en funktion printInt der tager et void pointer num som en parameter og kaster det til en heltals pointer ved hjælp af static_cast operator . Funktionen udskriver derefter værdien af det heltal, som den kastede markør peger på. I hovedfunktionen er en heltalsvariabel x defineret, og dens adresse er gemt i a void pointer ptr, som derefter videregives til printInt fungere. Udgangen af programmet er værdien af x, som er 10.
Afsluttende tanker
Det ugyldig pointere i C og C++ giver en effektiv måde at manipulere data på uden at skulle kende deres specifikke datatype. De er nyttige til hukommelsesallokering og funktionsmarkører, samt til at skabe en generisk grænseflade til objekter af forskellige klasser i C++. Det er dog vigtigt at overveje forskellene mellem C og C++ i deres brug af ugyldige pointer , såsom behovet for specifikke datatyper i C++ og behovet for eksplicit konvertering ved casting af void-pointere til andre pointertyper. Omhyggelig overvejelse af disse punkter kan føre til mere effektiv og effektiv brug af ugyldige pointer i programmering.