Funktioner markører i C programmering med eksempler

Markører giver store muligheder for 'C' -funktioner, som vi er begrænset til at returnere en værdi. Med markørparametre kan vores funktioner nu behandle faktiske data i stedet for en kopi af data.

For at modificere de faktiske værdier af variabler sender den kaldende erklæring adresser til markørparametre i en funktion.

I denne vejledning lærer du-

Funktioner Pointer Eksempel
Funktioner med matrixparametre
Funktioner, der returnerer en matrix
Funktionspekere
Array of Function Pointers
Funktioner ved hjælp af ugyldige markører
Funktionsmarkører som argumenter

Funktioner Pointer Eksempel

For eksempel bytter det næste program to værdier på to:

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 bytter de faktiske variabelværdier, fordi funktionen får adgang til dem via adresse ved hjælp af markører. Her vil vi diskutere programprocessen:

Vi erklærer funktionen ansvarlig for at bytte de to variable værdier, som tager to heltalspegere som parametre og returnerer enhver værdi, når den kaldes.
I hovedfunktionen erklærer og initialiserer vi to heltalsvariabler ('m' og 'n'), så udskriver vi henholdsvis deres værdier.
Vi kalder swap-funktionen () ved at videregive adressen til de to variabler som argumenter ved hjælp af ampersand-symbolet. Derefter udskriver vi de nye byttede værdier for variabler.
Her definerer vi swap () -funktionsindholdet, der tager to heltalvariabeladresser som parametre og erklærer en midlertidig heltalsvariabel, der bruges som et tredje lagerfelt for at gemme en af de værdivariabler, der vil blive sat til den anden variabel.
Gem indholdet af den første variabel peget på 'a' i den midlertidige variabel.
Gem den anden variabel med b i den første variabel med a.
Opdater den anden variabel (peget med b) med værdien af den første variabel, der er gemt i den midlertidige variabel.

Funktioner med matrixparametre

I C kan vi ikke videregive en matrix efter værdi til en funktion. Mens et array-navn er en pointer (adresse), så videregiver vi bare et array-navn til en funktion, der betyder at sende en markør til arrayet.

For eksempel overvejer vi følgende 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

Her forklarer vi programkoden med dens detaljer

Vi erklærer og definerer add_array () -funktion, der tager en matrixadresse (markør) med dets elementnummer som parametre og returnerer den samlede akkumulerede summering af disse elementer. Markøren bruges til at gentage arrayelementerne (ved hjælp af p [k] -notationen), og vi akkumulerer summeringen i en lokal variabel, som returneres efter iterering af hele elementarrayet.
Vi erklærer og initialiserer et heltalsarray med fem heltalselementer. Vi udskriver den samlede summering ved at videregive arraynavnet ( som fungerer som adresse) og arraystørrelsen til add_array () kaldet funktion som argumenter.

Funktioner, der returnerer en matrix

I C kan vi returnere en markør til en matrix som i følgende 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:

Og her vil vi diskutere programoplysningerne

Vi definerer og erklærer en funktion, der returnerer en matrixadresse, der indeholder en heltalværdi og ikke tog nogen argumenter.
Vi erklærer et heltalsmarkør, der modtager det komplette array, der er bygget, efter at funktionen kaldes, og vi udskriver dets indhold ved at gentage hele fem-element-arrayet.

Bemærk, at en markør, ikke en matrix, er defineret til at gemme den matrixadresse, der returneres af funktionen. Bemærk også, at når en lokal variabel returneres fra en funktion, er vi nødt til at erklære den som statisk i funktionen.

Funktionspekere

Som vi ved definition ved, at henvisninger peger på en adresse på et hvilket som helst hukommelsessted, kan de også pege på i begyndelsen af den eksekverbare kode som funktioner i hukommelsen.

En markør til funktion erklæres med *, den generelle erklæring for dens erklæring er:

return_type (*function_name)(arguments)

Du skal huske, at parenteserne omkring (* funktionsnavn) er vigtige, fordi uden dem vil compileren tro, at funktionsnavnet returnerer en markør af return_type.

Efter at have defineret funktionsmarkøren skal vi tildele den til en funktion. For eksempel erklærer det næste program en almindelig funktion, definerer en funktionsmarkør, tildeler funktionsmarkøren til den almindelige funktion og kalder derefter funktionen gennem markøren:

#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 definerer og erklærer en standardfunktion, der udskriver en Hej-tekst k gange angivet med parametertiderne, når funktionen kaldes
Vi definerer en pointerfunktion (med dens specielle erklæring), der tager et heltalsparameter og ikke returnerer noget.
Vi initialiserer vores pointerfunktion med Hi_function, hvilket betyder at markøren peger på Hi_function ().
I stedet for at standardfunktionen kalder ved at trykke på funktionsnavnet med argumenter, kalder vi kun markørfunktionen ved at sende nummeret 3 som argumenter, og det er det!

