Struct di C: Mendefinisikan, Menginisialisasi, dan Memakai Struktur

Array menampung banyak nilai dengan satu tipe. struct melakukan kebalikannya: menampung beberapa nilai dengan tipe berbeda dan memperlakukannya sebagai satu kesatuan. Sebuah titik adalah x dan y. Seorang karyawan adalah nama, id, dan gaji. Tanpa struct, kamu harus membawa semua itu sebagai tiga variabel lepas dan berharap tidak pernah tertukar gaji siapa milik siapa.

Mendeklarasikan Tipe Struct

Deklarasi struct memberi nama sebuah tag dan mendaftar anggotanya di dalam kurung kurawal:

struct Point {
    int x;
    int y;
};

Titik koma setelah kurung kurawal penutup itu wajib. Lupa menulisnya menghasilkan salah satu pesan error paling membingungkan yang akan ditemui pemula C, karena compiler menyalahkan baris berikutnya.

Kode ini mendeklarasikan sebuah tipe, bukan variabel. Di C, nama lengkap tipenya adalah struct Point, termasuk kata kuncinya:

#include <stdio.h>

struct Point {
    int x;
    int y;
};

int main(void) {
    struct Point p;
    p.x = 3;
    p.y = 4;

    printf("(%d, %d)\n", p.x, p.y);
    return 0;
}

Anggota dibaca dan ditulis dengan operator titik, p.x. Variabel struct adalah variabel biasa: tinggal di stack, bisa di-assign ke struct lain bertipe sama dengan =, dan lenyap di akhir scope-nya.

Menulis struct Point di mana-mana cukup melelahkan, dan karena itulah hampir semua kode C sungguhan membungkus deklarasinya dengan typedef supaya tipenya cukup ditulis Point.

Menginisialisasi Struct

Kamu bisa mengisi struct tepat saat mendeklarasikannya. Bentuk posisional mendaftar nilai sesuai urutan deklarasi:

struct Point p = {3, 4};   // x = 3, y = 4

Designated initializer menyebut nama setiap anggota, sehingga lebih jelas dan lebih aman:

#include <stdio.h>

struct Employee {
    int id;
    char name[32];
    double salary;
};

int main(void) {
    struct Employee a = {101, "Ada", 92000.0};
    struct Employee b = {.name = "Grace", .id = 102, .salary = 105000.0};
    struct Employee blank = {0};

    printf("%d %s %.2f\n", a.id, a.name, a.salary);
    printf("%d %s %.2f\n", b.id, b.name, b.salary);
    printf("%d [%s] %.2f\n", blank.id, blank.name, blank.salary);
    return 0;
}

Tiga hal yang perlu diperhatikan:

• Bentuk designated bisa mendaftar anggota dengan urutan apa pun, jadi menambah atau mengubah urutan anggota nanti tidak akan diam-diam menggeser nilai ke tempat yang salah.
• Anggota yang tidak kamu sebut akan diinisialisasi dengan nol. {0} adalah cara idiomatis untuk mengisi seluruh struct dengan nol.
• Anggota char name[32] adalah array sungguhan di dalam struct, jadi string-nya tersimpan di dalam struct itu sendiri, bukan di tempat lain. Itu juga berarti a.name = "Ada"; setelahnya tidak sah; kamu butuh strcpy (lihat fungsi string).

Struct tanpa inisialisasi berarti belum diinisialisasi, dan membaca anggotanya sebelum menulisnya adalah undefined behavior. = {0} tidak memakan biaya dan menghilangkan seluruh jenis bug itu.

Assignment dan Perbandingan

Assignment struct menyalin setiap anggota:

#include <stdio.h>

struct Point {
    int x;
    int y;
};

int main(void) {
    struct Point a = {1, 2};
    struct Point b = a;   // full copy

    b.x = 99;

    printf("a = (%d, %d)\n", a.x, a.y);
    printf("b = (%d, %d)\n", b.x, b.y);
    return 0;
}

a tidak tersentuh: b mendapat salinannya sendiri. Tetapi perhatikan apa yang tidak diberikan C: tidak ada == untuk struct. if (a == b) tidak akan bisa di-compile. Membandingkan berarti membandingkan anggota-anggotanya:

if (a.x == b.x && a.y == b.y) { /* equal */ }

Jangan memakai memcmp sebagai jalan pintas. Compiler menyisipkan byte padding yang tidak terlihat di antara anggota demi alignment, dan byte itu bisa berisi nilai sampah, sehingga dua struct dengan anggota yang identik bisa dianggap berbeda jika dibandingkan byte per byte.

