C'de typedef: Tipleri Adlandırmak, typedef struct Deyimi ve Ne Zaman Atlanır

typedef küçük bir şey yapar: zaten var olan bir tipe başka bir isim verir. Yeni bir tip oluşturulmaz, bellek ayrılmaz ve değerin nasıl davrandığıyla ilgili hiçbir şey değişmez. Bir adlandırma aracıdır - ve yerleşik tip adlarının uzadığı C'de (unsigned long long, struct Employee, void (*)(int)) iyi bir isim çok şey değer.

Temel Biçim

Söz dizimi, başına typedef eklenmiş bir değişken bildirimi gibi okunur. Değişken adının geleceği yere yeni tip adını koyarsınız:

unsigned long  count;    // count adında bir değişken bildirir
typedef unsigned long  ulong;   // ulong adında bir TİP bildirir

Kuralın tamamı budur ve bu sayfanın ilerisindeki tuhaf görünenler dahil okuyacağınız her typedef'i açıklar.

#include <stdio.h>

typedef unsigned long ulong;
typedef double Celsius;
typedef double Fahrenheit;

Fahrenheit to_f(Celsius c) {
    return c * 9.0 / 5.0 + 32.0;
}

int main(void) {
    ulong big = 4000000000UL;
    Celsius body = 37.0;

    printf("%lu\n", big);
    printf("%.1fC = %.1fF\n", body, to_f(body));
    return 0;
}

Celsius/Fahrenheit çiftinin size kazandırmadığı şeye dikkat edin: tür güvenliği. İkisi de yalnızca double'dır, dolayısıyla Celsius beklenen yere bir Fahrenheit değeri geçirmek memnuniyetle derlenir. İsimler niyeti insanlar için belgeler; bir denetim oluşturmazlar.

typedef struct Deyimi

Çoğu C programının bir typedef içermesinin asıl sebebi budur. C'de bir yapının tip adı anahtar kelimeyi içerir:

struct Point { int x; int y; };
struct Point p;              /* her seferinde "struct" kelimesi */

Bir typedef bunu kısaltır:

#include <stdio.h>

typedef struct Point {
    int x;
    int y;
} Point;

Point midpoint(Point a, Point b) {
    Point m = {(a.x + b.x) / 2, (a.y + b.y) / 2};
    return m;
}

int main(void) {
    Point a = {0, 0};
    Point b = {10, 6};
    Point m = midpoint(a, b);

    printf("orta nokta: (%d, %d)\n", m.x, m.y);
    return 0;
}

Onu önceki kuralla okuyun: typedef'i çıkarın, elinizde struct Point {...} Point; kalır ki bu Point adında bir değişkenin bildirimidir. typedef'i geri ekleyin ve Point bunun yerine bir tip adı olur.

Etiketli ya da Etiketsiz

Etiketi tamamen dışarıda bırakabilirsiniz; bu, yalnızca typedef adına sahip isimsiz bir yapı verir:

typedef struct {
    int x;
    int y;
} Point;          /* "struct Point" yoktur - yalnızca "Point" */

Bu daha derli topludur ve düz bir veri kaydı için yaygın tarzdır. Ama yapının kendisinden söz etmesi gerektiği anda başarısız olur, çünkü typedef adı kendi bildirimi bitene dek kullanılabilir değildir:

/* DERLENMEZ: "Node", kendi süslü parantezlerinin içinde henüz bir tip değil. */
typedef struct {
    int value;
    Node *next;
} Node;

Etiketi koruyun, kendine atıf çalışır, çünkü struct Node etiket görülür görülmez kullanılabilir:

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

typedef struct Node {
    int value;
    struct Node *next;     /* typedef adi degil, ETIKET */
} Node;

int main(void) {
    Node *head = malloc(sizeof *head);
    Node *second = malloc(sizeof *second);
    if (head == NULL || second == NULL) {
        free(head);
        free(second);
        return 1;
    }

    head->value = 1;
    head->next = second;
    second->value = 2;
    second->next = NULL;

    for (Node *n = head; n != NULL; n = n->next) {
        printf("%d ", n->value);
    }
    printf("\n");

    free(second);
    free(head);
    return 0;
}

Pratik kural: etiketi koruyun. Bir kelimeye mal olur, typedef adıyla eşleşir dolayısıyla hiçbir şey kafa karıştırıcı değildir ve kendine atıf ile başlıklardaki ileri bildirimler için kapıyı açık bırakır. O bağlı düğümün neye dönüştüğü için bkz. yapılar ve göstericiler.

İleri Bildirimler ve Opak Tipler

Bir yapıya giden göstericinin, yapının içeriği bilinmese bile bilinen bir boyutu olduğu için, bir başlık üyelerini açığa çıkarmadan bir tip dağıtabilir:

