typedef di C: Memberi Nama Tipe, Idiom typedef struct, dan Kapan Tidak Memakainya

typedef melakukan satu hal kecil: memberi nama lain pada tipe yang sudah ada. Tidak ada tipe baru yang dibuat, tidak ada memori yang disisihkan, dan tidak ada yang berubah pada perilaku nilainya. Ini adalah alat untuk memberi nama, dan di C, di mana nama tipe bawaannya panjang (unsigned long long, struct Employee, void (*)(int)), nama yang bagus sangat berharga.

Bentuk Dasar

Sintaksnya terbaca seperti deklarasi variabel dengan typedef ditempelkan di depannya. Di tempat nama variabel biasanya berada, kamu menaruh nama tipe yang baru:

unsigned long  count;    // declares a variable named count
typedef unsigned long  ulong;   // declares a TYPE named ulong

Itulah seluruh aturannya, dan aturan ini menjelaskan setiap typedef yang akan pernah kamu baca, termasuk yang bentuknya aneh di bagian selanjutnya halaman ini.

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

Perhatikan apa yang tidak kamu dapatkan dari pasangan Celsius/Fahrenheit: keamanan tipe. Keduanya hanyalah double, jadi mengirim nilai Fahrenheit ke tempat yang mengharapkan Celsius tetap bisa di-compile tanpa masalah. Nama-nama itu mendokumentasikan maksud untuk manusia; nama itu tidak membuat pengecekan apa pun.

Idiom typedef struct

Inilah alasan sebagian besar program C memakai typedef sama sekali. Di C, nama tipe sebuah struct menyertakan kata kuncinya:

struct Point { int x; int y; };
struct Point p;              /* the word "struct" every single time */

Typedef meringkasnya:

#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("midpoint: (%d, %d)\n", m.x, m.y);
    return 0;
}

Baca dengan aturan tadi: buang typedef dan kamu mendapat struct Point {...} Point;, yaitu deklarasi variabel bernama Point. Tambahkan lagi typedef dan Point menjadi nama tipe.

Dengan Tag atau Tanpa Tag

Kamu bisa membuang tag-nya sama sekali, sehingga menghasilkan struct anonim yang hanya punya nama typedef:

typedef struct {
    int x;
    int y;
} Point;          /* no "struct Point" exists - only "Point" */

Bentuk ini lebih rapi, dan untuk record data biasa ini gaya yang umum. Tetapi bentuk ini gagal begitu struct-nya perlu menyebut dirinya sendiri, karena nama typedef baru bisa dipakai setelah deklarasinya sendiri selesai:

/* Does NOT compile: "Node" is not a type yet inside its own braces. */
typedef struct {
    int value;
    Node *next;
} Node;

Pertahankan tag-nya dan referensi ke diri sendiri bisa berjalan, karena struct Node sudah bisa dipakai begitu tag-nya terlihat:

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

typedef struct Node {
    int value;
    struct Node *next;     /* the TAG, not the typedef name */
} 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;
}

Aturan praktisnya: pertahankan tag-nya. Biayanya hanya satu kata, namanya sama dengan nama typedef sehingga tidak membingungkan, dan pintu tetap terbuka untuk referensi ke diri sendiri dan untuk forward declaration di header. Lihat halaman struct dan pointer untuk melihat node berantai itu berkembang menjadi apa.

Forward Declaration dan Tipe Opaque

Karena pointer ke struct punya ukuran yang diketahui bahkan saat isi struct-nya belum diketahui, sebuah header bisa membagikan sebuah tipe tanpa memperlihatkan anggotanya:

/* stack.h */
typedef struct Stack Stack;     /* declared, not defined */

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

struct Stack { ... }; yang lengkap berada di stack.c, dan tidak ada kode di luar yang bisa menyentuh anggotanya. Pola tipe opaque ini adalah cara library C menegakkan enkapsulasi, dan itulah persisnya FILE di pustaka standar: kamu mendapat FILE * dari fopen tanpa diberi tahu apa pun tentang isinya. Lihat penanganan file.

typedef untuk enum dan union

Idiom yang sama berlaku untuk dua jenis tipe gabungan lainnya:

#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("color = %d, number = %d\n", c, n.i);
    return 0;
}

Tanpa typedef, keduanya akan ditulis enum Color c; dan union Number n;. Lihat halaman enum dan union untuk tahu apa yang sebenarnya mereka lakukan.

typedef untuk Function Pointer

Di sinilah typedef berhenti menjadi sekadar kenyamanan dan hampir menjadi keharusan. Sintaks mentah sebuah function pointer terkenal sulit dibaca:

void (*handler)(int, const char *);        /* a variable */
void register_cb(void (*cb)(int, const char *));   /* a parameter */

Beri nama tipenya sekali dan keduanya jadi mudah dibaca:

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

Terapkan lagi aturan membuang typedef: int (*IntBinaryOp)(int, int); saja akan mendeklarasikan variabel bernama IntBinaryOp yang menunjuk ke fungsi yang menerima dua int dan mengembalikan int. Dengan typedef, itu menjadi nama tipenya. Selengkapnya di halaman function pointer.

typedef vs #define

Keduanya terlihat bisa saling menggantikan untuk alias sederhana, padahal tidak:

#define INT_PTR int *
typedef int *int_ptr;

INT_PTR  a, b;    /* expands to: int *a, b;  -- b is a plain int! */
int_ptr  c, d;    /* both c and d are int *          */

#define adalah substitusi teks buta yang dilakukan sebelum compiler melihat kodenya; typedef adalah deklarasi sungguhan yang dipahami compiler, dan berlaku untuk setiap nama dalam daftar. Pakai typedef untuk tipe, dan simpan #define untuk konstanta dan makro.

Saat typedef Merugikan

Typedef juga bisa menyembunyikan informasi yang dibutuhkan pembaca. Contoh paling tajam adalah menyembunyikan pointer:

typedef struct Node *NodeRef;    /* the star disappears */

NodeRef n = get_node();

Melihat NodeRef n, pembaca tidak bisa tahu apakah n bisa NULL, apakah harus dibebaskan, apakah n dan salinannya berbagi objek yang sama, atau apakah anggotanya diakses dengan . atau ->. Keempat pertanyaan itu langsung terjawab oleh struct Node *n.

Pustaka standar setuju: typedef dibuat untuk struct-nya (FILE), dan tanda bintangnya dibiarkan di tempat pemakaian (FILE *fp). Dari situ muncul dua pedoman yang masuk akal:

• Buatlah typedef untuk struct, union, enum, dan function pointer, karena kata-kata yang dibuang tidak membawa informasi apa pun.
• Jangan membuat typedef untuk pointer hanya demi mempersingkatnya, dan jangan membuat typedef untuk tipe dasar demi menyamarkannya (typedef int Boolean; mengundang orang untuk menyimpan 7 di dalamnya; pakai bool dari <stdbool.h>, yang dibahas di halaman boolean).

Nama-nama berlebar tetap milik pustaka standar di <stdint.h> (uint32_t, int64_t, size_t) semuanya adalah typedef, dan itulah argumen terbaik untuk fitur ini: namanya menyatakan dengan tepat apa isinya, portabel, dan tidak ada yang disembunyikan.