C'de Fonksiyon Göstericileri: Söz Dizimi, Geri Çağrılar ve qsort

Derlenmiş kod da tıpkı veri gibi bellekte yaşar, dolayısıyla bir fonksiyonun bir adresi vardır. Fonksiyon göstericisi, bir tanesini saklayan bir değişkendir - ve bir fonksiyonu saklayabildiğinizde onu argüman olarak geçirebilir, bir tablosunu tutabilir ya da çalışma zamanında aralarında seçim yapabilirsiniz.

Özel sıralama düzeni, olay işleyicileri, eklenti arayüzleri ve durum makinelerinin arkasındaki yetenek budur. Aynı zamanda bir okuyucunun durup gözlerini kısmasına en çok yol açacak C söz dizimi parçasıdır, o yüzden oradan başlıyoruz.

Bildirim Söz Dizimi

Sıradan bir fonksiyon alın:

int add(int a, int b);

Adresini tutabilecek bir gösterici bildirmek için ismi (*isim) ile değiştirin:

int (*op)(int, int);

İçten dışa okuyun: op bir göstericidir, bir fonksiyona, (int, int) alan, int döndüren.

Parantezler süs değildir. Onlar olmadan *, bunun yerine dönüş tipine bağlanır:

int (*f)(int);   // int alıp int döndüren bir fonksiyona gösterici
int *g(int);     // int alıp int* döndüren bir FONKSİYON - tamamen farklı

İşte baştan sona çalışırken:

#include <stdio.h>

int add(int a, int b)      { return a + b; }
int subtract(int a, int b) { return a - b; }
int multiply(int a, int b) { return a * b; }

int main(void) {
    int (*op)(int, int);        // bildir

    op = add;                   // ata (& gerekmez)
    printf("topla:  %d\n", op(10, 3));

    op = subtract;              // baska bir yeri gostersin
    printf("cikar:  %d\n", op(10, 3));

    op = &multiply;             // & gecerlidir ama gereksizdir
    printf("carp:   %d\n", (*op)(10, 3));   // bu cagri bicimi de oyle

    printf("\nfonksiyonun kendisi %p adresinde\n", (void *)(void (*)(void))add);
    return 0;
}

Her iki çağrı biçimi de çalışır, çünkü bir fonksiyon adı otomatik olarak bir göstericiye dönüşür. op(10, 3) yazın; (*op)(10, 3) yazımı bir kalıntıdır.

Son printf hakkında bir not: %p bir nesne göstericisi bekler ve fonksiyon göstericileri biçimsel olarak ayrı bir ailedir, dolayısıyla birini yazdırmak tam anlamıyla taşınabilir değildir. Dönüşüm, hiç çalıştığı platformlarda derleyicileri susturur; birini yazdırmanız nadiren gerekecek.

typedef Onu Okunaklı Kılar

Bildirim söz dizimi hızla çirkinleşir ve typedef standart çaredir:

#include <stdio.h>

typedef int (*BinaryOp)(int, int);   // BinaryOp = int(int,int)'e gosterici

int add(int a, int b)      { return a + b; }
int multiply(int a, int b) { return a * b; }

// artik fonksiyon alan bir fonksiyon, diger bildirimler gibi okunur
int apply(BinaryOp op, int x, int y) {
    return op(x, y);
}

int main(void) {
    BinaryOp op = add;
    printf("apply(add, 4, 5)      = %d\n", apply(op, 4, 5));
    printf("apply(multiply, 4, 5) = %d\n", apply(multiply, 4, 5));
    return 0;
}

int apply(BinaryOp op, int x, int y) ile ham biçimi, int apply(int (*op)(int, int), int x, int y), karşılaştırın. Aynı anlam; birini bir bakışta okuyabiliyorsunuz. Genel kurallar için bkz. typedef.

Geri Çağrılar: Davranışı Çağırana Bırakmak