/* stack.h */
typedef struct Stack Stack;     /* bildirildi, tanımlanmadı */

Stack *stack_create(void);
void   stack_push(Stack *s, int value);
int    stack_pop(Stack *s);
void   stack_destroy(Stack *s);

Tam struct Stack { ... };, stack.c içinde yaşar ve dışarıdan hiç kimse üyelerine dokunamaz. Bu opak tip kalıbı, C kütüphanelerinin kapsüllemeyi uygulama yoludur ve standart kütüphanedeki FILE tam olarak budur - fopen'dan bir FILE * alırsınız ve içinde ne olduğu hakkında size hiçbir şey söylenmez. Bkz. dosya işlemleri.

enum'lar ve union'lar için typedef

Aynı deyim diğer iki bileşik tür için de geçerlidir:

#include <stdio.h>

typedef enum Color {
    RED,
    GREEN,
    BLUE
} Color;

typedef union Number {
    int i;
    float f;
} Number;

int main(void) {
    Color c = GREEN;
    Number n;
    n.i = 42;

    printf("renk = %d, sayi = %d\n", c, n.i);
    return 0;
}

typedef olmadan bunlar enum Color c; ve union Number n; olurdu. Gerçekte ne yaptıkları için bkz. enum'lar ve birleşimler.

Bir Fonksiyon Göstericisi için typedef

typedef'in bir kolaylık olmaktan çıkıp neredeyse zorunlu hâle geldiği yer burasıdır. Bir fonksiyon göstericisinin ham söz dizimi meşhur biçimde zor okunur:

void (*handler)(int, const char *);                 /* bir değişken */
void register_cb(void (*cb)(int, const char *));    /* bir parametre */

Tipi bir kez adlandırın, ikisi de okunaklı olsun:

#include <stdio.h>

typedef int (*IntBinaryOp)(int, int);

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

int apply(IntBinaryOp op, int a, int b) {
    return op(a, b);
}

int main(void) {
    IntBinaryOp ops[] = {add, mul};
    const char *names[] = {"add", "mul"};

    for (int i = 0; i < 2; i++) {
        printf("%s(3, 4) = %d\n", names[i], apply(ops[i], 3, 4));
    }
    return 0;
}

typedef'i çıkarma kuralını yeniden uygulayın: tek başına int (*IntBinaryOp)(int, int);, iki int alıp bir int döndüren bir fonksiyonu gösteren IntBinaryOp adında bir değişken bildirirdi. typedef ile bu, tipin adı olur. Daha fazlası fonksiyon göstericileri sayfasında.

typedef ile #define

Basit takma adlar için birbirinin yerine geçebilir görünürler ve değildirler:

#define INT_PTR int *
typedef int *int_ptr;

INT_PTR  a, b;    /* şuna genişler: int *a, b;  -- b düz bir int! */
int_ptr  c, d;    /* hem c hem d birer int *    */

#define, derleyici kodu görmeden önce yapılan kör metin değiştirmedir; typedef, derleyicinin anladığı gerçek bir bildirimdir ve listedeki her isme uygulanır. Tipler için typedef kullanın ve #define'ı sabitlere ve makrolara ayırın.

Bir typedef Ne Zaman Zarar Verir

Typedef'ler okuyucunun ihtiyaç duyduğu bilgiyi de gizleyebilir. En keskin örnek bir göstericiyi gizlemektir:

typedef struct Node *NodeRef;    /* yıldız yok olur */

NodeRef n = get_node();

NodeRef n'e bakan bir okuyucu, n'in NULL olup olamayacağını, serbest bırakılması gerekip gerekmediğini, n ile onun bir kopyasının aynı nesneyi paylaşıp paylaşmadığını ya da üyelere . ile mi -> ile mi ulaşılacağını anlayamaz. Dört sorunun dördü de struct Node *n ile anında yanıtlanır.

Standart kütüphane de aynı fikirde: yapıyı typedef eder (FILE) ve yıldızı kullanım noktasında bırakır (FILE *fp). Bundan iki makul rehber çıkar:

• Yapıları, birleşimleri, enum'ları ve fonksiyon göstericilerini typedef edin - kaldırılan gürültü hiçbir bilgi taşımaz.
• Yalnızca kısaltmak için bir göstericiyi typedef etmeyin ve temel bir tipi gizlemek için typedef etmeyin (typedef int Boolean;, birini içine 7 saklamaya davet eder - bunun yerine booleanlar sayfasında ele alınan <stdbool.h>'deki bool'u kullanın).

Standart kütüphanenin <stdint.h> içindeki kendi sabit genişlikli isimleri (uint32_t, int64_t, size_t) hepsi typedef'tir ve bu özellik için en iyi gerekçedir: tam olarak ne olduklarını söylerler, taşınabilirdirler ve hiçbir şey gizlenmez.