A c-ben feloszthatunk egy nagy programot a függvénynek nevezett alapvető építőelemekre. A függvény tartalmazza a programozási utasítások halmazát, amelyeket {} zár be. Egy függvény többször is meghívható, hogy a C program újrafelhasználható és moduláris legyen. Más szóval azt mondhatjuk, hogy a függvénygyűjtemény egy programot hoz létre. A függvény más néven eljárást vagy szubrutin más programozási nyelveken.

A C-beli funkciók előnyei

A C függvényeknek a következő előnyei vannak.

• A függvények használatával elkerülhetjük, hogy ugyanazt a logikát/kódot újra és újra átírjuk egy programban.
• A C függvényeket tetszőleges számú alkalommal hívhatjuk meg egy programban és bárhonnan a programban.
• Könnyen nyomon követhetünk egy nagy C-programot, ha több funkcióra van felosztva.
• Az újrafelhasználhatóság a C-funkciók fő vívmánya.
• A függvényhívás azonban mindig többletköltséget jelent egy C programban.

Funkció szempontjai

A C függvénynek három aspektusa van.

Funkció deklarációEgy függvényt globálisan kell deklarálni egy c programban, hogy a fordító közölje a függvény nevét, paramétereit és visszatérési típusát.
FunkcióhívásA függvény a program bármely pontjáról meghívható. A paraméterlista nem különbözhet függvényhívásban és függvénydeklarációban. Ugyanannyi függvényt kell átadnunk, amennyit a függvény deklarációjában deklarálunk.Funkció meghatározásaEz tartalmazza a ténylegesen végrehajtandó utasításokat. Ez a legfontosabb szempont, amelyre a vezérlés vonatkozik a függvény meghívásakor. Itt észre kell vennünk, hogy a függvényből csak egy érték adható vissza.