Husk, at funktionsnavnet peger på startadressen for den eksekverbare kode som et arraynavn, der peger på det første element. Derfor er instruktioner som function_ptr = & Hi_function og (* funptr) (3) korrekte.

BEMÆRK: Det er ikke vigtigt at indsætte adresseoperatøren & og indirection-operatøren * under funktionstildeling og funktionsopkald.

Array of Function Pointers

En række funktionsmarkører kan spille en switch eller en if-sætningsrolle til at træffe en beslutning, som i det næste 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

Her diskuterer vi programoplysningerne:

Vi erklærer og definerer fire funktioner, der tager to heltalargumenter og returnerer en heltalværdi. Disse funktioner tilføjer, subtraherer, multiplicerer og deler de to argumenter vedrørende hvilken funktion der kaldes til af brugeren.
Vi erklærer 4 heltal til at håndtere henholdsvis operander, operationstype og resultat. Vi erklærer også en matrix med fire funktionsmarkører. Hver funktionsmarkør i array-element tager to heltalsparametre og returnerer en heltalværdi.
Vi tildeler og initialiserer hvert array-element med den allerede deklarerede funktion. For eksempel vil det tredje element, som er den tredje funktionsmarkør, pege på multiplikationsfunktion.
Vi søger operander og type operation fra den bruger, der er skrevet med tastaturet.
Vi kaldte det relevante matrixelement (funktionsmarkør) med argumenter, og vi gemmer resultatet genereret af den relevante funktion.

Instruktionen int (* ope [4]) (int, int); definerer matrixen med funktionsmarkører. Hvert array-element skal have de samme parametre og returtype.

Erklæringsresultatet = ope [valg] (x, y); kører den passende funktion i henhold til brugerens valg. De to indtastede heltal er argumenterne, der sendes til funktionen.

Funktioner ved hjælp af ugyldige markører

Ugyldige markører bruges under funktionserklæringer. Vi bruger en ugyldig * returtypetilladelse til at returnere enhver type. Hvis vi antager, at vores parametre ikke ændres, når vi går til en funktion, erklærer vi det som konst.

For eksempel:

 void * cube (const void *);

Overvej følgende 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

Her vil vi diskutere programoplysningerne:

Vi definerer og erklærer en funktion, der returnerer en heltalsværdi og tager en adresse på den uforanderlige variabel uden en bestemt datatype. Vi beregner terningsværdien af indholdsvariablen (x), der er peget af num-markøren, og da den er en ugyldig markør, er vi nødt til at skrive kaste den til en heltal datatype ved hjælp af en bestemt notation (* datatype) -markør, og vi vender tilbage terningsværdien.
Vi erklærer operanden og resultatvariablen. Vi initialiserer også vores operand med værdien "4."
Vi kalder kubefunktionen ved at sende operandadressen, og vi håndterer den returnerende værdi i resultatvariablen

Funktionsmarkører som argumenter

En anden måde at udnytte en funktionsmarkør ved at videregive den som et argument til en anden funktion, som undertiden kaldes "tilbagekaldsfunktion", fordi modtagefunktionen "kalder den tilbage."

I stdlib.h-headerfilen bruger Quicksort "qsort ()" -funktionen denne teknik, som er en algoritme dedikeret til at sortere en matrix.

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

void * base: ugyldig markør til arrayet.
size_t num: Matrixelementets nummer.
størrelse_t bredde Elementets størrelse.
int (* sammenlign (const void *, const void *): funktionsmarkør sammensat af to argumenter og returnerer 0, når argumenterne har den samme værdi, <0 når arg1 kommer før arg2, og> 0 når arg1 kommer efter arg2.

Følgende program sorterer et heltal array fra lille til stort tal ved hjælp af 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

Her vil vi diskutere programoplysningerne:

Vi definerer sammenligningsfunktion sammensat af to argumenter og returnerer 0, når argumenterne har den samme værdi, <0 når arg1 kommer før arg2, og> 0 når arg1 kommer efter arg2.Parametrene er en ugyldig pegetype, der er støbt til den relevante matrixdatatype (heltal)
Vi definerer og initialiserer et heltal array Arraystørrelsen er gemt i num variablen, og størrelsen af hvert array element er gemt i bredde variabel ved hjælp af sizeof () foruddefineret C operator.
Vi kalder qsort- funktionen og videregiver arrayets navn, størrelse, bredde og sammenligningsfunktion defineret tidligere af brugeren for at sortere vores array i stigende rækkefølge. Sammenligningen udføres ved at tage hver iteration i to array-elementer indtil hele arrayet vil blive sorteret.
Vi udskriver arrayelementerne for at være sikre på, at vores array er godt sorteret ved at gentage hele arrayet ved hjælp af for loop.