Geri çağrı, başka bir fonksiyona, doğru anda sizi geri çağırabilsin diye verdiğiniz bir fonksiyondur. Bir kod parçasının işin yapısını halletmesini sağlarken kararı çağıranın vermesine izin verir.

#include <stdio.h>

typedef int (*Predicate)(int);

int is_even(int n)     { return n % 2 == 0; }
int is_positive(int n) { return n > 0; }
int is_big(int n)      { return n > 100; }

// tek fonksiyon, her turlu test
int count_if(const int *arr, int n, Predicate test) {
    int count = 0;
    for (int i = 0; i < n; i++) {
        if (test(arr[i])) {
            count++;
        }
    }
    return count;
}

int main(void) {
    int data[8] = {-4, 3, 120, 7, -9, 200, 0, 15};
    int n = 8;

    printf("cift:    %d\n", count_if(data, n, is_even));
    printf("pozitif: %d\n", count_if(data, n, is_positive));
    printf("buyuk:   %d\n", count_if(data, n, is_big));

    return 0;
}

Fonksiyon göstericileri olmadan count_even, count_positive ve count_big yazardınız - aynı döngünün üç kopyası. Onlarla döngü bir kez yazılır ve test parametre olur.

Asıl Kazanç: qsort

Standart kütüphanenin qsort'u, gerçekten kullanacağınız fonksiyon göstericisi örneğidir. Her şeyden oluşan bir diziyi sıralar ve bunu, elemanlar hakkında boyutlarından ve sizin sağladığınız bir karşılaştırıcıdan başka hiçbir şey bilmeden başarır.

void qsort(void *base, size_t nmemb, size_t size,
           int (*compar)(const void *, const void *));

Karşılaştırıcı iki const void * alır - iki elemanın adresleri - ve birincisi ikinciden önce geliyorsa negatif bir sayı, eşitlerse sıfır, sonra geliyorsa pozitif döndürür.

#include <stdio.h>
#include <stdlib.h>

int compare_ints(const void *a, const void *b) {
    int x = *(const int *)a;      // once gercek tipe donustur, sonra oku
    int y = *(const int *)b;
    if (x < y) return -1;
    if (x > y) return  1;
    return 0;
}

int compare_desc(const void *a, const void *b) {
    return compare_ints(b, a);    // sirayi tersine cevirmek icin argumanlari takas et
}

int main(void) {
    int data[8] = {42, 7, 19, 3, 88, 1, 55, 23};
    int n = sizeof data / sizeof data[0];

    qsort(data, n, sizeof data[0], compare_ints);
    printf("artan:  ");
    for (int i = 0; i < n; i++) printf("%d ", data[i]);

    qsort(data, n, sizeof data[0], compare_desc);
    printf("\nazalan: ");
    for (int i = 0; i < n; i++) printf("%d ", data[i]);
    printf("\n");

    return 0;
}

O karşılaştırıcıdan taşınacak iki alışkanlık. Asla return x - y; yazmayın - zekice görünür ve büyük ya da negatif değerler için taşar, yanlış bir işaret ve yanlış sıralanmış bir dizi üretir. Dereferans etmeden önce dönüştürün, sonra değil: *(const int *)a, çünkü bir void * üzerindeki *a'nın okuyacak bir şeyi yoktur.

Aynı makine, yapıları istediğiniz alana göre sıralar:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    char name[20];
    int  score;
} Player;

int by_score(const void *a, const void *b) {
    const Player *p = a, *q = b;
    return (q->score > p->score) - (q->score < p->score);   // once en yuksek
}

int by_name(const void *a, const void *b) {
    const Player *p = a, *q = b;
    return strcmp(p->name, q->name);
}

