Funktioner i C-programmering med exempel: Rekursiv & Inline

Vad är en funktion i C?

Funktion i C-programmering är ett återanvändbart kodblock som gör ett program lättare att förstå, testa och enkelt kan modifieras utan att ändra det anropande programmet. Funktioner delar upp koden och modulariserar programmet för bättre och effektivare resultat. Kort sagt är ett större program uppdelat i olika delprogram som anropas som funktioner.

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 namnet 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, likt en variabeldeklaration. Vi kan inte använda en funktion om den inte deklareras i ett program. En funktionsdeklaration kallas också för "funktionsprototyp".

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

return_data_type function_name (data_type arguments);

• return_data_type: är datatypen för värdefunktionen som returneras tillbaka till den anropande programsatsen.
• Funktionsnamnet: följs av parenteser
• Argumentnamn med deras datatypdeklarationer placeras valfritt inom parenteser.

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 den kompletta 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 skickas argumenten efter värdet där en kopia av data ges till den anropade funktionen. Den faktiskt skickade 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 däremot globala och tillgängliga från hela programmet. Konstanter som deklareras med ett #define högst upp 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ändardefinierade funktioner:

#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 anropa funktionen tills basfallet eller stoppet nås.ping villkoret är uppnått, och därefter 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.

Vanliga frågor