Funktionszeiger in der C-Programmierung mit Beispielen

Zeiger geben „C“-Funktionen große Möglichkeiten, die wir darauf beschränken, einen Wert zurückzugeben. Mit Zeigerparametern können unsere Funktionen jetzt tatsächliche Daten statt einer Kopie von Daten verarbeiten.
Um die tatsächlichen Werte von Variablen zu ändern, übergibt die aufrufende Anweisung Adressen an Zeigerparameter in einer Funktion.
Dabei Tutorial, lernen Sie-

• Beispiel für Funktionszeiger
• Funktionen mit Array-Parametern
• Funktionen, die ein Array zurückgeben
• Funktionszeiger
• Array von Funktionszeigern
• Funktionen, die void-Zeiger verwenden
• Funktionszeiger als Argumente

Beispiel für Funktionszeiger

Beispielsweise vertauscht das nächste Programm zwei Werte von zwei:

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

Ausgabe:

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

Das Programm tauscht die eigentlichen Variablenwerte aus, da die Funktion über die Adresse mit Zeigern auf sie zugreift. Hier werden wir den Programmablauf besprechen:

1. Wir deklarieren die für den Austausch der beiden Variablenwerte zuständige Funktion, die zwei Integer-Zeiger als Parameter nimmt und beim Aufruf einen beliebigen Wert zurückgibt.
2. In der main-Funktion deklarieren und initialisieren wir zwei Integer-Variablen (‚m‘ und ‚n‘), dann drucken wir jeweils ihre Werte.
3. Wir rufen die Funktion swap() auf, indem wir die Adresse der beiden Variablen als Argumente mit dem kaufmännischen Und-Symbol übergeben. Danach drucken wir die neuen getauschten Werte der Variablen.
4. Hier definieren wir den Inhalt der Funktion swap(), die zwei Integer-Variablenadressen als Parameter nimmt und eine temporäre Integer-Variable deklariert, die als dritte Speicherbox verwendet wird, um eine der Wertvariablen zu speichern, die in die zweite Variable eingefügt werden.
li>
5. Speichern Sie den Inhalt der ersten Variablen, auf die 'a' zeigt, in der temporären Variablen.
6. Speichern Sie die zweite Variable, auf die b zeigt, in der ersten Variablen, auf die a zeigt.
7. Aktualisiere die zweite Variable (auf die b zeigt) durch den Wert der ersten Variablen, die in der temporären Variablen gespeichert ist.

Funktionen mit Array-Parametern

In C können wir ein Array nicht als Wert an eine Funktion übergeben. Dagegen ist ein Array-Name ein Zeiger (eine Adresse), also übergeben wir einfach einen Array-Namen an eine Funktion, was bedeutet, dass ein Zeiger an das Array übergeben wird.

Als Beispiel betrachten wir das folgende Programm:

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

Ausgabe:

 Total summation is 471

Hier erklären wir den Programmcode mit seinen Details

1. Wir deklarieren und definieren die Funktion add_array(), die eine Array-Adresse (Zeiger) mit ihrer Elementnummer als Parameter nimmt und die gesamte akkumulierte Summe dieser Elemente zurückgibt. Der Zeiger wird verwendet, um die Array-Elemente zu iterieren (unter Verwendung der p[k]-Notation), und wir akkumulieren die Summe in einer lokalen Variablen, die nach Iteration des gesamten Element-Arrays zurückgegeben wird.
2. Wir deklarieren und initialisieren ein Integer-Array mit fünf Integer-Elementen. Wir geben die Gesamtsumme aus, indem wir den Array-Namen (der als Adresse fungiert) und die Array-Größe an add_array() übergeben aufgerufene Funktion als Argumente.

Funktionen, die ein Array zurückgeben

In C können wir einen Zeiger auf ein Array zurückgeben, wie im folgenden Programm:

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

Ausgabe:

1
2
3
4
5

Und hier werden wir die Programmdetails besprechen

