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 programok 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 felosztják a kódot, és modularizálják a programot a jobb és hatékonyabb eredmények érdekében. Röviden, egy nagyobb program különböző alprogramokra van felosztva, 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:

Könyvtári funkciók
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.

Funkciónyilatkozat
Funkció meghatározása
Funkcióhívás

Funkciónyilatkozat

A függvény deklarációja egy program nevének írását jelenti. Kötelező része a függvények kódbeli használatának. A függvénydeklarációban csak a függvény nevét adjuk meg, amelyet a programunkban változó deklarációként használunk. Nem használhatunk függvényt, hacsak nincs deklarálva egy programban. A függvénydeklarációt „Function prototípus. "

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ásba visszaadott értékfüggvény adattípusa.
A függvény_neve: zárójelek követik
érvek A nevek az adattípus-deklarációikkal együtt opcionálisan zárójelekbe kerülnek.

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);

Íme 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ésben, az argumentumokat érték adja át amelyben az adatok másolatát adjuk a hí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 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.

A C-ben a függvényen belül deklarált változók helyiek az adott kódblokkban, és nem hivatkozhatnak rájuk a függvényen kívül. Az összes függvényen kívül deklarált változók azonban globálisak és a teljes programból elérhetők. A-val deklarált konstansok #definálja egy program tetején a teljes programból elérhetők. A következő programot tekintjük, amely kiírja 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:

Egy egész számú globális változót deklarálunk, amelynek kezdeti értéke 1348.
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.
A globális változót a főfüggvényen belül nyomtatjuk ki.
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:

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.
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.

Tekintsük az alábbi diagramot, hogy jobban megértsük a rekurzív mechanizmust, amely abból áll, hogy a függvény önmagát hívja az alapeset vagy a leállítási feltétel eléréséig, 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();
}