Funktioner i C-programmering med eksempler: Rekursiv & Inline

Hvad er en funktion i C?

Funktion i C-programmering er en genanvendelig kodeblok, der gør et program lettere at forstå, teste og nemt kan ændres uden at ændre det kaldende program. Funktioner opdeler koden og modulariserer programmet for bedre og mere effektive resultater. Kort sagt er et større program opdelt i forskellige underprogrammer, der kaldes som funktioner.

Når du deler et stort program op i forskellige funktioner, bliver det nemt at styre hver funktion individuelt. Når der opstår en fejl i programmet, kan du nemt undersøge defekte funktioner og kun rette disse fejl. Du kan nemt ringe til og bruge funktioner, når de er påkrævet, hvilket automatisk sparer tid og plads.

Bibliotek vs. Brugerdefinerede funktioner

Hvert 'C'-program har mindst én funktion, som er hovedfunktionen, men et program kan have et hvilket som helst antal funktioner. Hovedfunktionen () i C er udgangspunktet for et program.

I 'C'-programmering er funktioner opdelt i to typer:

1. Bibliotekets funktioner
2. Brugerdefinerede funktioner

Forskellen mellem biblioteket og brugerdefinerede funktioner i C er, at vi ikke behøver at skrive en kode til en biblioteksfunktion. Det er allerede til stede i header-filen, som vi altid inkluderer i begyndelsen af ​​et program. Du skal bare skrive navnet på en funktion og bruge den sammen med den korrekte syntaks. Printf, scanf er eksempler på en biblioteksfunktion.

Hvorimod en brugerdefineret funktion er en type funktion, hvor vi er nødt til at skrive en krop af en funktion og kalde funktionen, når vi kræver, at funktionen udfører en operation i vores program.

En brugerdefineret funktion i C skrives altid af brugeren, men senere kan den være en del af 'C'-biblioteket. Det er en stor fordel ved 'C'-programmering.

C programmeringsfunktioner er opdelt i tre aktiviteter, såsom,

1. Funktionserklæring
2. Funktionsdefinition
3. Funktionsopkald

Funktionserklæring

Funktionsdeklaration betyder at skrive navnet på et program. Det er en obligatorisk del af brugen af ​​funktioner i kode. I en funktionsdeklaration angiver vi blot navnet på en funktion, som vi skal bruge i vores program, ligesom en variabeldeklaration. Vi kan ikke bruge en funktion, medmindre den er deklareret i et program. En funktionsdeklaration kaldes også "funktionsprototype".

Funktionserklæringerne (kaldet prototype) udføres normalt over hovedfunktionen () og har den generelle form:

return_data_type function_name (data_type arguments);

• return_data_type: er datatypen for den værdifunktion, der returneres tilbage til den kaldende sætning.
• Funktionsnavnet: efterfølges af parenteser
• Argumentnavne med deres datatypedeklarationer placeres eventuelt i parenteserne.

Vi betragter følgende program, der viser, hvordan man erklærer en terningfunktion for at beregne terningværdien af ​​en heltalsvariabel

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

Husk, at en funktion ikke nødvendigvis returnerer en værdi. I dette tilfælde bruges søgeordet void.

For eksempel angiver erklæringen output_message funktion, at funktionen ikke returnerer en værdi: void output_message();

Funktionsdefinition

Funktionsdefinition betyder blot at skrive en funktions brødtekst. En krop af en funktion består af udsagn, som skal udføre en bestemt opgave. Et funktionslegeme består af en enkelt eller en blok af udsagn. Det er også en obligatorisk del af en funktion.

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

Funktionsopkald

Et funktionskald betyder at kalde en funktion, når det er påkrævet i et program. Når vi kalder en funktion, udfører den en operation, som den er designet til. Et funktionskald er en valgfri del af et program.

  result = add(4,5);

Her er den komplette kode:

#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

Funktionsargumenter

En funktions argumenter bruges til at modtage de nødvendige værdier ved funktionskaldet. De matches efter position; det første argument sendes til den første parameter, det andet til den anden parameter og så videre.

Som standard sendes argumenterne med den værdi, hvor en kopi af dataene gives til den kaldte funktion. Den faktisk sendte variabel ændres ikke.

Vi betragter følgende program, som demonstrerer parametre, der passeres af værdi:

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

Programmets output er:

5 + 10 = 15

Husk, at værdierne af a og b blev sendt for at tilføje funktion ikke blev ændret, fordi kun dens værdi blev overført til parameteren x.

Variabelt omfang

Variabelt omfang betyder synligheden af ​​variabler i en kode i programmet.