1. Wir definieren und deklarieren eine Funktion, die eine Array-Adresse zurückgibt, die einen ganzzahligen Wert enthält und keine Argumente hat.
2. Wir deklarieren einen Integer-Zeiger, der das vollständige Array erhält, das nach dem Aufruf der Funktion erstellt wurde, und wir geben seinen Inhalt aus, indem wir das gesamte Array mit fünf Elementen iterieren.

Beachten Sie, dass ein Zeiger und kein Array definiert ist, um die von der Funktion zurückgegebene Array-Adresse zu speichern. Beachten Sie auch, dass wir eine lokale Variable, die von einer Funktion zurückgegeben wird, in der Funktion als statisch deklarieren müssen.

Funktionszeiger

Da wir per Definition wissen, dass Zeiger auf eine Adresse in einem beliebigen Speicherort zeigen, können sie als Funktionen im Speicher auch auf den Anfang von ausführbarem Code zeigen.
Ein Zeiger auf eine Funktion wird mit dem * deklariert, der allgemeinen Anweisung von seine Deklaration lautet:

return_type (*function_name)(arguments)

Sie müssen bedenken, dass die Klammern um (*Funktionsname) wichtig sind, da der Compiler ohne sie denken wird, dass der Funktionsname einen Zeiger vom Rückgabetyp zurückgibt.
Nachdem Sie den Funktionszeiger definiert haben, müssen wir ihn einer Funktion zuweisen. Beispielsweise deklariert das nächste Programm eine gewöhnliche Funktion, definiert einen Funktionszeiger, weist den Funktionszeiger der gewöhnlichen Funktion zu und ruft danach die Funktion über den Zeiger auf:

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

Ausgabe:

Hi
Hi
Hi

1. Wir definieren und deklarieren eine Standardfunktion, die beim Aufruf der Funktion k-mal einen Hi-Text ausgibt, der durch den Parameter angegeben wird
2. Wir definieren eine Zeigerfunktion (mit ihrer speziellen Deklaration), die einen ganzzahligen Parameter akzeptiert und nichts zurückgibt.
3. Wir initialisieren unsere Zeigerfunktion mit der Hi_function, was bedeutet, dass der Zeiger auf die Hi_function() zeigt.
4. Anstatt die Standardfunktion durch Taping des Funktionsnamens mit Argumenten aufzurufen, rufen wir nur die Zeigerfunktion auf, indem wir die Zahl 3 als Argumente übergeben, und das war's!

Denken Sie daran, dass der Funktionsname auf die Anfangsadresse des ausführbaren Codes zeigt, wie ein Array-Name, der auf sein erstes Element zeigt. Daher sind Anweisungen wie function_ptr =&Hi_function und (*funptr)(3) korrekt.
HINWEIS:Es ist nicht wichtig, den Adressoperator &und den Indirektionsoperator * während der Funktionszuweisung und des Funktionsaufrufs einzufügen.

Array von Funktionszeigern

Ein Array von Funktionszeigern kann die Rolle eines Schalters oder einer if-Anweisung spielen, um eine Entscheidung zu treffen, wie im nächsten Programm:

#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 besprechen wir die Programmdetails:

1. Wir deklarieren und definieren vier Funktionen, die zwei ganzzahlige Argumente annehmen und einen ganzzahligen Wert zurückgeben. Diese Funktionen addieren, subtrahieren, multiplizieren und dividieren die beiden Argumente, welche Funktion vom Benutzer aufgerufen wird.
2. Wir deklarieren 4 Ganzzahlen, um Operanden, Operationstyp bzw. Ergebnis zu handhaben. Außerdem deklarieren wir ein Array aus vier Funktionszeigern. Jeder Funktionszeiger eines Array-Elements nimmt zwei ganzzahlige Parameter und gibt einen ganzzahligen Wert zurück.
3. Wir ordnen und initialisieren jedes Array-Element mit der bereits deklarierten Funktion. Beispielsweise zeigt das dritte Element, das der dritte Funktionszeiger ist, auf die Multiplikationsoperationsfunktion.
4. Wir suchen Operanden und die Art der Operation vom Benutzer, der mit der Tastatur eingegeben wird.
5. Wir haben das entsprechende Array-Element (Funktionszeiger) mit Argumenten aufgerufen und das von der entsprechenden Funktion generierte Ergebnis gespeichert.

