Funktioner Pointere i C-programmering med eksempler

Pointere giver store muligheder for 'C'-funktioner, som vi er begrænset til at returnere én værdi. Med pointerparametre kan vores funktioner nu behandle faktiske data i stedet for en kopi af data.

For at ændre de faktiske værdier af variabler, sender den kaldende sætning adresser til pointerparametre i en funktion.

Funktioner Pointers Eksempel

For eksempel bytter det næste program to værdier af 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;}
}

Output:

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

Programmet bytter de faktiske variable værdier, fordi funktionen tilgår dem ved at bruge adresse pointer. Her vil vi diskutere programprocessen:

1. Vi erklærer funktionen, der er ansvarlig for at bytte de to variable værdier, som tager to heltal pointere som parametre og returnerer enhver værdi, når den kaldes.
2. I hovedfunktionen erklærer og initialiserer vi to heltalsvariabler ('m' og 'n'), og derefter udskriver vi deres værdier.
3. Vi kalder swap()-funktionen ved at sende adressen på de to variable som argumenter ved hjælp af og-tegnet. Derefter udskriver vi de nye ombyttede værdier af variabler.
4. Her definerer vi swap()-funktionens indhold, som tager to heltalsvariableadresser som parametre og erklærer en midlertidig heltalsvariabel brugt som en tredje lagerboks for at gemme en af ​​værdivariablerne, som vil blive sat til den anden variabel.
5. Gem indholdet af den første variabel peget med 'a' i den midlertidige variabel.
6. Gem den anden variabel, der peges af b, i den første variabel, der peges af a.
7. Opdater den anden variabel (peget med b) med værdien af ​​den første variabel gemt i den midlertidige variabel.

Funktioner med array-parametre

I C kan vi ikke videregive en matrix efter værdi til en funktion. Hvorimod et arraynavn er en pointer (adresse), så vi sender bare et arraynavn til en funktion, som betyder at sende en pointer 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);}

Output:

 Total summation is 471

Her vil vi forklare programkoden med dens detaljer

1. Vi erklærer og definerer add_array() funktion, som tager en array-adresse(pointer) med dens elementnummer som parametre og returnerer den samlede akkumulerede summering af disse elementer. Pointeren bruges til at iterere array-elementerne (ved hjælp af p[k]-notationen), og vi akkumulerer summeringen i en lokal variabel, som vil blive returneret efter iteration af hele element-arrayet.
2. Vi erklærer og initialiserer et heltalsarray med fem heltalselementer. Vi udskriver den samlede summering ved at sende matrixnavnet (som fungerer som adresse) og matrixstørrelsen til add_array()kaldet funktion som argumenter.

Funktioner, der returnerer et array

I C kan vi returnere en pointer til et array, som i følgende program:

#include <stdio.h>
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);}

Output:

1
2
3
4
5

Og her vil vi diskutere programdetaljerne

1. Vi definerer og erklærer en funktion, som returnerer en matrixadresse, der indeholder en heltalsværdi, og som ikke tog nogen argumenter.
2. Vi erklærer en heltalsmarkør, som modtager det komplette array, der er bygget efter funktionen kaldes, og vi udskriver dets indhold ved at iterere hele arrayet med fem elementer.

Bemærk, at en pointer, ikke et array, er defineret til at gemme arrayadressen, der returneres af funktionen. Bemærk også, at når en lokal variabel returneres fra en funktion, skal vi erklære den som statisk i funktionen.

Funktionsvisere

Som vi per definition ved, at pointere peger på en adresse i enhver hukommelsesplacering, kan de også pege på i begyndelsen af ​​eksekverbar kode som funktioner i hukommelsen.
En pointer til funktion erklæres med *, den generelle erklæring i dens erklæring er:

return_type (*function_name)(arguments)

Du skal huske, at parenteserne omkring (*funktionsnavn) er vigtige, for uden dem vil compileren tro, at funktionsnavnet returnerer en pointer af returtype.
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 <stdio.h>
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");}

Output:

Hi
Hi
Hi

1. Vi definerer og erklærer en standardfunktion, som udskriver en Hi-tekst k gange angivet med parameteren gange, når funktionen kaldes
2. Vi definerer en pointerfunktion (med dens specielle erklæring), som tager en heltalsparameter og ikke returnerer noget.
3. Vi initialiserer vores pointerfunktion med Hi_function, hvilket betyder at pointer peger på Hi_function().
4. I stedet for at standardfunktionen kalder ved at tape funktionsnavnet med argumenter, kalder vi kun markørfunktionen ved at sende tallet 3 som argumenter, og det er det!

