Què és un Void Pointer (void*)?
Un punter buit, també conegut com a punter genèric, és un punter que no està associat a cap tipus de dades específic, el que el fa adequat per apuntar a qualsevol tipus de dades. En altres paraules, a punter buit pot apuntar a un nombre enter, un caràcter, una cadena o qualsevol altre tipus de dades. Aquesta flexibilitat fa que els punters de buit siguin una eina poderosa en la programació en C i C++.
Declaració de Void Pointer en C i C++
En C i C++, el punter buit es declara mitjançant la sintaxi següent:
buit * ptr ;
Ús de Void Pointers en C i C++
Apunts buits en C s'utilitzen principalment quan el tipus de dades d'una variable no es coneix o pot variar en temps d'execució. Permeten una manera genèrica d'emmagatzemar i manipular dades sense necessitat de conèixer el seu tipus de dades específic. És útil sobretot quan es tracta de funcions o estructures de dades que poden gestionar diferents tipus de dades.
Un ús comú de punters buits es troba en funcions d'assignació de memòria com ara malloc() que retorna un punt de punter buit a un bloc de memòria que es pot utilitzar per emmagatzemar qualsevol tipus de dades. Aleshores, el programador pot llançar el punter buit al tipus de dades adequat per accedir i manipular les dades emmagatzemades al bloc de memòria assignat.
Un altre ús dels punters de buit a C és in punters de funció , que són variables que emmagatzemen l'adreça de memòria d'una funció. Els punters buits es poden utilitzar per emmagatzemar l'adreça de memòria de qualsevol funció, independentment del seu tipus de retorn o llista de paràmetres, la qual cosa permet una major flexibilitat en l'ús del punter de funció.
L'ús de punters buits en C++ és gairebé similar, però, també es poden utilitzar per crear una interfície genèrica per a objectes de diferents classes. Això s'aconsegueix sovint mitjançant l'ús de funcions virtuals, que permeten tractar de manera uniforme objectes de diferents classes. A més, C++ ofereix una comprovació de tipus més estricta que C, la qual cosa significa que s'utilitza punters buits incorrectament pot provocar més errors i errors.
Aspectes a tenir en compte en utilitzar punters buits en C i C++
Aquests són alguns punts que hauríeu de tenir en compte durant l'ús punters buits en C i C++.
1: En C, buit* es pot utilitzar com a valor de retorn i paràmetre de funció, però en C++ heu de tenir un punter de tipus de dades específic.
Per exemple:
En C, el codi es mostra a continuació:
#inclou#include
buit * afegir_números ( int a , int b ) {
int * resultat = malloc ( mida de ( int ) ) ;
* resultat = a + b ;
tornar ( buit * ) resultat ;
}
buit imprimir_resultat ( buit * resultat ) {
int * ptr = ( int * ) resultat ;
imprimirf ( 'El resultat és: %d \n ' , * ptr ) ;
lliure ( ptr ) ;
}
int principal ( ) {
int núm1 = 5 , num2 = 7 ;
buit * resultat = afegir_números ( núm1 , num2 ) ;
imprimir_resultat ( resultat ) ;
tornar 0 ;
}
El codi anterior defineix una funció afegir_números() que retorna a buit* punter al resultat d'afegir dos nombres enters passats com a arguments. La funció print_result() pren a punter buit* i imprimeix el resultat. A la funció main(), cridem afegir_números() i passa el resultat punter buit* a print_result() per a la impressió.
En C++, cal un tipus de dades específic.
#inclouutilitzant l'espai de noms std ;
buit printInt ( int * en una ) {
cout << 'L'enter és:' << * en una << endl ;
}
int principal ( ) {
int x = 10 ;
int * ptr = & x ;
printInt ( ptr ) ;
tornar 0 ;
}
2: A C, podeu convertir el punter buit a un altre tipus de punter mitjançant conversió implícita. Però en C++ heu d'utilitzar conversió explícita per convertir el punter buit a qualsevol altre tipus de punter.
Aquí teniu un exemple de codi senzill tant per a C com per a C++ per il·lustrar la diferència entre implícit i conversió explícita de punters buits a altres tipus de punters:
En C, s'utilitza el codi següent:
#incloubuit printChar ( buit * cap ) {
char c = * ( char * ) cap ;
imprimirf ( '%c \n ' , c ) ;
}
int principal ( ) {
char c = 'a' ;
buit * ptr = & c ;
printChar ( ptr ) ;
tornar 0 ;
}
El codi anterior defineix una funció printChar que pren un punter buit com a paràmetre i imprimeix el caràcter emmagatzemat en aquesta ubicació de memòria. A la funció principal, una variable char c està definit i la seva adreça s'emmagatzema en un punter buit ptr. El printChar aleshores s'anomena la funció amb punter buit 'ptr' com a argument. El punter de buit es converteix explícitament en un punter de caràcters al 'printChar' funció per accedir i imprimir el valor emmagatzemat 'c' .
En C++, el codi es mostra a continuació:
#incloubuit printInt ( buit * en una ) {
int * ptr = static_cast < int *> ( en una ) ;
std :: cout << * ptr << std :: endl ;
}
int principal ( ) {
int x = 10 ;
buit * ptr = & x ;
printInt ( ptr ) ;
tornar 0 ;
}
El codi anterior defineix una funció printInt que pren un punter nul num com a paràmetre i el converteix en un punter sencer mitjançant el operador static_cast . A continuació, la funció imprimeix el valor de l'enter al qual apunta el punter llançat. A la funció principal, es defineix una variable entera x i la seva adreça s'emmagatzema en a punter buit ptr, que després es passa a la printInt funció. La sortida del programa és el valor de x, que és 10.
Pensaments finals
El buit Els punters en C i C++ proporcionen una manera potent de manipular dades sense necessitat de conèixer el seu tipus de dades específic. Són útils per a l'assignació de memòria i els punters de funció, així com per crear una interfície genèrica per a objectes de diferents classes en C++. Tanmateix, és important tenir en compte les diferències entre C i C++ en el seu ús punters buits , com ara la necessitat de tipus de dades específics en C++ i la necessitat d'una conversió explícita quan es transmeten punters buits a altres tipus de punters. Una consideració acurada d'aquests punts pot conduir a un ús més eficient i eficaç punters buits en programació.