Funktioner i C-programmering med exempel: Rekursiv & Inline

När du delar upp ett stort program i olika funktioner blir det enkelt att hantera varje funktion individuellt. Närhelst ett fel uppstår i programmet kan du enkelt undersöka felaktiga funktioner och korrigera endast dessa fel. Du kan enkelt ringa och använda funktioner närhelst de behövs, vilket automatiskt leder till att du sparar tid och utrymme.

Bibliotek vs. Användardefinierade funktioner

Varje 'C'-program har minst en funktion som är huvudfunktionen, men ett program kan ha hur många funktioner som helst. Huvudfunktionen () i C är en startpunkt för ett program.

I 'C'-programmering är funktioner indelade i två typer:

1. Bibliotekets funktioner
2. Användardefinierade funktioner

Skillnaden mellan biblioteket och användardefinierade funktioner i C är att vi inte behöver skriva en kod för en biblioteksfunktion. Den finns redan i rubrikfilen som vi alltid inkluderar i början av ett program. Du behöver bara skriva in namnet på en funktion och använda den tillsammans med rätt syntax. Printf, scanf är exempel på en biblioteksfunktion.

Medan en användardefinierad funktion är en typ av funktion där vi måste skriva en funktionskropp och anropa funktionen när vi kräver att funktionen ska utföra någon operation i vårt program.

En användardefinierad funktion i C skrivs alltid av användaren, men senare kan den vara en del av 'C'-biblioteket. Det är en stor fördel med "C"-programmering.

C programmeringsfunktioner är indelade i tre aktiviteter som,

1. Funktionsdeklaration
2. Funktionsdefinition
3. Funktionssamtal

Funktionsdeklaration

Funktionsdeklaration innebär att skriva ett namn på ett program. Det är en obligatorisk del för att använda funktioner i kod. I en funktionsdeklaration anger vi bara namnet på en funktion som vi ska använda i vårt program som en variabeldeklaration. Vi kan inte använda en funktion om den inte deklareras i ett program. En funktionsdeklaration kallas även "Funktion Prototypen. "

Funktionsdeklarationerna (kallad prototyp) görs vanligtvis ovanför huvudfunktionen () och har den allmänna formen:

return_data_type function_name (data_type arguments);

• Smakämnen return_data_type: är datatypen för värdefunktionen som returneras till den anropande satsen.
• Smakämnen funktionsnamn: följs av parentes
• Argument namn med deras datatypdeklarationer placeras valfritt inom parentes.

Vi betraktar följande program som visar hur man deklarerar en kubfunktion för att beräkna kubvärdet för en heltalsvariabel

#include <stdio.h>
/*Function declaration*/
int add(int a,b);
/*End of Function declaration*/
int main() {

Tänk på att en funktion inte nödvändigtvis returnerar ett värde. I det här fallet används nyckelordet void.

Till exempel indikerar funktionsdeklarationen output_message att funktionen inte returnerar ett värde: void output_message();

Funktionsdefinition

Funktionsdefinition betyder att bara skriva en funktions brödtext. En funktionskropp består av uttalanden som ska utföra en specifik uppgift. En funktionskropp består av en enda eller ett block av satser. Det är också en obligatorisk del av en funktion.

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

Funktionssamtal

Ett funktionsanrop innebär att anropa en funktion närhelst det behövs i ett program. När vi anropar en funktion utför den en operation som den är designad för. Ett funktionsanrop är en valfri del av ett program.

  result = add(4,5);

Här är hela koden:

#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;
}

Produktion:

Addition:30

Funktionsargument

En funktions argument används för att ta emot de nödvändiga värdena av funktionsanropet. De matchas efter position; det första argumentet skickas till den första parametern, det andra till den andra parametern och så vidare.

Som standard argumenten skickas av värde där en kopia av data ges till den anropade funktionen. Den faktiskt godkända variabeln kommer inte att ändras.

Vi överväger följande program som visar parametrar som skickas av värde:

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

Programutgången är:

5 + 10 = 15

Tänk på att värdena för a och b skickades för att lägga till funktion inte ändrades eftersom endast dess värde skickades till parametern x.

Variabelt omfång

Variabelt omfattning betyder synligheten av variabler i en kod i programmet.

I C är variabler som deklareras inuti en funktion lokala för det kodblocket och kan inte refereras till utanför funktionen. Variabler som deklareras utanför alla funktioner är dock globala och tillgängliga från hela programmet. Konstanter deklarerade med en #definiera överst i ett program är tillgängliga från hela programmet. Vi betraktar följande program som skriver ut värdet på den globala variabeln från både huvud- och användardefinierad funktion:

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

Resultat:

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

Vi diskuterar programdetaljerna:

