Home-theater-designers
Maaaring nasaklaw mo na ang basic C syntax, na may mga simpleng halimbawa, at ngayon ay nag-iisip kung paano gumawa ng mas malalaking, real-world na mga programa. Para sa panimula, gugustuhin mong ayusin ang iyong code sa mga mahuhusay na bahagi, na may kaunting pag-uulit. Sa C, tulad ng karamihan sa mga wika, ang sagot sa iyong mga problema ay ang function.
MUO Video ng araw MAG-SCROLL PARA MAGPATULOY SA NILALAMAN
Ang paggawa at paggamit ng mga function sa C ay diretso at nagdudulot ng maraming benepisyo. Binibigyang-daan ka ng mga function na hatiin ang mga kumplikadong programa sa mas maliliit na piraso. Nagbibigay ang mga ito ng muling paggamit, kapwa sa loob ng iyong orihinal na programa, at sa mga nauugnay na aklatan o iba pang magkakahiwalay na programa.
Upang magsimula, kakailanganin mong matutunan ang tungkol sa mga deklarasyon ng function, prototype, parameter, at return statement.
kung paano maglipat mula sa ipod sa iTunes
Ano ang mga Function sa C?
Sa C programming , ang isang function ay isang pinangalanang seksyon ng code na gumagawa ng isang bagay kapag hiniling mo ito. Nakakatulong itong panatilihing maayos ang iyong code at hinahayaan kang gamitin ang parehong pagkilos nang maraming beses nang hindi nauulit ang iyong sarili.
Ang pinakasimpleng halimbawa ay isa na ginagamit mo na: ang pangunahing() function. Ang pangunahing function ay partikular na espesyal dahil ito ay gumaganap bilang ang pangunahing entry point para sa anumang C program. Maaari mo ring gamitin ang mga function ng library, na ang mga naisulat na ng ibang tao, o maaari mong isulat ang iyong sariling mga function na tinukoy ng gumagamit.
Mga Pag-andar: Pagdedeklara, Pagtukoy, at Pagtawag
Ang tatlong aspetong ito ay pangunahing sa paggamit ng mga function.
Pahayag ng Function
Nagbibigay ito ng impormasyon tungkol sa pangalan ng isang function, uri ng pagbabalik, at mga parameter, na nagpapagana sa paggamit nito bago ang buong kahulugan nito. Tinatawag din itong function prototype. Ito ay sumusunod sa simpleng syntax na ito:
return_type function_name(parameters);
saan:
- return_type ay ang uri ng data ng halaga na ibinabalik ng function. Maaari itong maging anumang wastong uri ng data ng C o walang bisa kung ang function ay hindi nagbabalik ng isang halaga.
- function_name ay ang pangalang ibibigay mo sa function. Gagamitin mo ito para tawagan ang function sa ibang pagkakataon.
- mga parameter ay isang listahan ng mga parameter ng input na tinatanggap ng function, kung mayroon man. Ang bawat parameter ay binubuo ng isang uri ng data na sinusundan ng isang pangalan ng parameter na pinaghihiwalay ng mga kuwit.
Halimbawa, narito ang isang simpleng deklarasyon ng function:
int add(int a, int b);
Kahulugan ng Function
Kapag tumawag ka ng isang function, pinapatakbo nito ang code na tinukoy sa kahulugan nito. Kabilang dito ang pangalan ng function, uri ng pagbabalik, listahan ng parameter, at ang mga pahayag na tumutukoy sa pag-uugali nito. Narito ang syntax:
return_type function_name(parameters) {
// Function body - code that defines what the function does
// Return a value if applicable
return value;
}
Hatiin natin ang mga bahagi ng syntax:
Function body : Ito ang bloke ng code na nakapaloob sa mga kulot na braces {} . Naglalaman ito ng mga tagubilin na tumutukoy kung ano ang ginagawa ng function kapag tinawag ito.
Balik na pahayag : Kung ang function ay may uri ng pagbabalik maliban sa walang bisa , ang bumalik ang pahayag ay nagpapadala ng halaga pabalik sa tumatawag. Dapat tumugma ang halagang ito sa tinukoy na uri ng pagbabalik.
Narito ang isang simpleng halimbawa ng isang kahulugan ng function:
int add(int a, int b) {
int sum = a + b;
return sum;
}
Function Call
Katulad ng pagluluto, maaaring mayroon kang recipe (function definition) at ilang sangkap (argument), ngunit kailangan mo pa ring sundin ang mga tagubilin para makakuha ng resulta. Ang isang function na tawag ay tatakbo sa function na may ibinigay na mga argumento; eto ang syntax:
return_type result = function_name(arguments);
mga argumento : Ito ang mga value o expression na ipinapasa mo sa function bilang mga input. Paghiwalayin ang bawat argumento ng kuwit. Ang numero, pagkakasunud-sunod, at mga uri ng data ng mga argumento ay dapat tumugma sa listahan ng parameter ng function.
resulta : Kung ang function ay may uri ng pagbabalik maliban sa walang bisa , maaari mong makuha ang ibinalik na halaga gamit ang isang variable ng naaangkop na uri ng data.
Narito ang isang halimbawa ng isang function na tawag:
#include <stdio.h>
// Function prototype
int add(int a, int b);
int main() {
int x = 5, y = 3;
// Call the function and store the result in 'sum'
int sum = add(x, y);
printf("The sum of %d and %d is %d\n", x, y, sum);
return 0;
}
// Function definition
int add(int a, int b) {
return a + b;
}
Sa pamamagitan ng pagsunod sa tatlong hakbang na ito—pagdedeklara ng function, pagbibigay ng pagpapatupad nito, at pagtawag dito ng naaangkop na mga argumento—mabisa mong magagamit ang mga function upang maisagawa ang iba't ibang gawain sa iyong programa.
Mga Parameter ng Paggana at Mga Halaga ng Pagbabalik
Ang mga parameter ay mga variable na ipinahayag sa deklarasyon o kahulugan ng function na nagsisilbing mga placeholder para sa mga value na ipinasa sa function kapag tinawag. Nagbibigay-daan sa iyo ang mga ito na ipasa ang data sa function, na pinapagana itong gumana at manipulahin ang data na iyon. Ang mga return value ay ang mga value na ginagawa ng isang function at ipinadala pabalik sa tumatawag.
Mayroong dalawang paraan ng pagpasa ng mga parameter.
Pass by Value
Sa diskarteng ito, kinokopya ng isang function na tawag ang halaga ng aktwal na argumento sa parameter ng function. Ang mga pagbabagong ginawa sa parameter sa loob ng function ay hindi makakaapekto sa orihinal na argumento.
Halimbawa:
ano ang magagawa ko sa isang raspberry pi
#include <stdio.h>
int square(int num) {
num = num * num;
return num;
}
int main() {
int x = 5;
int y = square(x);
// Output: x and y after function call: 5 25
printf("x and y after function call: %d %d\n", x, y);
return 0;
}
- Ang square function ay tumatagal ng isang integer parameter, sa isa .
- Kinakalkula ng square function ang square ng num, ina-update ang value nito, at ibinabalik ang bagong value na ito.
- Ang pangunahing function ay nagdedeklara ng isang integer variable, x , at itinalaga ito ng halaga 5.
- Pagkatapos ay tinawag nito ang square function, na ipinapasa ito sa halaga ng x. Itinatalaga nito ang resulta sa pangalawang variable, at .
- Pagkatapos ng function na tawag, pangunahing ipi-print ang mga halaga ng x at y. Ang halaga ng x ay nananatiling pareho dahil ang pagbabago ng num parameter sa loob ng parisukat ay hindi nakakaapekto sa orihinal na x.
Dumaan sa Sanggunian
Gamit ang diskarteng ito, ipapasa mo ang memory address (pointer) ng isang halaga sa isang function. Ang mga pagbabagong ginawa sa parameter sa loob ng function ay nakakaapekto sa orihinal na halaga sa labas nito.
Ang mga pointer, kasama ang kanilang paggamit bilang mga parameter, ay isa sa mga aspeto ng C na ginagawa itong naiiba mula sa isang wika tulad ng Python .
#include <stdio.h>
void square(int *num) {
*num = *num * *num;
}
int main() {
int x = 5;
square(&x);
// Output: x after function call: 25
printf("x after function call: %d\n", x);
return 0;
}
- Ang parisukat ang function ay tumatagal ng isang integer pointer ( int * ) parameter, sa isa . Hindi ito nagbabalik ng halaga.
- Kinakalkula ng square function ang square ng value na iyon sa isa naglalaman at ina-update ang halagang iyon gamit ang pointer dereference operator, * .
- Ang pangunahing ang function ay nagdedeklara ng integer variable, x , at itinalaga ito ng halaga 5 .
- Pagkatapos ay tinawag nito ang parisukat function na may isang pointer sa x gamit ang address-ng operator: &x .
- Pagkatapos ng function na tawag, pangunahing ipi-print ang halaga ng x , na ngayon 25 mula noong mga pagbabago sa *sa isa sa loob ng parisukat ang function ay nakakaapekto sa orihinal x .
Sa buod, ang pangunahing pagkakaiba sa pagitan ng dalawang pamamaraan ay kung paano nakakaapekto ang mga pagbabago sa parameter sa loob ng function sa orihinal na halaga sa labas nito. Ang pass by value ay lumilikha ng kopya, habang ang pass by reference (pointer) ay nagbibigay-daan sa direktang pagmamanipula ng orihinal na halaga.