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

Mi az a függvény a C-ben?

Funkció a C programozásban egy újrafelhasználható kódblokk, amely megkönnyíti a program megértését, tesztelését és egyszerű módosítását a hívó program megváltoztatása nélkül. A függvények felosztják a kódot és modularizálják a programot a jobb és hatékonyabb eredmények érdekében. Röviden, egy nagyobb programot különböző alprogramokra osztanak, amelyeket függvényeknek nevezünk.

Ha egy nagy programot különböző funkciókra oszt fel, egyszerűvé válik az egyes funkciók egyenkénti kezelése. Ha hiba történik a programban, könnyen kivizsgálhatja a hibás funkciókat, és csak azokat javíthatja ki. Könnyedén hívhatja és használhatja a funkciókat, amikor szükség van rájuk, ami automatikusan időt és helyet takarít meg.

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

Minden 'C' programnak van legalább egy függvénye, amely a fő funkció, de egy programnak tetszőleges számú függvénye lehet. A C fő () függvénye 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 írnunk egy könyvtári függvényhez. Már jelen van a fejlécfájlban, amelyet mindig a program elején helyezünk el. Csak be kell írnia egy függvény nevét, és használnia kell a megfelelő szintaxissal együtt. A Printf, scanf példák a könyvtári függvényekre.

Míg a felhasználó által definiált függvény egy olyan típusú függvény, amelyben meg kell írnunk egy függvény törzsét, és meg kell hívnunk a függvényt, amikor megköveteljük, hogy a függvény végrehajtson valamilyen műveletet a programunkban.

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

A C programozási funkciók három tevékenységre oszlanak, mint pl.

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

Funkciónyilatkozat

A függvénydeklaráció egy program nevének megírását jelenti. Ez a függvények kódban való használatának kötelező része. Egy függvénydeklarációban egyszerűen megadjuk annak a függvénynek a nevét, amelyet a programunkban használni fogunk, hasonlóan egy változódeklarációhoz. Nem használhatunk egy függvényt, hacsak nincs deklarálva egy programban. A függvénydeklarációt „függvényprototípusnak” is nevezik.

A függvénydeklaráció (úgynevezett prototípus) általában a fő () függvény felett történik, és általános formát öltenek:

return_data_type function_name (data_type arguments);

• A return_data_type: a hívó utasításnak visszaadott értékfüggvény adattípusa.
• A függvény_neve: után zárójelek állnak.
• Az argumentumok nevei az adattípus-deklarációjukkal együtt zárójelben helyezkednek el.

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

