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 samtalsprogrammet. Funktioner delar upp koden och modulerar programmet för bättre och effektiva resultat. Kort sagt, ett större program är uppdelat i olika underprogram som kallas som funktioner

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

I den här handledningen lär du dig-

Library Vs. Användardefinierade funktioner
Funktionsdeklaration
Funktionsdefinition
Funktionssamtal
Funktionsargument
Variabelt omfång
Statiska variabler
Rekursiva funktioner
Inline-funktioner

Library Vs. Användardefinierade funktioner

Varje C-program har minst en funktion som är huvudfunktionen, men ett program kan ha valfritt antal funktioner. Huvudfunktionen () i C är en startpunkt för ett program.

I 'C' programmering är funktionerna uppdelade i två typer:

Biblioteksfunktioner
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. Det finns redan i rubrikfilen som vi alltid inkluderar i början av ett program. Du behöver bara skriva 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 kroppsdel av en funktion och anropa funktionen när vi behöver funktionen för att 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 uppdelade i tre aktiviteter som,

Funktionsdeklaration
Funktionsdefinition
Funktionssamtal

Funktionsdeklaration

Funktionsdeklaration betyder att man skriver ett programnamn. 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 funktion förklaring kallas också "Function prototyp ."

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

return_data_type function_name (data_type arguments);

Den return_data_type : är datatyp värdet funktionen återvände tillbaka till den uppringande uttalande.
Den function_name : följs av parenteser
Argumentnamn med deras datatypsdeklarationer placeras valfritt inom parentes.

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

#include /*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 tom.

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

Funktionsdefinition

Funktionsdefinition betyder bara att skriva en funktions kropp. En funktionsdel består av uttalanden som ska utföra en specifik uppgift. En funktionsdel består av en enda eller ett block av uttalanden. 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 betyder att man ringer till en funktion när det krävs i ett program. Närhelst vi kallar en funktion utför den en operation som den designades för. Ett funktionssamtal är en valfri del i ett program.

 result = add(4,5);

Här är den kompletta koden:

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

Produktion:

Addition:30

Funktionsargument

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

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

Vi överväger följande program som visar parametrar som skickas efter 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 ändrades inte eftersom endast dess värde skickades till parametern x.

Variabelt omfång

Variabelt omfång betyder synligheten för variabler inom en programkod.

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

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

Resultat:

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

Vi diskuterar programdetaljerna:

Vi deklarerar en heltal global variabel med 1348 som initialvärde.
Vi deklarerar och definierar en test () -funktion som varken tar argument eller returnerar ett värde. Denna funktion skriver bara ut det globala variabelvärdet för att visa att de globala variablerna kan nås var som helst i programmet.
Vi skriver ut den globala variabeln inom huvudfunktionen.
Vi kallar testfunktionen i orde 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 det kan leda till fel och de kan ändras var som helst i ett program. De bör initieras innan de används.

Statiska variabler

De statiska variablerna har ett lokalt omfång. 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 återinmatas. En statisk variabel initieras när deklareras och behöver prefixet statisk.

Följande program använder en statisk variabel:

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

Programmet visar:

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

Rekursiva funktioner

Tänk på faktorn för ett tal som beräknas enligt följande 6! = 6 * 5 * 4 * 3 * 2 * 1.

Denna beräkning görs som upprepade beräkningar av fakta * (fakta -1) tills faktum är lika med 1.

En rekursiv funktion är en funktion som anropar sig själv och inkluderar ett utgångsförhållande för att avsluta de rekursiva samtalen. När det gäller faktornummerberäkningen är utgångsbetingelsen faktiskt lika med 1. Rekursion fungerar genom att "stapla" samtal tills det utgående villkoret är sant.

Till exempel:

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

Programmet visar:

 The factorial of 6 is 720

Här diskuterar vi programdetaljer:

Vi deklarerar vår rekursiva faktorfunktion som tar ett heltalsparameter och returnerar faktorn för denna parameter. Den här funktionen kallar sig själv och minskar antalet tills det utgående, eller basförhållandet nås. När villkoret är sant multipliceras de tidigare genererade värdena med varandra och det slutliga faktorvärdet returneras.
Vi deklarerar och initialiserar en heltalsvariabel med värdet "6" och skriver sedan ut sitt faktorvärde genom att anropa vår faktorfunktion.

Tänk på följande diagram för att mer förstå den rekursiva mekanismen som består av att kalla funktionen själv tills basfallet eller stopptillståndet har uppnåtts, och efter det samlar vi in tidigare värden:

Inline-funktioner

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

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

När vi använder funktioner behöver vi ett extra pekhuvud för att hoppa till funktionsdefinitionen och återgå till uttalandet. För att eliminera behovet av sådana pekhuvuden använder vi inline-funktioner.

I en inline-funktion ersätts ett funktionsanrop direkt med en faktisk programkod. Det hoppar inte till något block eftersom alla operationer utförs inuti 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 ligger framför 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

Ovanstående program visar användningen av en inline-funktion för att lägga till två nummer. Som vi kan se har vi returnerat tillägget på två siffror inom inline-funktionen bara utan att skriva några extra rader. Under funktionssamtalet har vi precis skickat värden som vi måste utföra tillägg på.

Sammanfattning

En funktion är ett miniprogram eller ett underprogram.
Funktioner används för att modulera programmet.
Bibliotek och användardefinierade är två typer av funktioner.
En funktion består av en deklaration, funktionsdel och en funktionsanropsdel.
Funktionsdeklaration och organ är obligatoriska.
Ett funktionssamtal kan vara valfritt i ett program.
C-programmet har minst en funktion; det är huvudfunktionen ().
Varje funktion har ett namn, datatyp för returvärdet eller ett tomrum, 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ärde ingen efter adress.
Det variabla omfånget kallas synligheten för variabler i ett program
Det finns globala och lokala variabler i C-programmering