A függvény létrehozásának szintaxisa c nyelven az alábbiakban látható:

 return_type function_name(data_type parameter...){ //code to be executed } 

A függvények típusai

A C programozásban kétféle függvény létezik:

Könyvtári funkciók:A C fejlécfájlokban deklarált függvények, például scanf(), printf(), gets(), puts(), ceil(), floor() stb.Felhasználó által definiált funkciók:azok a függvények, amelyeket a C programozó hoz létre, így sokszor használhatja. Csökkenti egy nagy program bonyolultságát és optimalizálja a kódot.

Visszatérési érték

Egy C függvény visszaadhat egy értéket a függvényből, vagy nem. Ha nem kell értéket visszaadnia a függvényből, használja a void értéket a visszatérési típushoz.

Nézzünk egy egyszerű példát a C függvényre, amely nem ad vissza semmilyen értéket a függvényből.

Példa visszatérési érték nélkül:

 void hello(){ printf('hello c'); } 

Ha bármilyen értéket szeretne visszaadni a függvényből, bármilyen adattípust kell használnia, például int, long, char stb. A visszatérési típus a függvénytől visszaadandó értéktől függ.

mitől gyors a pc

Nézzünk egy egyszerű példát a C függvényre, amely int értéket ad vissza a függvényből.

Példa visszatérési értékkel:

 int get(){ return 10; } 

A fenti példában 10-et kell visszaadnunk értékként, tehát a visszatérési típus int. Ha lebegőpontos értéket szeretne visszaadni (pl. 10.2, 3.1, 54.5 stb.), a float-ot kell használnia a metódus visszatérési típusaként.

lehet-e egy absztrakt osztálynak konstruktora

 float get(){ return 10.2; } 

Most meg kell hívnia a függvényt, hogy megkapja a függvény értékét.

A függvényhívás különböző aspektusai

Egy függvény elfogadhat vagy nem fogad el bármilyen argumentumot. Lehet, hogy bármilyen értéket ad vissza, vagy nem. Ezen tények alapján a függvényhívásoknak négy különböző aspektusa van.

• függvény argumentumok és visszatérési érték nélkül
• függvény argumentumok nélkül és visszatérési értékkel
• függvény argumentumokkal és visszatérési érték nélkül
• függvény argumentumokkal és visszatérési értékkel

Példa argumentum és visszatérési érték nélküli függvényre

1. példa

 #include void printName(); void main () { printf('Hello '); printName(); } void printName() { printf('Javatpoint'); } 

Kimenet

 Hello Javatpoint 

2. példa

 #include void sum(); void main() { printf('
Going to calculate the sum of two numbers:'); sum(); } void sum() { int a,b; printf('
Enter two numbers'); scanf('%d %d',&a,&b); printf('The sum is %d',a+b); } 

Kimenet

 Going to calculate the sum of two numbers: Enter two numbers 10 24 The sum is 34 

Példa a függvényre argumentum nélkül és visszatérési értékkel

1. példa

 #include int sum(); void main() { int result; printf('
Going to calculate the sum of two numbers:'); result = sum(); printf('%d',result); } int sum() { int a,b; printf('
Enter two numbers'); scanf('%d %d',&a,&b); return a+b; } 

Kimenet

 Going to calculate the sum of two numbers: Enter two numbers 10 24 The sum is 34 

2. példa: program a négyzet területének kiszámítására

visszatérési típusa java-ban

 #include int sum(); void main() { printf('Going to calculate the area of the square
'); float area = square(); printf('The area of the square: %f
',area); } int square() { float side; printf('Enter the length of the side in meters: '); scanf('%f',&side); return side * side; } 

Kimenet

 Going to calculate the area of the square Enter the length of the side in meters: 10 The area of the square: 100.000000 

Példa a függvényre argumentummal és visszatérési érték nélkül

1. példa

 #include void sum(int, int); void main() { int a,b,result; printf('
Going to calculate the sum of two numbers:'); printf('
Enter two numbers:'); scanf('%d %d',&a,&b); sum(a,b); } void sum(int a, int b) { printf('
The sum is %d',a+b); } 

Kimenet

 Going to calculate the sum of two numbers: Enter two numbers 10 24 The sum is 34 

2. példa: program öt szám átlagának kiszámítására.

 #include void average(int, int, int, int, int); void main() { int a,b,c,d,e; printf('
Going to calculate the average of five numbers:'); printf('
Enter five numbers:'); scanf('%d %d %d %d %d',&a,&b,&c,&d,&e); average(a,b,c,d,e); } void average(int a, int b, int c, int d, int e) { float avg; avg = (a+b+c+d+e)/5; printf('The average of given five numbers : %f',avg); } 

Kimenet

 Going to calculate the average of five numbers: Enter five numbers:10 20 30 40 50 The average of given five numbers : 30.000000 

Példa a függvényre argumentummal és visszatérési értékkel

1. példa

 #include int sum(int, int); void main() { int a,b,result; printf('
Going to calculate the sum of two numbers:'); printf('
Enter two numbers:'); scanf('%d %d',&a,&b); result = sum(a,b); printf('
The sum is : %d',result); } int sum(int a, int b) { return a+b; } 

Kimenet

 Going to calculate the sum of two numbers: Enter two numbers:10 20 The sum is : 30 

2. példa: Program annak ellenőrzésére, hogy egy szám páros vagy páratlan

 #include int even_odd(int); void main() { int n,flag=0; printf('
Going to check whether a number is even or odd'); printf('
Enter the number: '); scanf('%d',&n); flag = even_odd(n); if(flag == 0) { printf('
The number is odd'); } else { printf('
The number is even'); } } int even_odd(int n) { if(n%2 == 0) { return 1; } else { return 0; } } 

Kimenet

 Going to check whether a number is even or odd Enter the number: 100 The number is even 

C Könyvtári funkciók

A könyvtári függvények a C beépített funkciói, amelyek csoportosítva vannak, és egy közös helyen, a könyvtárban vannak elhelyezve. Az ilyen funkciókat bizonyos műveletek végrehajtására használják. Például a printf egy könyvtári függvény, amellyel a konzolon nyomtatnak. A könyvtári funkciókat a fordítók tervezői hozzák létre. Az összes C szabványos könyvtári funkció a kiterjesztéssel mentett különböző fejlécfájlokban van definiálva .h . Ezeket a fejlécfájlokat bele kell foglalnunk a programunkba, hogy használhassuk az ilyen fejlécfájlokban meghatározott könyvtári funkciókat. Például az olyan könyvtári funkciók használatához, mint a printf/scanf, bele kell foglalnunk a programunkba az stdio.h fájlt, amely egy fejlécfájl, amely tartalmazza a szabványos bemeneti/kimeneti könyvtári funkciókat.

A leggyakrabban használt fejlécfájlok listája a következő táblázatban található.

A C funkciókkal kapcsolatos további részletek alább találhatók:

Számos további információ található a C függvényekkel kapcsolatban. Néhány közülük a következő:

Moduláris programozás: A képesség, hogy feloszt a hatalmas program A kisebb, jobban kezelhető modulokba bontás a C-beli funkciók használatának egyik fő előnye. Mindegyik funkció tartalmazhat egy adott feladatot vagy funkcionalitás-összetevőt, ami egyszerűsíti és tisztázza a teljes programstruktúrát. Ez a moduláris stratégia javítja a kód újrafelhasználását, és megkönnyíti a karbantartást és a hibakeresést.

java regexben

Kód újrafelhasználása: A függvények használatával egy bizonyos algoritmust vagy logikát csak egyszer hozhat létre, és többször is felhasználhatja a program során. Bármikor meghívhatja a függvényt, amikor le kell futtatnia a kódot, így nem kell máshol másolnia. Nem csak felgyorsítja a fejlődést hanem biztosítja a következetességet és csökkenti a hibák lehetőségét.

Kapszulázás és absztrakció: Azáltal, hogy elfedik a funkcionalitás megvalósításának sajátosságait, a függvények bizonyos szintű absztrakciót kínálnak. Egy függvény prototípus interfésze a fejléc fájl , míg a tényleges megvalósítás egy másik forrásfájlban is megadható. A program más részei anélkül is használhatják a funkciót, hogy meg kellene érteniük, hogyan valósul meg belsőleg az interfész és a megvalósítás elkülönülése miatt.

Egyszerű program karbantartás: Egy program könnyebben megérthető és karbantartható, ha kisebb funkciókra oszlik. Az a képesség, hogy az egyes funkciókhoz külön felelősséget rendeljünk, olvashatóbbá teszi a kódot, és könnyebbé teszi a hibaelhárítást és a hibakeresést. Ha hibát talál, vagy módosításra van szükség, a szükséges funkcióra koncentrálhat anélkül, hogy ez befolyásolná a program többi részét.

Továbbfejlesztett együttműködés: A funkciók lehetővé teszik az ugyanazon a projekten dolgozó fejlesztők számára az együttműködést. A program funkciókra osztható, így több csapattag is dolgozhat rajta különböző funkciókat egyszerre. A fejlesztők zökkenőmentesen integrálhatják munkájukat a funkciókba, ha az interfészek jól meghatározottak, ami javítja a termelékenységet és elősegíti a hatékony fejlesztést.

A paraméter átadása: Argumentumokat vagy adatokat küldhet egy C-beli függvénynek, hogy az feldolgozhassa azokat. A funkció ezen bemenetek felhasználásával műveleteket hajthat végre, és eredményeket generálhat. Paraméterek átadásával növelheti a funkciók rugalmasságát és alkalmazkodóképességét, ami növeli a program általános sokoldalúságát.

Visszatérési értékek: A függvények visszaküldhetik az értékeket az őket meghívó kódnak, lehetővé téve a függvény végrehajtási eredményeinek kommunikálását. A visszaadott értéket a program más területein is felhasználhatja a függvényen belüli számítások vagy adatkezelések elvégzése után. Visszatérési értékek különösen hasznosak, ha eredményt kell kiszámítani vagy feltételt kell létrehozni a függvény kimenetétől függően.

Következtetés:

Összefoglalva, a függvények elengedhetetlenek a C programozáshoz, mert programot adnak szervezettség, újrafelhasználhatóság és modularitás . A fejlesztők elkerülhetik ugyanazon kód többszöri létrehozását azáltal, hogy hatalmas programokat kisebb funkciókra bontanak, így a kód hatékonyabb és egyszerűbb karbantartása. A program bárhol meghívhat egy függvényt, rugalmasságot biztosítva és javítva a vezérlési folyamatot.

A nyilatkozat, felhívás , és meghatározás funkciók csak néhány jellemzője a sok közül. A fordítót a függvény deklarációja tájékoztatja név, érvek , és visszatérési típus . Lehetőség van függvények meghívására vagy nélküle paramétereket és a-val vagy anélkül visszatérési értéket . A programozók felhasználó által definiált függvényeket készítenek, hogy javítsák kódjuk olvashatóságát és optimalizálását, míg a C könyvtári funkciók, mint pl. printf() és scanf() előre beállított képességeket biztosítanak.

Összességében a funkciók kulcsfontosságú építőkövei a C programozásnak, és olyan előnyöket biztosítanak, mint a megnövekedett rendszerezés, a kód újrafelhasználása és a hatalmas programok egyszerű nyomon követése. A funkcióhívások némi többletköltséget jelenthetnek, de előnyeik meghaladják a minimális teljesítményt. A programozók hatékony és moduláris C programokat írhatnak a függvények megértésével és használatával.