În limbajul C, funcțiile care primesc alte funcții ca parametri sunt cunoscute ca funcții de ordin superior. Acestea sunt utilizate frecvent pentru a realiza operații mai abstracte și pentru a evita duplicarea codului. În acest tutorial, vom explora cum să definim și să utilizăm astfel de funcții.

Concepte de bază

1. Pointeri la funcții: În C, un pointer la funcție este o variabilă care poate conține adresa unei funcții. Acest pointer poate fi folosit pentru a apela funcția.

2. Prototipuri de funcții: Este important să înțelegem cum să declarăm și să utilizăm prototipurile de funcții pentru a lucra cu pointeri la funcții.

Exemplu simplu

Să începem cu un exemplu simplu care utilizează pointeri la funcții. Vom defini o funcție care aplică o altă funcție asupra unui număr.

Definirea funcțiilor

#include <stdio.h>

// Funcție simplă care adaugă 10 la un număr
int add_ten(int num) {
    return num + 10;
}

// Funcție care primește un număr și o funcție ca parametri
int apply_function(int (*func)(int), int num) {
    return func(num);
}

int main() {
    int number = 5;
    int result = apply_function(add_ten, number);
    printf("Result: %d\n", result);
    return 0;
}

1. Definirea funcției add_ten:

int add_ten(int num) {
    return num + 10;
}

Această funcție primește un întreg num și returnează valoarea num + 10.

1. Definirea funcției apply_function:

int apply_function(int (*func)(int), int num) {
    return func(num);
}

Această funcție este mai interesantă. Ea primește două argumente:

• func: un pointer la o funcție care primește un int și returnează un int.

• num: un număr întreg asupra căruia va fi aplicată funcția func.

În interiorul funcției apply_function, func(num) este apelat, ceea ce înseamnă că funcția func este aplicată asupra lui num.

1. Apelarea funcției în main:

int main() {
    int number = 5;
    int result = apply_function(add_ten, number);
    printf("Result: %d\n", result); 
    return 0;
}

În main, definim o variabilă number și o folosim pentru a apela apply_function cu add_ten ca funcție și number ca argument. Rezultatul este apoi printat.

Un exemplu mai complex

Să extindem exemplul pentru a utiliza mai multe funcții și pentru a vedea cum putem aplica diferite funcții asupra unui șir de numere.

Definirea funcțiilor

#include <stdio.h>

int add_ten(int num) {
    return num + 10;
}

int multiply_by_two(int num) {
    return num * 2;
}

void apply_to_array(int (*func)(int), int *array, int size) {
    for (int i = 0; i < size; i++) {
        array[i] = func(array[i]);
    }
}

void print_array(int *array, int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", array[i]);
    }
    printf("\n");
}

int main() {
    int numbers[] = {1, 2, 3, 4, 5};
    int size = sizeof(numbers) / sizeof(numbers[0]);
    printf("Original array: ");
    print_array(numbers, size);

    apply_to_array(add_ten, numbers, size);
    printf("After adding ten: ");
    print_array(numbers, size);

    apply_to_array(multiply_by_two, numbers, size);
    printf("After multiplying by two: ");
    print_array(numbers, size);

    return 0;
}

Explicații detaliate

1. Definirea funcției multiply_by_two:

int multiply_by_two(int num) {
    return num * 2;
}

Această funcție primește un întreg num și returnează valoarea num * 2.

1. Definirea funcției apply_to_array:

void apply_to_array(int (*func)(int), int *array, int size) {
    for (int i = 0; i < size; i++) {
        array[i] = func(array[i]);
    }
}

Această funcție primește trei argumente:

• func: un pointer la o funcție care primește un int și returnează un int.

• array: un pointer la un șir de numere întregi.

• size: dimensiunea șirului.

În interiorul funcției, se parcurge fiecare element al șirului și se aplică funcția func asupra fiecărui element.

1. Definirea funcției print_array:

void print_array(int *array, int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", array[i]);
    }
printf("\n");
}

Această funcție primește un șir de numere întregi și dimensiunea sa, și tipărește fiecare element.

1. Apelarea funcțiilor în main:

int main() {

    int numbers[] = {1, 2, 3, 4, 5};
    int size = sizeof(numbers) / sizeof(numbers[0]);
    printf("Original array: ");
    print_array(numbers, size);

    apply_to_array(add_ten, numbers, size);
    printf("After adding ten: ");

    print_array(numbers, size);
    apply_to_array(multiply_by_two, numbers, size);
    printf("After multiplying by two: ");
    print_array(numbers, size);

    return 0;
}

În main, definim un șir de numere și utilizăm apply_to_array pentru a aplica add_ten și multiply_by_two asupra acestuia. Rezultatele sunt tipărite după fiecare operație.

Concluzie

Utilizarea funcțiilor care primesc alte funcții ca parametri în C poate fi extrem de puternică și flexibilă. Acestea permit crearea de cod modular și reutilizabil, reducând duplicarea și sporind claritatea. Exemplele prezentate ilustrează cum să definiți și să utilizați astfel de funcții pentru a efectua operații abstracte asupra datelor.