1. Vi deklarerar en global heltalsvariabel med 1348 som initialvärde.
2. Vi deklarerar och definierar en test()-funktion som varken tar argument eller returnerar ett värde. Den här funktionen skriver bara ut det globala variabelvärdet för att visa att de globala variablerna kan nås var som helst i programmet.
3. Vi skriver ut den globala variabeln inom huvudfunktionen.
4. Vi anropar testfunktionen för att skriva ut det globala variabelvärdet.

I C, när argument skickas till funktionsparametrar, fungerar parametrarna som lokala variabler som kommer att förstöras när funktionen avslutas.

När du använder globala variabler, använd dem med försiktighet eftersom de kan leda till fel och de kan ändras var som helst i ett program. De bör initieras före användning.

Statiska variabler

De statiska variablerna har en lokal räckvidd. De förstörs dock inte när funktionen avslutas. Därför behåller en statisk variabel sitt värde för alltid och kan nås när funktionen återinförs. En statisk variabel initieras när den deklareras och behöver prefixet static.

Följande program använder en statisk variabel:

#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 ++; }

Programmet visar:

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

Rekursiva funktioner

Betrakta faktorialen för ett tal som beräknas enligt följande 6! =6* 5 * 4 * 3 * 2 * 1.

Denna beräkning görs som att upprepade gånger beräkna fakta * (faktum -1) tills faktum är lika med 1.

En rekursiv funktion är en funktion som anropar sig själv och inkluderar ett utgångsvillkor för att avsluta de rekursiva anropen. I fallet med beräkningen av faktornummer är utgångsvillkoret faktum lika med 1. Rekursion fungerar genom att "stapla" anrop tills utgångsvillkoret är sant.

Till exempel:

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

Programmet visar:

 The factorial of 6 is 720

Här diskuterar vi programdetaljer:

1. Vi deklarerar vår rekursiva faktorialfunktion som tar en heltalsparameter och returnerar faktorialen för denna parameter. Denna funktion anropar sig själv och minskar numret tills utgången eller basvillkoret uppnås. När villkoret är sant kommer de tidigare genererade värdena att multipliceras med varandra och det slutliga faktorvärdet returneras.
2. Vi deklarerar och initierar en heltalsvariabel med värdet ”6″ och skriver sedan ut dess faktorvärde genom att anropa vår faktoriella funktion.

Betrakta följande diagram för att bättre förstå den rekursiva mekanismen som består av att kalla funktionen för sig själv tills basfallet eller stopptillståndet uppnås, och efter det samlar vi in ​​de tidigare värdena:

Inline -funktioner

Funktion i C-programmering används för att lagra de mest använda instruktionerna. Den används för att modularisera programmet.

Närhelst en funktion anropas, hoppar instruktionspekaren till funktionsdefinitionen. Efter att ha kört en funktion faller instruktionspekaren tillbaka till satsen varifrån den hoppade till funktionsdefinitionen.

När vi använder funktioner behöver vi en extra pekare gå till funktionsdefinitionen och återgå till satsen. För att eliminera behovet av sådana pekhuvuden använder vi inline-funktioner.

I en inline-funktion ersätts ett funktionsanrop direkt av en faktisk programkod. Den hoppar inte till något block eftersom alla operationer utförs i inline-funktionen.

Inline-funktioner används mest för små beräkningar. De är inte lämpliga när stora datorer är inblandade.

En inline-funktion liknar den normala funktionen förutom att nyckelordet inline är placerat före funktionsnamnet. Inline-funktioner skapas med följande syntax:

inline function_name ()
{
    //function definition
}

Låt oss skriva ett program för att implementera en inline-funktion.

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

Produktion:

Addition: 30

Programmet ovan visar användningen av en inline-funktion för addition av två tal. Som vi kan se har vi endast returnerat tillägget på två siffror inom inline-funktionen utan att skriva några extra rader. Under funktionsanrop har vi precis skickat värden som vi måste göra addition.

Sammanfattning

• En funktion är ett miniprogram eller ett underprogram.
• Funktioner används för att modularisera programmet.
• Bibliotek och användardefinierade är två typer av funktioner.
• En funktion består av en deklaration, funktionskropp och en funktionsanropsdel.
• Funktionsdeklaration och organ är obligatoriska.
• Ett funktionsanrop kan vara valfritt i ett program.
• C-programmet har minst en funktion; det är huvudfunktionen ().
• Varje funktion har ett namn, datatyp av returvärde eller en tomhet, parametrar.
• Varje funktion måste definieras och deklareras i ditt C-program.
• Tänk på att vanliga variabler i en C-funktion förstörs så snart vi avslutar funktionsanropet.
• Argumenten som skickas till en funktion kommer inte att ändras eftersom de skickas med värdet none efter adress.
• Variabelomfattningen kallas synligheten för variabler inom ett program
• Det finns globala och lokala variabler i C-programmering