Functies Pointers in C Programmeren met voorbeelden

Pointers geven enorm veel mogelijkheden aan 'C'-functies die we beperkt hebben tot het retourneren van één waarde. Met aanwijzerparameters kunnen onze functies nu werkelijke gegevens verwerken in plaats van een kopie van gegevens.
Om de werkelijke waarden van variabelen te wijzigen, geeft de aanroepende instructie adressen door aan aanwijzerparameters in een functie.
In deze tutorial, je zult leren-

Functies Pointers Voorbeeld
Functies met arrayparameters
Functies die een array retourneren
Functiewijzers
Array van functiewijzers
Functies met lege aanwijzers
Functiewijzers als argumenten

Functies Pointers Voorbeeld

Het volgende programma verwisselt bijvoorbeeld twee waarden van twee:

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

Uitvoer:

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

Het programma verwisselt de werkelijke variabelenwaarden omdat de functie ze op adres benadert met behulp van aanwijzers. Hier zullen we het programmaproces bespreken:

We verklaren de functie die verantwoordelijk is voor het omwisselen van de twee variabele waarden, die twee integer-pointers als parameters neemt en elke waarde retourneert wanneer deze wordt aangeroepen.
In de hoofdfunctie declareren en initialiseren we twee integer-variabelen ('m' en 'n'), waarna we hun waarden respectievelijk afdrukken.
We roepen de functie swap() aan door het adres van de twee variabelen als argumenten door te geven met het ampersand-symbool. Daarna printen we de nieuwe verwisselde waarden van variabelen.
Hier definiëren we de inhoud van de functie swap() die twee integer-variabele-adressen als parameters nodig heeft en een tijdelijke integer-variabele declareren die wordt gebruikt als een derde opslagvak om een van de waardevariabelen op te slaan die in de tweede variabele wordt geplaatst.
Bewaar de inhoud van de eerste variabele die wordt aangeduid met 'a' in de tijdelijke variabele.
Sla de tweede variabele op waarnaar b wordt verwezen in de eerste variabele waarnaar wordt verwezen door a.
Werk de tweede variabele (aangeduid met b) bij met de waarde van de eerste variabele die is opgeslagen in de tijdelijke variabele.

Functies met arrayparameters

In C kunnen we geen array op waarde doorgeven aan een functie. Terwijl een arraynaam een aanwijzer (adres) is, geven we dus gewoon een arraynaam door aan een functie, wat betekent dat een aanwijzer naar de array moet worden doorgegeven.

We beschouwen bijvoorbeeld het volgende programma:

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

Uitvoer:

 Total summation is 471

Hier zullen we de programmacode met zijn details uitleggen

We declareren en definiëren de functie add_array() die een arrayadres (pointer) met zijn elementennummer als parameters neemt en de totale geaccumuleerde sommatie van deze elementen retourneert. De aanwijzer wordt gebruikt om de array-elementen te herhalen (met behulp van de p[k]-notatie), en we accumuleren de sommatie in een lokale variabele die wordt geretourneerd na het herhalen van de hele elementarray.
We declareren en initialiseren een integer-array met vijf integer-elementen. We drukken de totale sommatie af door de arraynaam (die als adres fungeert) en de arraygrootte door te geven aan de add_array() functie aangeroepen als argumenten.

Functies die een array retourneren

In C kunnen we een pointer naar een array terugsturen, zoals in het volgende programma:

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

Uitvoer:

En hier zullen we de programmadetails bespreken

We definiëren en declareren een functie die een array-adres retourneert dat een geheel getal bevat en geen argumenten aanneemt.
We declareren een integer-pointer die de volledige array ontvangt die is gebouwd nadat de functie is aangeroepen en we printen de inhoud ervan door de hele array met vijf elementen te herhalen.

Merk op dat een pointer, geen array, is gedefinieerd om het arrayadres op te slaan dat door de functie wordt geretourneerd. Merk ook op dat wanneer een lokale variabele wordt geretourneerd door een functie, we deze als statisch moeten declareren in de functie.

Functiewijzers

Zoals we per definitie weten dat pointers naar een adres op elke geheugenlocatie verwijzen, kunnen ze ook verwijzen naar het begin van uitvoerbare code als functies in het geheugen.
Een pointer naar functie wordt gedeclareerd met de * , de algemene verklaring van de verklaring is:

return_type (*function_name)(arguments)

Je moet onthouden dat de haakjes rond (*function_name) belangrijk zijn, want zonder deze zal de compiler denken dat de functienaam een pointer van return_type retourneert.
Na het definiëren van de functiepointer, moeten we deze toewijzen aan een functie. Het volgende programma declareert bijvoorbeeld een gewone functie, definieert een functieaanwijzer, wijst de functieaanwijzer toe aan de gewone functie en roept daarna de functie aan via de aanwijzer:

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

Uitvoer:

Hi
Hi
Hi

We definiëren en declareren een standaardfunctie die een Hi-tekst k keer afdrukt, aangegeven door de parametertijden wanneer de functie wordt aangeroepen
We definiëren een pointerfunctie (met zijn speciale declaratie) die een integer-parameter nodig heeft en niets teruggeeft.
We initialiseren onze aanwijzerfunctie met de Hi_function, wat betekent dat de aanwijzer naar de Hi_function() wijst.
In plaats van de standaardfunctie die wordt aangeroepen door de functienaam met argumenten te tikken, roepen we alleen de aanwijzerfunctie aan door het getal 3 als argumenten door te geven, en dat is alles!

