Ano ang Void Pointer (void*)?
Ang void pointer, na kilala rin bilang generic pointer, ay isang pointer na hindi nauugnay sa anumang partikular na uri ng data, na ginagawa itong angkop para sa pagturo sa anumang uri ng data. Sa madaling salita, a walang bisa na pointer maaaring tumuro sa isang integer, isang character, isang string, o anumang iba pang uri ng data. Ang flexibility na ito ay gumagawa ng mga void pointer na isang makapangyarihang tool sa C at C++ programming.
Deklarasyon ng Void Pointer sa C at C++
Sa C at C++, ang walang bisa na pointer ay ipinahayag sa pamamagitan ng sumusunod na syntax:
walang bisa * ptr ;
Paggamit ng mga Void Pointer sa C at C++
Walang bisa na mga payo sa C ay kadalasang ginagamit kapag ang uri ng data ng isang variable ay hindi kilala o maaaring mag-iba sa runtime. Nagbibigay-daan ang mga ito para sa isang generic na paraan upang mag-imbak at magmanipula ng data nang hindi kailangang malaman ang partikular na uri ng data nito. Nakatutulong ito lalo na kapag nakikitungo sa mga function o istruktura ng data na maaaring humawak ng iba't ibang uri ng data.
Isang karaniwang paggamit ng walang bisa na mga payo ay nasa memory allocation function tulad ng malloc() na nagbabalik ng void pointer point sa isang bloke ng memorya na maaaring magamit upang mag-imbak ng anumang uri ng data. Ang programmer ay maaaring i-cast ang void pointer sa naaangkop na uri ng data upang ma-access at manipulahin ang data na nakaimbak sa inilalaan na bloke ng memorya.
Ang isa pang paggamit ng mga void pointer sa C ay nasa function pointer , na mga variable na nag-iimbak ng memory address ng isang function. Maaaring gamitin ang mga void pointer upang iimbak ang memory address ng anumang function, anuman ang uri ng pagbabalik nito o listahan ng parameter, na nagbibigay-daan para sa higit na kakayahang umangkop sa paggamit ng function pointer.
Ang gamit ng walang bisa na mga payo sa C++ ay halos magkapareho, gayunpaman, maaari din silang magamit upang lumikha ng isang generic na interface para sa mga bagay ng iba't ibang klase. Madalas itong nakakamit sa pamamagitan ng paggamit ng mga virtual na function, na nagpapahintulot sa mga bagay ng iba't ibang klase na tratuhin nang pantay. Dagdag pa, nag-aalok ang C++ ng mas mahigpit na pagsusuri ng uri kaysa sa C, na nangangahulugang ang paggamit walang bisa na mga payo ang hindi tama ay maaaring magresulta sa mas maraming error at bug.
Mga Punto na Dapat Isaalang-alang habang Gumagamit ng mga Void Pointer sa C at C++
Narito ang ilang mga punto na dapat mong isaalang-alang habang ginagamit walang bisa na mga payo sa C at C++.
1: Sa C, walang bisa* ay maaaring gamitin bilang isang return value at function na parameter ngunit sa C++ dapat mayroon kang partikular na uri ng data ng pointer.
Halimbawa:
Sa C, ang code ay ibinigay sa ibaba:
#include#include
walang bisa * add_numbers ( int a , int b ) {
int * resulta = malloc ( sukat ng ( int ) ) ;
* resulta = a + b ;
bumalik ( walang bisa * ) resulta ;
}
walang bisa print_result ( walang bisa * resulta ) {
int * ptr = ( int * ) resulta ;
printf ( 'Ang resulta ay: %d \n ' , * ptr ) ;
libre ( ptr ) ;
}
int pangunahing ( ) {
int num1 = 5 , num2 = 7 ;
walang bisa * resulta = add_numbers ( num1 , num2 ) ;
print_result ( resulta ) ;
bumalik 0 ;
}
Ang code sa itaas ay tumutukoy sa isang function add_numbers() na nagbabalik a walang bisa* pointer sa resulta ng pagdaragdag ng dalawang integer na ipinasa bilang mga argumento. Ang function print_result() tumatagal ng a walang laman* pointer at ini-print ang resulta. Sa main() function, tinatawagan namin add_numbers() at ipasa ang resulta walang laman* pointer sa print_result() para sa paglilimbag.
Sa C++, kinakailangan ang isang partikular na uri ng data.
#includegamit ang namespace std ;
walang bisa printInt ( int * sa isa ) {
cout << 'Ang integer ay: ' << * sa isa << endl ;
}
int pangunahing ( ) {
int x = 10 ;
int * ptr = at x ;
printInt ( ptr ) ;
bumalik 0 ;
}
2: Sa C, maaari mong i-convert ang void pointer sa isa pang uri ng pointer sa pamamagitan ng implicit conversion. Ngunit sa C++ kailangan mong gamitin ang tahasang conversion upang i-convert ang walang bisa na pointer sa anumang iba pang uri ng pointer.
Narito ang isang simpleng halimbawa ng code para sa parehong C at C++ upang ilarawan ang pagkakaiba sa pagitan ng implicit at tahasang conversion ng walang bisa na mga payo sa iba pang mga uri ng pointer:
Sa C, ang sumusunod na code ay ginagamit:
#includewalang bisa printChar ( walang bisa * ch ) {
char c = * ( char * ) ch ;
printf ( '%c \n ' , c ) ;
}
int pangunahing ( ) {
char c = 'a' ;
walang bisa * ptr = at c ;
printChar ( ptr ) ;
bumalik 0 ;
}
Ang code sa itaas ay tumutukoy sa isang function printChar na kumukuha ng void pointer bilang parameter at nagpi-print ng character na nakaimbak sa lokasyon ng memorya na iyon. Sa pangunahing function, isang char variable c ay tinukoy at ang address nito ay nakaimbak sa isang void pointer ptr. Ang printChar function ay pagkatapos ay tinatawag na may void pointer 'ptr' bilang argumento. Ang void pointer ay tahasang na-convert sa isang char pointer sa “printChar” function upang i-access at i-print ang halaga na nakaimbak sa 'c' .
Sa C++, ang code ay ibinigay sa ibaba:
#includewalang bisa printInt ( walang bisa * sa isa ) {
int * ptr = static_cast < int *> ( sa isa ) ;
std :: cout << * ptr << std :: endl ;
}
int pangunahing ( ) {
int x = 10 ;
walang bisa * ptr = at x ;
printInt ( ptr ) ;
bumalik 0 ;
}
Ang code sa itaas ay tumutukoy sa isang function printInt na kumukuha ng void pointer num bilang isang parameter at inihagis ito sa isang integer pointer gamit ang operator ng static_cast . Pagkatapos ay ipi-print ng function ang halaga ng integer na itinuro ng casted pointer. Sa pangunahing function, ang isang integer variable x ay tinukoy at ang address nito ay naka-imbak sa a void pointer ptr, na pagkatapos ay ipinapasa sa printInt function. Ang output ng programa ay ang halaga ng x, na 10.
Pangwakas na Kaisipan
Ang walang bisa Ang mga pointer sa C at C++ ay nagbibigay ng isang mahusay na paraan upang manipulahin ang data nang hindi kailangang malaman ang partikular na uri ng data nito. Ang mga ito ay kapaki-pakinabang para sa paglalaan ng memorya at mga function pointer, pati na rin para sa paglikha ng isang generic na interface para sa mga bagay ng iba't ibang klase sa C++. Gayunpaman, mahalagang isaalang-alang ang mga pagkakaiba sa pagitan ng C at C++ sa kanilang paggamit ng walang bisa na mga payo , gaya ng pangangailangan para sa mga partikular na uri ng data sa C++ at ang pangangailangan para sa tahasang conversion kapag nag-cast ng mga void pointer sa iba pang uri ng pointer. Ang maingat na pagsasaalang-alang sa mga puntong ito ay maaaring humantong sa mas mahusay at epektibong paggamit ng walang bisa na mga payo sa programming.