Funktioner Pekare i C-programmering med exempel

Pekare ger stora möjligheter till "C" -funktioner som vi är begränsade till att returnera ett värde. Med pekparametrar kan våra funktioner nu bearbeta faktiska data snarare än en kopia av data.

För att modifiera de faktiska värdena på variabler skickar anropssatsen adresser till pekparametrar i en funktion.

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

Funktioner Pekare Exempel
Funktioner med arrayparametrar
Funktioner som returnerar en matris
Funktionspekare
Array of Function Pointers
Funktioner som använder ogiltiga pekare
Funktionspekare som argument

Funktioner Pekare Exempel

Till exempel byter nästa program två värden på två:

void swap (int *a, int *b);int main() {int m = 25;int n = 100;printf("m is %d, n is %d\n", m, n);swap(&m, &n);printf("m is %d, n is %d\n", m, n);return 0;}void swap (int *a, int *b) {int temp;temp = *a;*a = *b;*b = temp;}}

Produktion:

m is 25, n is 100m is 100, n is 25

Programmet byter de faktiska variabelvärdena eftersom funktionen får åtkomst till dem med adress med hjälp av pekare. Här kommer vi att diskutera programprocessen:

Vi förklarar funktionen ansvarig för att byta de två variabla värdena, som tar två helpekare som parametrar och returnerar valfritt värde när det anropas.
I huvudfunktionen deklarerar och initialiserar vi två heltalsvariabler ('m' och 'n') och sedan skriver vi ut deras värden.
Vi kallar swap () -funktionen genom att skicka adressen till de två variablerna som argument med hjälp av ampersand-symbolen. Därefter skriver vi ut de nya bytvärdena för variabler.
Här definierar vi swap () -funktionsinnehållet som tar två heltalvariabeladresser som parametrar och förklarar en tillfällig heltalvariabel som används som en tredje lagringsruta för att spara en av de värdevariabler som kommer att läggas till den andra variabeln.
Spara innehållet i den första variabeln pekad av 'a' i den temporära variabeln.
Lagra den andra variabeln pekad av b i den första variabeln pekad av a.
Uppdatera den andra variabeln (pekad av b) med värdet på den första variabeln som sparats i den temporära variabeln.

Funktioner med arrayparametrar

I C kan vi inte skicka en matris efter värde till en funktion. Medan ett arraynamn är en pekare (adress), så skickar vi bara ett arraynamn till en funktion som betyder att skicka en pekare till arrayen.

Till exempel anser vi följande program:

int add_array (int *a, int num_elements);int main() {int Tab[5] = {100, 220, 37, 16, 98};printf("Total summation is %d\n", add_array(Tab, 5));return 0;}int add_array (int *p, int size) {int total = 0;int k;for (k = 0; k < size; k++) {total += p[k]; /* it is equivalent to total +=*p ;p++; */}return (total);}

Produktion:

 Total summation is 471

Här kommer vi att förklara programkoden med dess detaljer

Vi deklarerar och definierar add_array () -funktionen som tar en matrisadress (pekare) med dess elementnummer som parametrar och returnerar den totala ackumulerade summeringen av dessa element. Pekaren används för att iterera arrayelementen (med hjälp av p [k] -notationen), och vi ackumulerar summeringen i en lokal variabel som kommer att returneras efter iterering av hela elementmatrisen.
Vi deklarerar och initialiserar ett heltalarray med fem helelement. Vi skriver ut den totala summeringen genom att skicka arraynamnet (som fungerar som adress) och arraystorleken till add_array () -kallningsfunktionen som argument.

Funktioner som returnerar en matris

I C kan vi returnera en pekare till en matris, som i följande program:

#include int * build_array();int main() {int *a;a = build_array(); /* get first 5 even numbers */for (k = 0; k < 5; k++)printf("%d\n", a[k]);return 0;}int * build_array() {static int Tab[5]={1,2,3,4,5};return (Tab);}

Produktion:

Och här kommer vi att diskutera programdetaljerna

Vi definierar och deklarerar en funktion som returnerar en matrisadress som innehåller ett heltal och inte tog några argument.
Vi förklarar en helpekare som tar emot hela arrayen byggd efter att funktionen har anropats och vi skriver ut dess innehåll genom att itera hela fem elementarrayen.