#include <stdio.h>
/*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ó kerül felhasználásra.

Például az 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ó azt jelenti, hogy csak egy függvény törzsét írjuk. Egy függvény törzse olyan utasításokból áll, amelyek egy adott feladatot fognak végrehajtani. A függvénytörzs egyetlen utasításból vagy utasításblokkból áll. Ez is egy funkció kötelező része.

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 arra egy programban szükség van. Amikor meghívunk egy függvényt, az olyan műveletet hajt végre, amelyre tervezték. A függvényhívás a program választható része.

  result = add(4,5);

Itt a teljes kód:

#include <stdio.h>
int add(int a, int b);	//function declaration
int main()
{
	int a=10,b=20;
	int c=add(10,20); 	//function call
	printf("Addition:%d\n",c);
	getch();
}
int add(int a,int b)	//function body
{
	int c;
	c=a+b;
	return c;
}

output:

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. Pozíció szerint illeszkednek; az első argumentum átadásra kerül az első paraméternek, a második a második paraméternek és így tovább.

Alapértelmezés szerint az argumentumok értékenként kerülnek átadásra, amelyben az adatok másolatát kapja meg a meghívott függvény. A ténylegesen átadott változó nem változik.

A következő programot vesszük figyelembe, amely bemutatja az érték szerint á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 a és b értékei nem változtak meg az add függvénynek, mert csak az értéke került á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.

C nyelven a függvényeken belül deklarált változók lokálisak az adott kódblokkra, és nem lehet rájuk a függvényen kívül hivatkozni. Azonban a függvényeken kívül deklarált változók globálisak és az egész programból elérhetők. A program tetején #define paraméterrel deklarált konstansok az egész programból elérhetők. Tekintsük a következő programot, amely kinyomtatja a globális változó értékét mind a fő, mind a felhasználó által definiált függvényből:

#include <stdio.h>
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 =1348
from user defined function : global =1348

Megbeszéljük a program részleteit:

1. Egy egész számú globális változót deklarálunk, amelynek kezdeti értéke 1348.
2. Deklarálunk é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 bizonyítására, hogy a globális változók bárhol elérhetők a programban.
3. A globális változót a főfüggvényen belül nyomtatjuk ki.
4. Meghívjuk a teszt függvényt, hogy kinyomtassuk a globális változó értékét.

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

Amikor használja globális változók, óvatosan használja őket, mert hibákhoz vezethet, és a programban bárhol megváltozhatnak. Használat előtt inicializálni kell őket.

Statikus változók

A statikus változóknak helyi hatókörük van. A funkcióból való kilépéskor azonban nem semmisülnek meg. Ezért egy statikus változó örökre megőrzi értékét, és a függvény újbóli megadásakor elérhető. A statikus változó deklarálásakor inicializálódik, és szüksége van a static előtagra.

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

#include <stdio.h>
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 megjeleníti:

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

Rekurzív funkciók

Tekintsük egy szám faktoriálisát, amelyet a következőképpen számítunk ki: 6! =6* 5*4*3*2*1.

Ez a számítás a tény * (-1) ismételt kiszámításaként történik, amíg a tény nem egyenlő 1-gyel.

A rekurzív függvény olyan függvény, amely meghívja magát, és egy kilépési feltételt tartalmaz a rekurzív hívások befejezése érdekében. A faktorszám számítása esetén a kilépési feltétel tény, egyenlő 1-gyel. A rekurzió a hívások „halmozásával” működik, amíg a kilépési feltétel igaz.

Például:

#include <stdio.h>
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 */
  else
    return (number * factorial(number - 1));
}

A program megjeleníti:

 The factorial of 6 is 720

Itt megbeszéljük a program részleteit:

1. Deklaráljuk a rekurzív faktoriális függvényünket, amely egy egész paramétert vesz fel, és ennek a paraméternek a faktoriálisát adja vissza. Ez a funkció meghívja magát, és addig csökkenti a számot, amíg el nem éri a kilépést vagy az alapfeltételt. Ha a feltétel igaz, a korábban generált értékeket megszorozzák egymással, és a végső faktoriális értéket adják vissza.
2. Deklarálunk és inicializálunk egy "6" értékű egész változót, majd a faktoriális függvényünk meghívásával kinyomtatjuk a faktoriális értékét.

A rekurzív mechanizmus jobb megértéséhez tekintsük a következő táblázatot, amely a függvény önmagának hívását jelenti az alapesetig vagy a stopig:ping feltétel teljesül, majd ezt követően összegyűjtjük az előző értékeket:

Inline funkciók

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

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

Amikor függvényeket használunk, szükségünk van egy extrára mutató fejjel ugorjon a függvénydefinícióra, és térjen vissza az utasításhoz. Az ilyen mutatófejek szükségességének kiküszöbölése érdekében inline függvényeket használunk.

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

Az inline függvényeket többnyire kis számításokhoz használják. Nem megfelelőek, ha nagy számítástechnikáról van szó.

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

inline function_name ()
{
    //function definition
}

Írjunk 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();
}

output:

Addition: 30

A fenti program bemutatja egy soron belüli függvény használatát két szám összeadásához. Amint látjuk, az inline függvényen belül csak két szám összeadását adtuk vissza anélkül, hogy extra sorokat írtunk volna. A függvényhívás során éppen olyan értékeket adtunk át, amelyeken összeadást kell végrehajtanunk.

GYIK