Funkciók a C programozásban példákkal: Rekurzív, Inline

Tartalomjegyzék:

Anonim

Mi a függvény C-ben?

A C programozás funkciója egy újrafelhasználható kódblokk, amely megkönnyíti a program megértését, tesztelését és könnyen módosítható a hívó program megváltoztatása nélkül. A funkciók megosztják a kódot, és modulálják a programot a jobb és eredményesebb eredmények érdekében. Röviden: egy nagyobb program különféle alprogramokra oszlik, amelyeket függvényként hívnak meg

Ha egy nagy programot különféle funkciókra oszt, könnyen megkönnyíti az egyes funkciók külön-külön történő kezelését. Amikor hiba lép fel a programban, könnyen kivizsgálhatja a hibás funkciókat, és csak ezeket a hibákat javíthatja ki. Könnyedén felhívhatja és használhatja a funkciókat, amikor csak szükséges, ami automatikusan időt és helyet takarít meg.

Ebben az oktatóanyagban megtanulja-

  • Könyvtár vs. Felhasználó által definiált funkciók
  • Funkciónyilatkozat
  • Funkció meghatározása
  • Funkcióhívás
  • Funkció érvek
  • Változó hatókör
  • Statikus változók
  • Rekurzív funkciók
  • Beépített funkciók

Könyvtár vs. Felhasználó által definiált funkciók

Minden „C” programnak van legalább egy funkciója, amely a fő funkció, de egy program tetszőleges számú funkcióval rendelkezhet. A fő () függvény a C-ben egy program kiindulópontja.

A „C” programozásban a funkciók két típusra oszthatók:

  1. Könyvtári funkciók
  2. Felhasználó által definiált funkciók

A különbség a könyvtár és a felhasználó által definiált függvények között C-ben az, hogy nem kell kódot írni a függvény könyvtárához. Ez már benne van a fejlécfájlban, amelyet mindig a program elején tartalmazunk. Csak be kell írnia egy függvény nevét, és a megfelelő szintaxissal együtt kell használnia. A Printf, a scanf a könyvtárfunkció példái.

Míg a felhasználó által definiált függvény egy olyan típusú funkció, amelyben meg kell írnunk egy függvény törzsét, és meg kell hívnunk a függvényt, amikor a funkcióra valamilyen művelet végrehajtására van szükségünk programunkban.

A felhasználó által definiált függvényt a C-ben mindig a felhasználó írja, de később a „C” könyvtár része lehet. A „C” programozás egyik fő előnye.

A C programozási funkciók három tevékenységre vannak felosztva, például:

  1. Funkciónyilatkozat
  2. Funkció meghatározása
  3. Funkcióhívás

Funkciónyilatkozat

A funkció deklaráció egy program nevének megírását jelenti. Kötelező rész a függvények kódban történő használatához. A függvénydeklarációban csak megadjuk annak a függvénynek a nevét, amelyet a programunkban használunk, mint egy változó deklarációt. Csak akkor használhatunk függvényt, ha azt egy program deklarálja. A függvény deklarációt "Funkció prototípusnak " is nevezik .

A függvénydeklarációkat (az úgynevezett prototípusokat) általában a main () függvény felett végezzük el, és az alábbi általános formában fordulnak elő:

return_data_type function_name (data_type arguments);
  • A return_data_type : az értékfüggvény adattípusa, amely visszakerült a hívó utasításhoz.
  • A function_name : után zárójelek szerepelnek
  • Az argumentumnevek adattípus-deklarációikkal opcionálisan a zárójelek közé kerülnek.

Figyelembe vesszük a következő programot, amely bemutatja, hogyan kell deklarálni egy kockafüggvényt egy egész változó kockaértékének kiszámításához

#include /*Function declaration*/int add(int a,b);/*End of Function declaration*/int main() {

Ne feledje, hogy egy függvény nem feltétlenül ad vissza értéket. Ebben az esetben a void kulcsszót használják.

Például a output_message függvény deklarációja azt jelzi, hogy a függvény nem ad vissza értéket: void output_message ();

Funkció meghatározása

A függvénydefiníció csak egy függvény törzsének megírását jelenti. A függvénytest olyan állításokból áll, amelyek egy adott feladatot fognak végrehajtani. A függvénytest egyetlen vagy mondatblokkból áll. Ez egy függvény kötelező része is.