Observera att en pekare, inte en matris, är definierad för att lagra matrisadressen som returneras av funktionen. Lägg också märke till att när en lokal variabel returneras från en funktion måste vi förklara den som statisk i funktionen.

Funktionspekare

Som vi vet per definition att pekare pekar på en adress i vilken minnesplats som helst, kan de också peka på i början av körbar kod som funktioner i minnet.

En pekare att fungera deklareras med *, den allmänna uttalandet för dess deklaration är:

return_type (*function_name)(arguments)

Du måste komma ihåg att parenteserna runt (* funktionsnamn) är viktiga för att utan dem kommer kompilatorn att tro att funktionsnamnet returnerar en pekare av retur_typ.

Efter att ha definierat funktionspekaren måste vi tilldela den till en funktion. Till exempel deklarerar nästa program en vanlig funktion, definierar en funktionspekare, tilldelar funktionspekaren till den vanliga funktionen och anropar därefter funktionen genom pekaren:

#include void Hi_function (int times); /* function */int main() {void (*function_ptr)(int); /* function pointer Declaration */function_ptr = Hi_function; /* pointer assignment */function_ptr (3); /* function call */return 0;}void Hi_function (int times) {int k;for (k = 0; k < times; k++) printf("Hi\n");}

Produktion:

HiHiHi

Vi definierar och deklarerar en standardfunktion som skriver ut en högtext k gånger som indikeras av parametertiderna när funktionen anropas
Vi definierar en pekarfunktion (med dess speciella deklaration) som tar en heltalsparameter och inte returnerar någonting.
Vi initialiserar vår pekarfunktion med Hi_function vilket betyder att pekaren pekar på Hi_function ().
I stället för att standardfunktionen ringer genom att knacka på funktionsnamnet med argument, kallar vi bara pekarfunktionen genom att skicka nummer 3 som argument, och det är det!

Tänk på att funktionsnamnet pekar på startadressen för den körbara koden som ett arraynamn som pekar på dess första element. Därför är instruktioner som function_ptr = & Hi_function och (* funptr) (3) korrekta.

OBS! Det är inte viktigt att infoga adressoperatören & och indirektionsoperatören * under funktionstilldelningen och funktionssamtalet.

Array of Function Pointers

En rad funktionspekare kan spela en switch eller en if-satsningsroll för att fatta ett beslut, som i nästa program:

#include int sum(int num1, int num2);int sub(int num1, int num2);int mult(int num1, int num2);int div(int num1, int num2);int main(){ int x, y, choice, result;int (*ope[4])(int, int);ope[0] = sum;ope[1] = sub;ope[2] = mult;ope[3] = div;printf("Enter two integer numbers: ");scanf("%d%d", &x, &y);printf("Enter 0 to sum, 1 to subtract, 2 to multiply, or 3 to divide: ");scanf("%d", &choice);result = ope[choice](x, y);printf("%d", result);return 0;}int sum(int x, int y) {return(x + y);}int sub(int x, int y) {return(x - y);}int mult(int x, int y) {return(x * y);}int div(int x, int y) {if (y != 0) return (x / y); else return 0;}

Enter two integer numbers: 13 48Enter 0 to sum, 1 to subtract, 2 to multiply, or 3 to divide: 2624

Här diskuterar vi programdetaljerna:

Vi deklarerar och definierar fyra funktioner som tar två heltalargument och returnerar ett heltalsvärde. Dessa funktioner lägger till, subtraherar, multiplicerar och delar de två argumenten angående vilken funktion som anropas av användaren.
Vi förklarar fyra heltal för att hantera operander, operationstyp respektive resultat. Vi förklarar också en matris med fyra funktionspekare. Varje funktionspekare i arrayelementet tar två heltalsparametrar och returnerar ett heltalsvärde.
Vi tilldelar och initialiserar varje arrayelement med den redan deklarerade funktionen. Till exempel kommer det tredje elementet som är den tredje funktionspekaren att peka på multiplikationsoperationsfunktionen.
Vi söker operander och typ av operation från användaren som skrivs med tangentbordet.
Vi anropade lämpligt arrayelement (funktionspekare) med argument och vi lagrar resultatet som genereras av lämplig funktion.