Die Anweisung int (*ope[4])(int, int); definiert das Array von Funktionszeigern. Jedes Array-Element muss dieselben Parameter und denselben Rückgabetyp haben.
Die Anweisung result =ope[choice](x, y); Führt die entsprechende Funktion gemäß der vom Benutzer getroffenen Auswahl aus. Die beiden eingegebenen Ganzzahlen sind die Argumente, die an die Funktion übergeben werden.

Funktionen, die void-Zeiger verwenden

Void-Zeiger werden während Funktionsdeklarationen verwendet. Wir verwenden eine void *-Rückgabetypgenehmigung, um jeden Typ zurückzugeben. Wenn wir davon ausgehen, dass sich unsere Parameter bei der Übergabe an eine Funktion nicht ändern, deklarieren wir sie als const.
Zum Beispiel:

 void * cube (const void *);

Betrachten Sie das folgende Programm:

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

Ergebnis:

 4 cubed is 64

Hier werden wir die Programmdetails besprechen:

1. Wir definieren und deklarieren eine Funktion, die einen ganzzahligen Wert zurückgibt und eine Adresse einer unveränderlichen Variablen ohne einen bestimmten Datentyp übernimmt. Wir berechnen den Cube-Wert der Inhaltsvariablen (x), auf die der num-Zeiger zeigt, und da es sich um einen void-Zeiger handelt, müssen wir ihn mit einem Zeiger in einer bestimmten Notation (* Datentyp) in einen ganzzahligen Datentyp umwandeln, und wir kehren zurück der Würfelwert.
2. Wir deklarieren den Operanden und die Ergebnisvariable. Außerdem initialisieren wir unseren Operanden mit dem Wert „4.“
3. Wir rufen die Cube-Funktion auf, indem wir die Operandenadresse übergeben, und behandeln den Rückgabewert in der Ergebnisvariablen

Funktionszeiger als Argumente

Eine andere Möglichkeit, einen Funktionszeiger auszunutzen, indem er als Argument an eine andere Funktion übergeben wird, die manchmal als „Callback-Funktion“ bezeichnet wird, weil die empfangende Funktion „sie zurückruft“. ”-Funktion verwendet diese Technik, die ein Algorithmus zum Sortieren eines Arrays ist.

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

• void *base :void-Zeiger auf das Array.
• size_t num :Die Array-Elementnummer.
• size_t width Die Elementgröße.
• int (*compare (const void *, const void *) :Funktionszeiger, der aus zwei Argumenten besteht und 0 zurückgibt, wenn die Argumente denselben Wert haben, <0, wenn arg1 vor arg2 kommt, und>0, wenn arg1 nach arg2 kommt .

Das folgende Programm sortiert ein Integer-Array mithilfe der Funktion qsort() von einer kleinen zu einer großen Zahl:

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

Ergebnis:

 13 14 48 50 52

Hier werden wir die Programmdetails besprechen:

1. Wir definieren eine Vergleichsfunktion, die aus zwei Argumenten besteht und 0 zurückgibt, wenn die Argumente denselben Wert haben, <0, wenn arg1 vor arg2 kommt, und>0, wenn arg1 nach arg2 kommt Array-Datentyp (Integer)
2. Wir definieren und initialisieren ein Integer-Array. Die Array-Größe wird in num gespeichert Variable und die Größe jedes Array-Elements wird in der Breitenvariable mit dem vordefinierten C-Operator sizeof() gespeichert.
3. Wir nennen das qsort Funktion und übergeben Sie den Array-Namen, die Größe, die Breite und die Vergleichsfunktion, die zuvor vom Benutzer definiert wurden, um unser Array in aufsteigender Reihenfolge zu sortieren. Der Vergleich wird durchgeführt, indem in jeder Iteration zwei Array-Elemente genommen werden, bis das gesamte Array sortiert ist.
4. Wir geben die Array-Elemente aus, um sicherzustellen, dass unser Array gut sortiert ist, indem wir das gesamte Array mit einer for-Schleife durchlaufen.