int main(void) {
    Player players[4] = {
        {"Ada",   91},
        {"Grace", 78},
        {"Linus", 91},
        {"Ken",   85}
    };
    int n = 4;

    qsort(players, n, sizeof players[0], by_score);
    printf("puana gore:\n");
    for (int i = 0; i < n; i++) printf("  %-6s %d\n", players[i].name, players[i].score);

    qsort(players, n, sizeof players[0], by_name);
    printf("isme gore:\n");
    for (int i = 0; i < n; i++) printf("  %-6s %d\n", players[i].name, players[i].score);

    return 0;
}

(q->score > p->score) - (q->score < p->score) deyimi, çıkarma ve taşma olmadan tam olarak -1, 0 ya da 1 döndürür. Ve strcmp zaten doğru dönüş geleneğine sahiptir, dolayısıyla bir metin karşılaştırıcısı tek satırdır.

Fonksiyon Göstericisi Tabloları

Bir fonksiyon göstericisi dizisi, bir if/else zincirini bir aramaya dönüştürür. Yorumlayıcılar işlem kodlarını böyle dağıtır ve menü sistemleri komutları böyle çalıştırır.

#include <stdio.h>

typedef double (*Operation)(double, double);

double op_add(double a, double b) { return a + b; }
double op_sub(double a, double b) { return a - b; }
double op_mul(double a, double b) { return a * b; }
double op_div(double a, double b) { return b == 0 ? 0.0 : a / b; }

typedef struct {
    char      symbol;
    Operation fn;
    const char *name;
} Entry;

int main(void) {
    Entry table[] = {
        {'+', op_add, "topla"},
        {'-', op_sub, "cikar"},
        {'*', op_mul, "carp"},
        {'/', op_div, "bol"}
    };
    int n = sizeof table / sizeof table[0];

    double x = 12.0, y = 4.0;

    for (int i = 0; i < n; i++) {
        printf("%.1f %c %.1f = %.2f   (%s)\n",
               x, table[i].symbol, y, table[i].fn(x, y), table[i].name);
    }

    // switch olmadan bir karakter uzerinden dagitim
    char wanted = '*';
    for (int i = 0; i < n; i++) {
        if (table[i].symbol == wanted) {
            printf("\n'%c' dagitildi -> %.2f\n", wanted, table[i].fn(x, y));
            break;
        }
    }

    return 0;
}

Bir işlem eklemek artık bir switch'i düzenlemek değil, bir satır eklemektir. Bunu yapılarla eşleştirin, standart C eklenti biçimini elde edersiniz: bu dilde "bir arayüz", fonksiyon göstericilerinden oluşan bir yapı demektir.

Canınızı Yakacak Şeyler

İmzalar tam olarak eşleşmelidir. Bir fonksiyon göstericisinin tipi, parametre tiplerini ve dönüş tipini içerir. Uyumsuz bir fonksiyon atamak bir kısıt ihlalidir ve yanlış tipli bir gösterici üzerinden çağırmak, "çalışsa" bile tanımsız davranıştır. Bir uyarıyı susturmak için bir karşılaştırıcının imzasını dönüştürmeyin - karşılaştırıcıyı düzeltin.

Boş bir fonksiyon göstericisi de boş bir göstericidir. Tam olarak veri göstericilerinde olduğu gibi NULL ile başlatın ve çağırmadan önce kontrol edin:

if (handler != NULL) {
    handler(event);
}

O denetimin ekmeğini neden hak ettiği için bkz. boş göstericiler.

void göstericiler tür güvenliğini kaybeder ve tür sistemi sizsiniz. Bir qsort karşılaştırıcısının içinde hiçbir şey sizi yanlış tipe dönüştürmekten alıkoymaz. Bir double dizisini compare_ints ile sıralarsanız tertemiz derlenir ve saçmalık üretir.

Bildirim söz dizimi iç içe geçer. Bir fonksiyon göstericisi döndüren bir fonksiyon int (*get_op(char c))(int, int);'dir. Kendinizi bunu yazarken bulduğunuzda typedef'e uzanın:

typedef int (*BinaryOp)(int, int);
BinaryOp get_op(char c);           // aynı şey, okunaklı