I C er variabler, der er deklareret i en funktion, lokale for den pågældende kodeblok og kan ikke refereres til uden for funktionen. Variabler, der er deklareret uden for alle funktioner, er dog globale og tilgængelige fra hele programmet. Konstanter, der er deklareret med et #define øverst i et program, er tilgængelige fra hele programmet. Vi betragter følgende program, der udskriver værdien af ​​den globale variabel fra både hoved- og brugerdefineret 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 diskuterer programdetaljerne:

1. Vi erklærer en heltals global variabel med 1348 som startværdi.
2. Vi erklærer og definerer en test() funktion, som hverken tager argumenter eller returnerer en værdi. Denne funktion udskriver kun den globale variabelværdi for at demonstrere, at de globale variabler kan tilgås overalt i programmet.
3. Vi udskriver den globale variabel i hovedfunktionen.
4. Vi kalder testfunktionen for at udskrive den globale variabelværdi.

I C, når argumenter sendes til funktionsparametre, fungerer parametrene som lokale variable, som vil blive ødelagt, når funktionen afsluttes.

Når du bruger globale variabler, brug dem med forsigtighed, fordi de kan føre til fejl, og de kan ændres hvor som helst i et program. De skal initialiseres før brug.

Statiske variable

De statiske variable har et lokalt omfang. De ødelægges dog ikke, når funktionen forlades. Derfor bevarer en statisk variabel sin værdi for evigt og kan tilgås, når funktionen genindsættes. En statisk variabel initialiseres, når den erklæres og har brug for præfikset static.

Følgende program bruger 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 viser:

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

Rekursive funktioner

Betragt faktorialen af ​​et tal, der beregnes som følger: 6! = 6 * 5 * 4 * 3 * 2 * 1.

Denne beregning udføres som gentagne gange at beregne fakta * (faktum -1), indtil fakta er lig med 1.

En rekursiv funktion er en funktion, der kalder sig selv og inkluderer en exit-betingelse for at afslutte de rekursive kald. I tilfældet med beregningen af ​​et faktortal er udgangsbetingelsen faktisk lig med 1. Rekursion fungerer ved at "stabling" opkald, indtil udgangsbetingelsen er sand.

For eksempel:

#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 viser:

 The factorial of 6 is 720

Her diskuterer vi programdetaljer:

1. Vi erklærer vores rekursive faktorielle funktion, som tager en heltalsparameter og returnerer denne parameters faktoriale. Denne funktion kalder sig selv og reducerer tallet, indtil udgangen eller basistilstanden er nået. Når betingelsen er sand, vil de tidligere genererede værdier blive ganget med hinanden, og den endelige faktorværdi returneres.
2. Vi erklærer og initialiserer en heltalsvariabel med værdien "6" og udskriver derefter dens faktorielle værdi ved at kalde vores faktorielle funktion.

Overvej følgende diagram for bedre at forstå den rekursive mekanisme, som består i at kalde funktionen for sig selv, indtil basistilfældet eller stoppetping betingelsen er nået, og derefter indsamler vi de foregående værdier:

Inline funktioner

Funktion i C-programmering bruges til at gemme de hyppigst anvendte instruktioner. Det bruges til modularisering af programmet.

Når en funktion kaldes, springer instruktionsmarkøren til funktionsdefinitionen. Efter at have udført en funktion, falder instruktionsmarkøren tilbage til sætningen, hvorfra den hoppede til funktionsdefinitionen.

Når vi bruger funktioner, har vi brug for en ekstra pointer hovedet for at springe til funktionsdefinitionen og vende tilbage til sætningen. For at eliminere behovet for sådanne pointerhoveder bruger vi inline-funktioner.

I en inline-funktion erstattes et funktionskald direkte af en egentlig programkode. Den hopper ikke til nogen blok, fordi alle handlinger udføres inde i inline-funktionen.

Inline-funktioner bruges mest til små beregninger. De er ikke egnede, når der er tale om store databehandlinger.

En inline-funktion ligner den normale funktion, bortset fra at nøgleordet inline er placeret før funktionsnavnet. Inline-funktioner oprettes med følgende syntaks:

inline function_name ()
{
    //function definition
}

Lad os skrive et program til at implementere 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();
}

Output:

Addition: 30

Ovenstående program demonstrerer brugen af ​​en inline-funktion til tilføjelse af to tal. Som vi kan se, har vi kun returneret tilføjelsen på to tal inden for inline-funktionen uden at skrive nogen ekstra linjer. Under funktionskald har vi netop videregivet værdier, som vi skal udføre addition på.

Ofte Stillede Spørgsmål