Husk, at funktionsnavnet peger på startadressen for den eksekverbare kode som et arraynavn, der peger på dets 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 indirektionsoperatøren * under funktionstildelingen og funktionskaldet.

Array af funktionspointere

En række funktionspointere kan spille en switch eller en if-sætningsrolle for at træffe en beslutning, som i det næste program:

#include <stdio.h>
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 48
Enter 0 to sum, 1 to subtract, 2 to multiply, or 3 to divide: 2
624

Her diskuterer vi programdetaljerne:

1. Vi erklærer og definerer fire funktioner som tager to heltalsargumenter og returnerer en heltalsværdi. Disse funktioner adderer, subtraherer, multiplicerer og dividerer de to argumenter vedrørende hvilken funktion der kaldes af brugeren.
2. 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 af array-element tager to heltalsparametre og returnerer en heltalsværdi.
3. Vi tildeler og initialiserer hvert array-element med den funktion, der allerede er erklæret. For eksempel vil det tredje element, som er den tredje funktionsmarkør, pege på multiplikationsoperationsfunktionen.
4. Vi søger operander og operationstype fra brugeren, der indtastes med tastaturet.
5. Vi kaldte det passende array-element (Function pointer) med argumenter, og vi gemmer resultatet genereret af den relevante funktion.

Instruktionen int (*ope[4])(int, int); definerer rækken af ​​funktionspointere. Hvert array-element skal have samme parametre og returtype.
Udsagnsresultatet = ope[valg](x, y); kører den passende funktion i henhold til brugerens valg. De to indtastede heltal er de argumenter, der sendes til funktionen.

Funktioner Brug af void pointers

Ugyldige pointere bruges under funktionserklæringer. Vi bruger en void * returtype tillader at returnere enhver type. Hvis vi antager, at vores parametre ikke ændrer sig, når de overføres til en funktion, erklærer vi den som const.
For eksempel:

 void * cube (const void *);

Overvej følgende program:

#include <stdio.h>
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 programdetaljerne:

1. Vi definerer og erklærer en funktion, der returnerer en heltalværdi og tager en adresse med en uforanderlig variabel uden en specifik datatype. Vi beregner kubeværdien af ​​indholdsvariablen (x) peget af num-markøren, og da det er en void-pointer, skal vi skrive cast den til en heltalsdatatype ved hjælp af en specifik notation (* datatype) pointer, og vi returnerer terningværdien.
2. Vi erklærer operanden og resultatvariablen. Vi initialiserer også vores operand med værdien "4."
3. Vi kalder kubefunktionen ved at sende operandadressen, og vi håndterer den returnerende værdi i resultatvariablen

Fungerer pointere som argumenter

En anden måde at udnytte en funktionsmarkør på ved at overføre den som et argument til en anden funktion, nogle gange kaldet "tilbagekaldsfunktion", fordi den modtagende funktion "kalder den tilbage."
I stdlib.h header-filen bruger Quicksort "qsort()"-funktionen denne teknik, som er en algoritme dedikeret til at sortere et array.

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

• void *base: void pointer til arrayet.
• size_t num : Array-elementnummeret.
• size_t width Elementstørrelsen.
• int (*compare (const void *, const void *): funktionsmarkør sammensat af to argumenter og returnerer 0, når argumenterne har samme værdi, <0, når arg1 kommer før arg2, og >0, når arg1 kommer efter arg2.

Følgende program sorterer et heltalsmatrix fra lille til stort tal ved hjælp af qsort()-funktionen:

#include <stdio.h>
#include <stdlib.h>
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 programdetaljerne:

1. Vi definerer en sammenligningsfunktion sammensat af to argumenter og returnerer 0, når argumenterne har samme værdi, <0, når arg1 kommer før arg2, og >0, når arg1 kommer efter arg2. (heltal)
2. Vi definerer og initialiserer et heltalsarray Matrixstørrelsen er gemt i num variabel og størrelsen af ​​hvert array-element gemmes i breddevariabel ved hjælp af sizeof() foruddefineret C operatør.
3. Vi kalder qsort funktion og videregive arraynavnet, størrelsen, bredden og sammenligningsfunktionen defineret tidligere af brugeren for at sortere vores array i stigende rækkefølge. Sammenligningen udføres ved at tage to array-elementer i hver iteration, indtil hele arrayet er sorteret.
4. Vi udskriver array-elementerne for at være sikre på, at vores array er godt sorteret ved at iterere hele arrayet vha. til løkke.