Kas ir tukšuma rādītājs (tukšums*)?
Tukšais rādītājs, kas pazīstams arī kā vispārīgs rādītājs, ir rādītājs, kas nav saistīts ar kādu konkrētu datu tipu, tāpēc tas ir piemērots, lai norādītu uz jebkura veida datiem. Citiem vārdiem sakot, a tukšs rādītājs var norādīt uz veselu skaitli, rakstzīmi, virkni vai jebkuru citu datu tipu. Šī elastība padara tukšās norādes par spēcīgu C un C++ programmēšanas rīku.
Nederīgu rādītāju deklarācija C un C++ valodā
Programmā C un C++, tukšs rādītājs tiek deklarēts, izmantojot šādu sintaksi:
nederīgs * ptr ;
Tukšo rādītāju izmantošana C un C++
Tukšas norādes C valodā galvenokārt izmanto, ja mainīgā datu tips nav zināms vai var mainīties izpildes laikā. Tie nodrošina vispārīgu veidu, kā uzglabāt un apstrādāt datus, nezinot to specifisko datu tipu. Tas ir īpaši noderīgi, strādājot ar funkcijām vai datu struktūrām, kas var apstrādāt dažāda veida datus.
Viens izplatīts lietojums tukšas norādes ir atmiņas piešķiršanas funkcijās, piemēram, malloc () kas atgriež tukšuma rādītāja punktu atmiņas blokā, ko var izmantot jebkura veida datu glabāšanai. Pēc tam programmētājs var novirzīt tukšuma rādītāju uz atbilstošo datu tipu, lai piekļūtu piešķirtajā atmiņas blokā saglabātajiem datiem un ar tiem manipulētu.
Ir vēl viens tukšo rādītāju lietojums C valodā funkciju norādes , kas ir mainīgie, kas saglabā funkcijas atmiņas adresi. Nederīgos rādītājus var izmantot, lai saglabātu jebkuras funkcijas atmiņas adresi neatkarīgi no tās atgriešanas veida vai parametru saraksta, tādējādi nodrošinot lielāku elastību funkciju rādītāja lietošanā.
Pielietojums tukšas norādes C++ valodā ir gandrīz līdzīgs, tomēr tos var izmantot arī, lai izveidotu vispārīgu interfeisu dažādu klašu objektiem. To bieži panāk, izmantojot virtuālās funkcijas, kas ļauj vienādi apstrādāt dažādu klašu objektus. Turklāt C++ piedāvā stingrāku tipa pārbaudi nekā C, kas nozīmē, ka tiek izmantota tukšas norādes nepareizi var radīt vairāk kļūdu un kļūdu.
Norādījumi, kas jāņem vērā, izmantojot nederīgās norādes valodās C un C++
Šeit ir daži punkti, kas jāņem vērā, lietojot tukšas norādes C un C++ valodās.
1: C, spēkā neesošs* var izmantot kā atgriešanas vērtību un funkcijas parametru, bet programmā C++ ir jābūt noteiktam datu tipa rādītājam.
Piemēram:
C valodā kods ir norādīts zemāk:
#include#include
nederīgs * add_numbers ( starpt a , starpt b ) {
starpt * rezultāts = malloc ( izmērs ( starpt ) ) ;
* rezultāts = a + b ;
atgriezties ( nederīgs * ) rezultāts ;
}
nederīgs drukas_rezultāts ( nederīgs * rezultāts ) {
starpt * ptr = ( starpt * ) rezultāts ;
printf ( 'Rezultāts ir: %d \n ' , * ptr ) ;
bezmaksas ( ptr ) ;
}
starpt galvenais ( ) {
starpt num1 = 5 , num2 = 7 ;
nederīgs * rezultāts = add_numbers ( num1 , num2 ) ;
drukas_rezultāts ( rezultāts ) ;
atgriezties 0 ;
}
Iepriekš minētais kods definē funkciju add_numbers() kas atgriež a spēkā neesošs* rādītājs uz rezultātu, pievienojot divus veselus skaitļus, kas nodoti kā argumenti. Funkcija print_result() ņem a tukšs* rādītājs un izdrukā rezultātu. Funkcijā main() mēs izsaucam add_numbers() un nodod iegūto tukšs* rādītājs uz print_result() drukāšanai.
Programmā C++ ir nepieciešams noteikts datu tips.
#includeizmantojot namespace std ;
nederīgs printInt ( starpt * uz viena ) {
cout << 'Vesels skaitlis ir: << * uz viena << endl ;
}
starpt galvenais ( ) {
starpt x = 10 ;
starpt * ptr = & x ;
printInt ( ptr ) ;
atgriezties 0 ;
}
2: Programmā C varat konvertēt tukšo rādītāju uz citu rādītāja veidu netieša konversija. Bet C++ jums ir jāizmanto nepārprotama konversija lai pārvērstu tukšs rādītājs uz jebkuru citu rādītāja veidu.
Šeit ir vienkāršs koda piemērs gan C, gan C++, lai ilustrētu atšķirību starp netieši un nepārprotama konversija no tukšas norādes uz citiem rādītāju veidiem:
C valodā tiek izmantots šāds kods:
#includenederīgs printChar ( nederīgs * ch ) {
char c = * ( char * ) ch ;
printf ( '%c \n ' , c ) ;
}
starpt galvenais ( ) {
char c = 'a' ;
nederīgs * ptr = & c ;
printChar ( ptr ) ;
atgriezties 0 ;
}
Iepriekš minētais kods definē funkciju printChar kas izmanto tukšuma rādītāju kā parametru un izdrukā šajā atmiņas vietā saglabāto rakstzīmi. Galvenajā funkcijā char mainīgais c ir definēts un tā adrese tiek saglabāta tukšajā rādītājā ptr. The printChar pēc tam funkcija tiek izsaukta ar tukšs rādītājs 'ptr' kā arguments. Tukšais rādītājs ir nepārprotami pārveidots par char rādītāju “printChar” funkcija, lai piekļūtu saglabātajai vērtībai un izdrukātu to “c” .
C++ valodā kods ir norādīts zemāk:
#includenederīgs printInt ( nederīgs * uz viena ) {
starpt * ptr = static_cast < starpt *> ( uz viena ) ;
std :: cout << * ptr << std :: endl ;
}
starpt galvenais ( ) {
starpt x = 10 ;
nederīgs * ptr = & x ;
printInt ( ptr ) ;
atgriezties 0 ;
}
Iepriekš minētais kods definē funkciju printInt kas izmanto tukšuma rādītāja num kā parametru un pārraida to uz vesela skaitļa rādītāju, izmantojot operators static_cast . Pēc tam funkcija izdrukā veselā skaitļa vērtību, uz kuru norāda izmestais rādītājs. Galvenajā funkcijā ir definēts vesels skaitlis mainīgais x un tā adrese tiek saglabāta a tukšs rādītājs ptr, kas pēc tam tiek nodots printInt funkciju. Programmas izvade ir x vērtība, kas ir 10.
Pēdējās domas
The nederīgs C un C++ norādes nodrošina jaudīgu veidu, kā manipulēt ar datiem, nezinot to specifisko datu tipu. Tie ir noderīgi atmiņas piešķiršanai un funkciju norādes, kā arī lai izveidotu vispārīgu saskarni dažādu klašu objektiem C++. Tomēr ir svarīgi ņemt vērā atšķirības starp C un C++ to lietošanā tukšas norādes , piemēram, nepieciešamība pēc konkrētiem datu tipiem programmā C++ un nepieciešamība pēc skaidras pārveidošanas, apraidot nederīgās norādes uz citiem rādītāju tipiem. Rūpīga šo punktu apsvēršana var nodrošināt efektīvāku un lietderīgāku izmantošanu tukšas norādes programmēšanā.