int add(int a,int b) //function body{int c;c=a+b;return c;}

Funkcióhívás

A függvényhívás azt jelenti, hogy egy függvényt akkor hívunk meg, amikor erre szükség van egy programban. Valahányszor meghívunk egy függvényt, egy olyan műveletet hajt végre, amelyre tervezték. A függvényhívás a program opcionális része.

 result = add(4,5);

Itt van a teljes kód:

#include int add(int a, int b); //function declarationint main(){int a=10,b=20;int c=add(10,20); //function callprintf("Addition:%d\n",c);getch();}int add(int a,int b) //function body{int c;c=a+b;return c;}

Kimenet:

Addition:30

Funkció érvek

A függvény argumentumait arra használják, hogy a függvényhívással megkapják a szükséges értékeket. Helyzet szerint egyeztetik őket; az első argumentum átkerül az első paraméterbe, a második a második paraméterbe és így tovább.

Alapértelmezés szerint az argumentumokat olyan érték adja át , amelyben az adatok egy példányát megadják a meghívott függvénynek. A ténylegesen átadott változó nem változik.

A következő programot vesszük figyelembe, amely bemutatja az érték által átadott paramétereket:

int add (int x, int y);int main() {int a, b, result;a = 5;b = 10;result = add(a, b);printf("%d + %d\ = %d\n", a, b, result);return 0;}int add (int x, int y) {x += y;return(x);}

A program kimenete:

5 + 10 = 15

Ne feledje, hogy az a és b értékeket a függvény hozzáadásához adták át, és nem változtattak, mert csak az értéket adták át az x paraméterbe.

Változó hatókör

A változó hatóköre a változók láthatóságát jelenti a program kódjában.

A C-ben a függvényen belül deklarált változók lokálisak az adott kódblokkhoz, és nem hivatkozhatók a függvényen kívülre. Azonban az összes függvényen kívül deklarált változók globálisak és hozzáférhetők az egész programból. A program tetején #define értékkel deklarált konstansok a teljes programból elérhetők. A következő programot vesszük figyelembe, amely a globális változó értékét kiírja mind a fő, mind a felhasználó által definiált függvényből:

#include int global = 1348;void test();int main() {printf("from the main function : global =%d \n", global);test () ;return 0;}void test (){printf("from user defined function : global =%d \n", global);}

Eredmény:

from the main function : global =1348from user defined function : global =1348

Megbeszéljük a program részleteit:

  1. Kijelöljük kezdőértékként egy egész globális változót, amelynek értéke 1348.
  2. Kijelentjük és definiálunk egy test () függvényt, amely nem vesz fel argumentumokat és nem ad vissza értéket. Ez a függvény csak a globális változó értékét nyomtatja ki annak bemutatására, hogy a globális változók a program bárhol elérhetők.
  3. A globális változót kinyomtatjuk a fő függvényen belül.
  4. Az orde tesztfüggvényt hívjuk a globális változó értékének kinyomtatására.

C-ben, amikor argumentumokat adunk át a függvényparamétereknek, a paraméterek helyi változókként működnek, amelyek megsemmisülnek a függvényből való kilépéskor.

Globális változók használatakor óvatosan használja őket, mert hibákhoz vezethetnek, és bárhol megváltozhatnak a programban. Használatuk előtt inicializálni kell őket.

Statikus változók

A statikus változók lokális hatókörrel rendelkeznek. A funkcióból való kilépéskor azonban nem pusztulnak el. Ezért egy statikus változó örökre megőrzi értékét, és a funkció újbóli belépésekor érhető el. A statikus változó inicializálva van, amikor deklarálva van, és a statikus előtagra van szüksége.

A következő program statikus változót használ:

#include void say_hi();int main() {int i;for (i = 0; i < 5; i++) { say_hi();}return 0;}void say_hi() {static int calls_number = 1;printf("Hi number %d\n", calls_number);calls_number ++; }

A program a következőket jeleníti meg:

Hi number 1Hi number 2Hi number 3Hi number 4Hi number 5

Rekurzív funkciók

Tekintsük egy szám tényezőjét, amelyet a 6. lépés szerint számolunk! = 6 * 5 * 4 * 3 * 2 * 1.

Ezt a számítást többszörösen kiszámított tényként * (tény -1) végzik, amíg a tény nem lesz 1.

