Pandaigdigang Pag-andar
Ang global function ay isang function na tinukoy sa isang C file bago ang main() function. Kahit na ang main() function ay isang global function ngunit ang main() function ay hindi ang focus sa artikulong ito. Sa wikang C, ang mga function na tinukoy ng programmer ay karaniwang mga pandaigdigang function at simpleng tinutukoy bilang mga function.
Ang isang pandaigdigang function ay maaaring tawagan sa anumang saklaw sa file nito. Upang ang isang pandaigdigang function na makita sa ibang file, ang prototype nito ay kailangang ideklara sa ibang file na iyon (tingnan sa ibaba.) Upang maiwasan ang isang function na tinukoy sa isang file na makita sa ibang file, unahan ang kahulugan gamit ang reserbang salita, static. Sa pamamagitan nito, ang static na function ay magiging isang global function lamang sa sarili nitong file at hindi makikita sa ibang file.
Kaya, ang isang pandaigdigang function na tinukoy sa otherFile.c ay makikita kahit saan sa otherFile.c. Para ito ay makita sa mainFile.c, ang prototype nito ay kailangang ideklara sa mainFile.c (tingnan sa ibaba.) Ang kahulugan nito sa otherFile.c ay hindi dapat unahan ng 'static'. Upang maiwasang makita ito sa mainFile.c, ang kahulugan nito sa otherFile.c ay kailangang gawing static na inalis ang kuwit sa pamamagitan ng unahan nito ng salitang, static.
Ang artikulong ito ay naglalarawan ng static na function sa wika ng computer, C na nagsisimula sa kahulugan ng function prototype at ang paggamit nito sa isang C program ng dalawa o higit pang mga file.
Ang pagsasama-sama ng mga file, mainFile.c at otherFile.c, ay maaaring gawin gamit ang sumusunod na Bash terminal command:
gcc mainFile. c ibangFile. c - na temp. exe
temp.exe ay ang pangalan ng nagreresultang solong executing file.
Nilalaman ng Artikulo
C Function Prototype
Isaalang-alang ang pangkalahatang kahulugan ng function:
char * fn1 ( char * stri ) {bumalik stri ;
}
Ang prototype para sa function na ito ay:
char * fn1 ( char * stri ) ;Ito ang function signature, na nagtatapos sa semicolon.
Ngayon, hayaan ang nilalaman ng otherFile.c ay:
char * fn1 ( char * stri ) {bumalik stri ;
}
Ipagpalagay na ang file, otherFile.c ay mayroon lamang ng kahulugan ng pandaigdigang function, fn1(). Ngayon hayaan ang nilalaman ng file, mainFile.c, ay:
#includechar * fn1 ( char * stri ) ;
int pangunahing ( )
{
char * str = fn1 ( 'nakita' ) ;
printf ( '%s \n ' , str ) ;
bumalik 0 ;
}
Nagsisimula ito sa pagsasama ng
Ang pangunahing file na ito ay walang kahulugan ng anumang pandaigdigang function maliban sa default na main() function. Sa pangunahing function, ang unang pahayag ay tumatawag sa function na fn1() na tinukoy sa ibang file. Hindi magiging epektibo ang tawag na ito kung ang prototype ng fn1() ay hindi idineklara sa file na ito, mainFile.c.
Kung na-code ng mambabasa ang dalawang file sa itaas, maaari niyang i-compile ang program sa isang executable file na may sumusunod na command:
gcc mainFile. c ibangFile. c - na temp. exepagpindot sa Enter key sa dulo ng linya. Ang output ay dapat, 'nakikita'.
Pandaigdigang Pag-andar
Ang mainFile.c file ay maaaring mabago tulad ng sumusunod:
#includechar * fn1 ( char * stri ) ;
char * fn ( char * st ) {
bumalik st ;
}
int pangunahing ( )
{
char * str1 = fn1 ( 'nakita' ) ;
printf ( '%s \n ' , str1 ) ;
char * str2 = fn ( 'Global na nakikita sa file nito.' ) ;
printf ( '%s \n ' , str2 ) ;
bumalik 0 ;
}
Ngayon, mayroong dalawang pandaigdigang function sa file, mainFile.c. Ang mga pangalan ng mga function ay fn() at main(). Ang dfn() ay isang pandaigdigang function. Ito ay nakita sa pangunahing() function na lokal na saklaw, sa pamamagitan ng isang tawag. Sa wikang C, ang isang pandaigdigang function sa pandaigdigang saklaw, tulad ng fn(), ay simpleng tinutukoy bilang isang function. Gayundin, ang global function, fn1() sa file, otherFile.c ay simpleng tinutukoy, bilang isang function.
Kung ang dalawang file ay muling pinagsama-sama sa temp.exe, kung gayon ang iyong magiging:
nakitaGlobal na makikita sa file nito.
Tandaan: ang kahulugan ng function para sa fn() ay maaari ding gawin upang makita sa kabilang file, otherFile.c. Upang makamit iyon ay mayroong prototype na deklarasyon sa otherFile.c, tulad ng sumusunod:
char * fn ( char * st ) ;nagtatapos sa semicolon. Ang aktibidad na ito, ay iniwan bilang isang ehersisyo para sa mambabasa.
Wastong Paggana ng Static
Mula sa talakayan sa itaas, ang isang function ay makikita sa anumang saklaw (kahit saan) sa file nito. Maaari rin itong makita sa ibang file, para sa parehong programa, kung ang prototype nito ay idineklara doon. Upang maiwasang makita ang kahulugan ng file sa ibang file, gawing static ang kahulugan sa pamamagitan ng unahan nito ng nakareserbang salita, static. Kahit na ang prototype nito ay idineklara sa ibang file, hindi pa rin ito makikita sa ibang file. Ang mga file ng programa ay hindi kahit na mag-compile. Upang ilarawan ito, hayaan ang nilalaman ng file, otherFile.c ay:
static char * fn1 ( char * stri ) {bumalik stri ;
}
Ito ang parehong nilalaman sa file, otherFile.c, tulad ng dati, ngunit kasama ang naunang nakalaan na salita, static. Ang nilalaman ng mainFile.c file, ay nananatiling pareho. Kung ang isang pagtatangka ay ginawa upang ipunin ang mga file ng programa gamit ang utos,
gcc mainFile. c ibangFile. c - na temp. exeang compiler ay maglalabas ng mensahe ng error, ibig sabihin ay hindi nag-compile ang program. Kahit na ang prototype deklarasyon sa iba't ibang mga file, ay din preceded sa pamamagitan ng static, ang program file ay hindi pa rin mag-compile.
Konklusyon
Ang kahulugan ng function sa wikang C, ay isang pandaigdigang function. Ang function na ito ay maaaring tawagin (nakikita) sa anumang saklaw sa file nito. Upang makita ang function na ito sa ibang file, tulad ng pangunahing file, ang prototype na deklarasyon nito ay kailangang i-type sa ibang file na iyon. Upang maiwasang makita ang function na ito sa iba't ibang file, gawing static ang kahulugan nito sa pamamagitan ng pag-uuna nito ng nakareserbang salita, static.