Houd er rekening mee dat de functienaam verwijst naar het beginadres van de uitvoerbare code, zoals een arraynaam die naar het eerste element ervan verwijst. Daarom zijn instructies zoals function_ptr =&Hi_function en (*funptr)(3) correct.
OPMERKING:Het is niet belangrijk om de adresoperator &en de indirecte operator * in te voeren tijdens de functietoewijzing en functieaanroep.

Array van functiewijzers

Een reeks functieaanwijzers kan een schakel- of if-statementrol spelen bij het nemen van een beslissing, zoals in het volgende programma:

#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

Hier bespreken we de programmadetails:

We declareren en definiëren vier functies die twee integer-argumenten nodig hebben en een integer-waarde retourneren. Deze functies tellen op, trekken af, vermenigvuldigen en delen de twee argumenten met betrekking tot welke functie door de gebruiker wordt aangeroepen.
We declareren 4 gehele getallen om respectievelijk operanden, bewerkingstype en resultaat te verwerken. We declareren ook een array van vier functieaanwijzers. Elke functieaanwijzer van het array-element heeft twee integers-parameters en retourneert een integer-waarde.
We wijzen en initialiseren elk array-element met de functie die al is gedeclareerd. Het derde element dat de derde functieaanwijzer is, zal bijvoorbeeld verwijzen naar de vermenigvuldigingsfunctie.
We zoeken operands en het type bewerking van de gebruiker die met het toetsenbord heeft getypt.
We hebben het juiste array-element (functieaanwijzer) met argumenten aangeroepen en we slaan het resultaat op dat door de juiste functie is gegenereerd.

De instructie int (*ope[4])(int, int); definieert de reeks functiewijzers. Elk array-element moet dezelfde parameters en hetzelfde retourtype hebben.
Het resultaat van de instructie =ope[choice](x, y); voert de juiste functie uit volgens de keuze van de gebruiker. De twee ingevoerde gehele getallen zijn de argumenten die aan de functie worden doorgegeven.

Functies met lege aanwijzers

Void pointers worden gebruikt tijdens functiedeclaraties. We gebruiken een void * return type permits om elk type te retourneren. Als we aannemen dat onze parameters niet veranderen bij het doorgeven aan een functie, declareren we deze als const.
Bijvoorbeeld:

 void * cube (const void *);

Overweeg het volgende programma:

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

Resultaat:

 4 cubed is 64

Hier zullen we de programmadetails bespreken:

We definiëren en declareren een functie die een geheel getal retourneert en een adres van een onveranderlijke variabele neemt zonder een specifiek gegevenstype. We berekenen de kubuswaarde van de inhoudsvariabele (x) die wordt aangeduid door de num-aanwijzer, en aangezien het een lege aanwijzer is, moeten we deze naar een integer gegevenstype typen met behulp van een specifieke notatie (* datatype) aanwijzer, en we retourneren de kubuswaarde.
We declareren de operand en de resultaatvariabele. We initialiseren onze operand ook met de waarde "4".
We roepen de kubusfunctie aan door het operandadres door te geven, en we verwerken de terugkerende waarde in de resultaatvariabele

Functiewijzers als argumenten

Een andere manier om een functieaanwijzer te misbruiken door deze als argument door te geven aan een andere functie die soms "callback-functie" wordt genoemd, omdat de ontvangende functie "het terugroept".
In het stdlib.h-headerbestand, de Quicksort "qsort() De functie ” gebruikt deze techniek, een algoritme dat speciaal is bedoeld om een array te sorteren.

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

void *base :void pointer naar de array.
size_t num :Het nummer van het array-element.
size_t width De grootte van het element.
int (*compare (const void *, const void *) :functieaanwijzer samengesteld uit twee argumenten en retourneert 0 wanneer de argumenten dezelfde waarde hebben, <0 wanneer arg1 vóór arg2 komt en>0 wanneer arg1 na arg2 komt .

Het volgende programma sorteert een array met gehele getallen van klein naar groot met de functie qsort():

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

Resultaat:

 13 14 48 50 52

Hier zullen we de programmadetails bespreken:

We definiëren de vergelijkingsfunctie die bestaat uit twee argumenten en retourneert 0 wanneer de argumenten dezelfde waarde hebben, <0 wanneer arg1 vóór arg2 komt en>0 wanneer arg1 na arg2 komt. De parameters zijn een void pointers-type dat naar de juiste gegevenstype array (geheel getal)
We definiëren en initialiseren een integer array. De grootte van de array wordt opgeslagen in het num variabele en de grootte van elk array-element wordt opgeslagen in de variabele width met behulp van de vooraf gedefinieerde C-operator sizeof().
We noemen de qsort functie en geef de arraynaam, grootte, breedte en vergelijkingsfunctie door die eerder door de gebruiker zijn gedefinieerd om onze array in oplopende volgorde te sorteren.
We drukken de array-elementen af om er zeker van te zijn dat onze array goed is gesorteerd door de hele array te herhalen met de for-lus.

Pointers in C:Wat is Pointer in C-programmering? Soorten Bitsgewijze operators in C:AND, OR, XOR, Shift &Complement

C Taal