A rekurzív funkció egy olyan funkció, amely felhívja magát, és tartalmaz egy kilépési feltételt a rekurzív hívások befejezése érdekében. A faktoriális számítás esetén a kilépési feltétel valójában egyenlő az 1. A rekurzió úgy működik, hogy a hívásokat "egymásra rakja", amíg a kilépési feltétel igaz.

Például:

#include int factorial(int number);int main() {int x = 6;printf("The factorial of %d is %d\n", x, factorial(x));return 0;}int factorial(int number) {if (number == 1) return (1); /* exiting condition */elsereturn (number * factorial(number - 1));}

A program a következőket jeleníti meg:

 The factorial of 6 is 720

Itt megvitatjuk a program részleteit:

  1. Kijelentjük rekurzív faktoriális függvényünket, amely egy egész paramétert vesz fel, és visszaadja ennek a paraméternek a faktoriálját. Ez a függvény hívja magát és csökkenti a számot, amíg a kilépés vagy az alapfeltétel el nem ér. Ha a feltétel igaz, a korábban generált értékeket megszorozzuk egymással, és a végső faktoriális érték visszatér.
  2. Deklaráljuk és inicializáljuk a "6" értékű egész változót, majd a faktoriális függvényünk meghívásával kinyomtatjuk annak faktoriális értékét.

Vegye figyelembe az alábbi diagramot, hogy jobban megértse a rekurzív mechanizmust, amely abból áll, hogy a függvényt önmagának hívja, amíg az alapeset vagy a leállítási feltétel el nem éri, majd ezt követően összegyűjtjük az előző értékeket:

Beépített funkciók

A C programozás funkciója a leggyakrabban használt utasítások tárolására szolgál. A program modulálására szolgál.

Amikor egy függvényt meghívnak, az utasításmutató a függvénydefinícióra ugrik. A függvény végrehajtása után az utasításmutató visszaesik az utasításra, ahonnan a függvénydefinícióra ugrott.

Amikor függvényeket használunk, szükségünk van egy további mutatófejre, hogy a funkciódefinícióra ugorjon, és visszatérjen az utasításhoz. Az ilyen mutatófejek szükségességének kiküszöbölése érdekében soros funkciókat használunk.

Inline függvényben a függvényhívást közvetlenül egy tényleges programkód váltja fel. Nem ugrik egyetlen blokkra sem, mert az összes műveletet az inline függvényen belül hajtják végre.

Az inline függvényeket leginkább kis számításokhoz használják. Nem alkalmasak nagy számítástechnika esetén.

Az inline függvény hasonló a normál függvényhez, azzal a különbséggel, hogy az inline kulcsszó a függvény neve előtt van. Az inline függvények a következő szintaxissal jönnek létre:

inline function_name (){//function definition}

Írjunk egy programot egy inline függvény megvalósítására.

inline int add(int a, int b) //inline function declaration{return(a+b);}int main(){int c=add(10,20);printf("Addition:%d\n",c);getch();}

Kimenet:

Addition: 30

A fenti program bemutatja az inline függvény használatát két szám hozzáadásához. Mint láthatjuk, az inline függvényen belül két számra adtuk vissza az összeadást, anélkül, hogy bármilyen extra sort írtunk volna. A függvényhívás során éppen átadtuk azokat az értékeket, amelyeken összeadást kell végrehajtanunk.

Összegzés

  • A függvény egy mini program vagy egy alprogram.
  • Funkciókat használunk a program modulálására.
  • A könyvtár és a felhasználó által definiált kétféle funkció.
  • A függvény deklarációból, függvénytörzsből és függvényhívó részből áll.
  • A funkciónyilatkozat és a test kitöltése kötelező.
  • A funkcióhívás opcionális lehet egy programban.
  • A C programnak legalább egy funkciója van; ez a fő funkció ().
  • Minden függvénynek van neve, visszatérési értékének adattípusa vagy érvénytelen értéke, paraméterei.
  • Minden funkciót meg kell határozni és deklarálni kell a C programban.
  • Ne feledje, hogy a C függvény hétköznapi változói megsemmisülnek, amint kilépünk a függvényhívásból.
  • A függvénynek átadott argumentumok nem változnak, mert a cím és cím szerinti értékek alapján adják át őket.
  • A változó hatóköre a változók láthatósága a programon belül
  • A C programozásban vannak globális és lokális változók