Instruktionen int (* ope [4]) (int, int); definierar matrisen med funktionspekare. Varje arrayelement måste ha samma parametrar och returtyp.

Uttalningsresultatet = ope [val] (x, y); kör lämplig funktion enligt användarens val. De två angivna heltalen är argumenten som skickas till funktionen.

Funktioner som använder ogiltiga pekare

Annulleringspekare används under funktionsdeklarationer. Vi använder ett ogiltigt * returtillstånd för att returnera alla typer. Om vi antar att våra parametrar inte ändras när vi övergår till en funktion, förklarar vi det som konst.

Till exempel:

 void * cube (const void *);

Tänk på följande program:

#include void* cube (const void* num);int main() {int x, cube_int;x = 4;cube_int = cube (&x);printf("%d cubed is %d\n", x, cube_int);return 0;}void* cube (const void *num) {int result;result = (*(int *)num) * (*(int *)num) * (*(int *)num);return result;}

Resultat:

 4 cubed is 64

Här kommer vi att diskutera programdetaljerna:

Vi definierar och deklarerar en funktion som returnerar ett heltal och tar en adress till oföränderlig variabel utan en specifik datatyp. Vi beräknar kubvärdet för innehållsvariabeln (x) som pekas av num-pekaren, och eftersom det är en tomrumspekare måste vi skriva kasta den till en heltal datatyp med en specifik notation (* datatyp) -pekare, och vi returnerar kubvärdet.
Vi deklarerar operand och resultatvariabel. Vi initialiserar också vår operand med värdet "4."
Vi kallar kubfunktionen genom att skicka operandadressen och hanterar returvärdet i resultatvariabeln

Funktionspekare som argument

Ett annat sätt att utnyttja en funktionspekare genom att skicka den som ett argument till en annan funktion som ibland kallas "återuppringningsfunktion" eftersom den mottagande funktionen "ringer tillbaka den."

I stdlib.h-huvudfilen använder Quicksort "qsort ()" -funktionen denna teknik som är en algoritm som är avsedd för att sortera en matris.

void qsort(void *base, size_t num, size_t width, int (*compare)(const void *, const void *))

void * base: ogiltig pekare till matrisen.
size_t num: Arrayelementets nummer.
storlek_t bredd Elementets storlek.
int (* jämför (const void *, const void *): funktionspekare sammansatt av två argument och returnerar 0 när argumenten har samma värde, <0 när arg1 kommer före arg2 och> 0 när arg1 kommer efter arg2.

Följande program sorterar ett heltal-array från litet till stort tal med funktionen qsort ():

#include #include int compare (const void *, const void *);int main() {int arr[5] = {52, 14, 50, 48, 13};int num, width, i;num = sizeof(arr)/sizeof(arr[0]);width = sizeof(arr[0]);qsort((void *)arr, num, width, compare);for (i = 0; i < 5; i++)printf("%d ", arr[ i ]);return 0;}int compare (const void *elem1, const void *elem2) {if ((*(int *)elem1) == (*(int *)elem2)) return 0;else if ((*(int *)elem1) < (*(int *)elem2)) return -1;else return 1;}

Resultat:

 13 14 48 50 52

Här kommer vi att diskutera programdetaljerna:

Vi definierar jämförfunktionen som består av två argument och returnerar 0 när argumenten har samma värde, <0 när arg1 kommer före arg2, och> 0 när arg1 kommer efter arg2. (heltal)
Vi definierar och initierar en heltalmatris Matrisstorleken lagras i numvariabeln och storleken på varje matriselement lagras i breddvariabel med hjälp av sizeof () fördefinierad C-operator.
Vi kallar qsort- funktionen och skickar arraynamn , storlek, bredd och jämförelsesfunktion som tidigare definierats av användaren för att sortera vår array i stigande ordning. Jämförelsen kommer att utföras genom att ta i varje iteration två array-element tills hela arrayen kommer att sorteras.
Vi skriver ut arrayelementen för att vara säkra på att vår array är väl sorterad genom att itera hela arrayen med hjälp av for loop.