Array Struct

Karena struct adalah tipe seperti yang lain, kamu bisa membuat array darinya. Ini cara standar untuk menyimpan tabel berisi record.

#include <stdio.h>

struct Employee {
    int id;
    char name[32];
    double salary;
};

int main(void) {
    struct Employee staff[3] = {
        {101, "Ada",    92000.0},
        {102, "Grace",  105000.0},
        {103, "Alan",   87000.0},
    };

    int n = sizeof(staff) / sizeof(staff[0]);
    double total = 0.0;

    for (int i = 0; i < n; i++) {
        printf("%-3d %-8s %10.2f\n", staff[i].id, staff[i].name, staff[i].salary);
        total += staff[i].salary;
    }

    printf("Average: %.2f\n", total / n);
    return 0;
}

staff[i].salary dibaca "elemen i, lalu anggota salary-nya". Pengindeksan mengikat lebih kuat daripada titik, jadi tidak perlu tanda kurung.

Struct Disalin Saat Dikirim ke Fungsi

Inilah aturan yang menjebak banyak orang. Saat kamu mengirim struct ke fungsi, C menyalinnya. Fungsi itu bekerja pada salinan pribadinya sendiri:

#include <stdio.h>

struct Point {
    int x;
    int y;
};

void try_to_move(struct Point p) {
    p.x += 100;   // changes the copy only
}

double distance_from_origin(struct Point p) {
    return p.x * p.x + p.y * p.y;   // squared distance, no math.h needed
}

int main(void) {
    struct Point p = {3, 4};

    try_to_move(p);
    printf("after try_to_move: (%d, %d)\n", p.x, p.y);
    printf("squared distance: %.0f\n", distance_from_origin(p));
    return 0;
}

p tetap (3, 4). Membaca struct sebagai nilai, seperti yang dilakukan distance_from_origin, sama sekali tidak masalah dan sering menjadi pilihan paling jelas untuk struct kecil. Tetapi jika fungsinya harus mengubah struct milik pemanggil, atau jika struct-nya cukup besar sehingga menyalinnya jadi boros, kirim pointer. Itulah topik halaman struct dan pointer.

Mengembalikan struct sebagai nilai bekerja dengan cara yang sama dan sepenuhnya sah:

struct Point make_point(int x, int y) {
    struct Point p = {x, y};
    return p;
}

Struct Bersarang

Anggota struct bisa berupa struct juga. Rangkai titiknya untuk masuk ke dalam:

#include <stdio.h>

struct Date {
    int year;
    int month;
    int day;
};

struct Book {
    char title[64];
    struct Date published;
    int pages;
};

int main(void) {
    struct Book b = {
        .title = "The C Programming Language",
        .published = {.year = 1978, .month = 2, .day = 22},
        .pages = 228,
    };

    printf("%s (%d-%02d-%02d), %d pages\n",
           b.title,
           b.published.year, b.published.month, b.published.day,
           b.pages);
    return 0;
}

b.published.year masuk satu tingkat demi satu tingkat. Struct bersarang adalah cara membangun model data sungguhan di C. Struct bagian dalam disimpan di dalam struct luarnya, bukan ditunjuk, jadi seluruh Book adalah satu blok memori yang bersambung.

Ukuran, Padding, dan Urutan Anggota

sizeof memberitahumu seberapa besar sebuah struct, dan jawabannya sering lebih besar daripada jumlah ukuran anggotanya:

#include <stdio.h>

struct Wasteful {
    char  a;    // 1 byte
    int   b;    // 4 bytes
    char  c;    // 1 byte
};

struct Tidy {
    int   b;
    char  a;
    char  c;
};

int main(void) {
    printf("Wasteful: %zu bytes\n", sizeof(struct Wasteful));
    printf("Tidy:     %zu bytes\n", sizeof(struct Tidy));
    return 0;
}

Di mesin pada umumnya, Wasteful berukuran 12 byte dan Tidy 8 byte, walaupun keduanya berisi tiga anggota yang sama. Compiler menyisipkan padding supaya setiap anggota berada di alamat yang disukai tipenya; sebuah int biasanya ingin kelipatan 4. Menaruh anggota yang lebih besar sebelum yang lebih kecil cenderung menghasilkan susunan yang lebih rapat.

Ini jarang penting (array berisi sejuta elemen, tata letak paket jaringan) dan tidak pernah memengaruhi kebenaran kodemu sendiri. Yang dijelaskannya adalah kenapa sizeof bisa mengejutkan, dan kenapa memcmp pada struct adalah ide yang buruk.