Lompat ke konten
Materi
  • 1 Dasar-dasar C
    1.1

    main, printf & fungsi

    Setiap program C dimulai di main. #include <stdio.h> memasukkan header agar Anda dapat menggunakan printf untuk mencetak. Fungsi adalah blok bernama yang dapat Anda panggil; \n memulai baris baru. main mengembalikan 0 untuk berarti "sukses".

    #include <stdio.h>
    
    void greet(void) {
        printf("Hello, world!\n");
    }
    
    int main(void) {
        greet();
        printf("I am learning C.\n");
        return 0;
    }
    
    Setiap program C berjalan dari main setelah menyertakan header
    Setiap program C berjalan dari main setelah menyertakan header
    1.2

    Variabel, tipe & aritmatika

    C memerlukan tipe untuk setiap variabel: int (bilangan bulat), double (titik melayang/floating-point), char (satu karakter). printf menggunakan penanda format — %d, %f, %c — untuk setiap nilai. Pembagian / antara dua bilangan bulat adalah pembagian bilangan bulat; % adalah sisa.

    #include <stdio.h>
    
    int main(void) {
        int n = 17;
        double pi = 3.14;
        char grade = 'A';
        printf("%d %.2f %c\n", n, pi, grade);   // 17 3.14 A
        printf("%d %d\n", 7 / 2, 7 % 2);        // 3 1
        return 0;
    }
    

    String format mengontrol baik pencetakan maupun pembacaan:

    Penanda Tipe Contoh output
    %d int 17
    %f double (%.2f = 2 tempat desimal) 3.14
    %c char A
    %s string Mei
    %zu ukuran (dari sizeof / strlen) 3
    %x unsigned int, dicetak dalam basis 16 ff

    scanf("%d", &n) membaca int melalui alamatnya (hatikan &). Format input dan output tidak identik: printf("%f", x) mencetak double, tetapi scanf("%lf", &x) membaca double; input %f membutuhkan float *. Periksa jumlah item yang berhasil ditugaskan yang dikembalikan. Kakaknya sscanf menguraikan nilai dari sebuah string:

    #include <stdio.h>
    
    int main(void) {
        char line[] = "Mei 88";
        char name[20];
        int score;
        if (sscanf(line, "%19s %d", name, &score) != 2) return 1;
        printf("%s scored %d\n", name, score);   // Mei scored 88
        return 0;
    }
    
    1.3

    Komentar & gaya

    Komentar adalah catatan untuk manusia; kompiler mengabaikannya. Gunakan // untuk satu baris dan /* ... */ untuk blok. Indentasi yang baik dan nama yang jelas membuat kode mudah dibaca.

    #include <stdio.h>
    
    int main(void) {
        // a single-line comment
        /* a block
           comment */
        int total = 3 + 4;       // clear names help
        printf("%d\n", total);   // 7
        return 0;
    }
    

    Kesalahan umum

    • Pengisytiharan dan penyataan ungkapan berakhir dengan ;; blok majmuk { ... } tidak memerlukan titik koma tambahan. main sepatutnya mengembalikan int (return 0;).
    • printf memerlukan string format: %d untuk int, %f untuk double, dan \n untuk baris baru.
    • Format yang salah seperti %d untuk double menyebabkan tingkah laku tak tertakrif; ia tidak dijamin sekadar mencetak sampah. Padankan jenis hujah.
  • 2 Seleksi
    2.1

    if / else

    Sebuah if menjalankan blok ketika kondisi bernilai benar. C tidak memiliki tipe boolean sejati secara default: 0 adalah false dan nilai non-nol apa pun adalah true. Rantai pilihan dengan else if dan else. Bandingkan dengan ==, !=, <, >, <=, >=.

    #include <stdio.h>
    
    int main(void) {
        int score = 72;
        if (score >= 90) {
            printf("A\n");
        } else if (score >= 60) {
            printf("Pass\n");
        } else {
            printf("Fail\n");
        }
        return 0;
    }
    
    if memilih cabang yang benar; else memilih cabang yang salah
    if memilih cabang yang benar; else memilih cabang yang salah
    2.2

    saklar

    Sebuah switch memilih satu case berdasarkan nilai bilangan bulat. Setiap case memerlukan break untuk keluar — tanpa itu, C akan "jatuh melalui" ke kasus berikutnya. default dijalankan jika tidak ada yang cocok.

    #include <stdio.h>
    
    int main(void) {
        int day = 3;
        switch (day) {
            case 1: printf("Mon\n"); break;
            case 2: printf("Tue\n"); break;
            case 3: printf("Wed\n"); break;
            default: printf("Other\n");
        }
        return 0;
    }
    

    Kesalahan umum

    • if (x = 5) melakukan penugasan dan selalu benar; gunakan == untuk membandingkan.
    • Setiap kasus switch memerlukan break;, atau akan melompat ke kasus berikutnya.
    • 0 bernilai false dan nilai non-nol mana pun bernilai true dalam sebuah kondisi.
  • 3 Perulangan
    3.1

    perulangan while & for

    Sebuah perulangan mengulang sebuah blok. Perulangan while berjalan selama kondisinya true. Perulangan for menggabungkan inisialisasi, pengujian, dan penambahan (i++) menjadi satu baris — paling baik ketika Anda tahu berapa kali harus mengulangi.

    #include <stdio.h>
    
    int main(void) {
        int i = 1;
        while (i <= 3) {
            printf("%d ", i);
            i++;
        }
        printf("\n");                    // 1 2 3
        for (int j = 0; j < 5; j++) {
            printf("%d ", j);
        }
        printf("\n");                    // 0 1 2 3 4
        return 0;
    }
    
    while memeriksa kondisi; for menghitung dengan langkah
    while memeriksa kondisi; for menghitung dengan langkah
    3.2

    Akumulasi

    Pola umum: mulailah akumulator pada 0, lalu tambahkan nilainya di dalam perulangan. Ide yang sama dapat digunakan untuk menghitung jumlah item atau menemukan total kumulatif.

    #include <stdio.h>
    
    int main(void) {
        int total = 0;
        for (int i = 1; i <= 5; i++) {
            total += i;            // 1 + 2 + 3 + 4 + 5
        }
        printf("%d\n", total);     // 15
        return 0;
    }
    
    3.3

    Perulangan bersarang & pola

    Perulangan di dalam perulangan lain disebut perulangan bersarang. Perulangan dalam selesai sepenuhnya untuk setiap langkah perulangan luar — sempurna untuk grid dan pola.

    #include <stdio.h>
    
    int main(void) {
        for (int row = 0; row < 3; row++) {
            for (int col = 0; col < 3; col++) {
                printf("*");
            }
            printf("\n");
        }
        return 0;
    }
    

    Kesalahan umum

    • for (i = 0; i < n; i++) berjalan n kali; tanda titik koma tepat setelah for (...) membuat perulangan kosong.
    • Perulangan while whose kondisi tidak pernah menjadi false akan berputar selamanya.
    • Deklarasikan penanda (int i) sebelum atau di dalam header for.
  • 4 Fungsi
    4.1

    Parameter & nilai kembalian

    Sebuah fungsi menerima parameter (input) dan mengembalikan nilai kembalian. Tipe kembalian muncul pertama (int, double, …); void berarti ia tidak mengembalikan apa pun.

    #include <stdio.h>
    
    int square(int x) {        // x is a parameter
        return x * x;          // hand back a value
    }
    
    int main(void) {
        int r = square(5);
        printf("%d\n", r);     // 25
        return 0;
    }
    
    Parameter masuk; nilai kembalian keluar
    Parameter masuk; nilai kembalian keluar
    4.2

    Prototipe & jangkauan

    C membaca dari atas ke bawah, sehingga fungsi harus diketahui sebelum dipanggil. Prototipe — baris header ditambah ; — mendeklarasikannya lebih awal agar Anda bisa menempatkan main terlebih dahulu. Jangkauan variabel adalah blok tempat ia berada: bersifat lokal dan hilang saat blok berakhir.

    #include <stdio.h>
    
    int add(int a, int b);     // prototype: declared before use
    
    int main(void) {
        printf("%d\n", add(3, 4));   // 7
        return 0;
    }
    
    int add(int a, int b) {    // definition comes later
        int sum = a + b;       // sum is local to add
        return sum;
    }
    

    Kesalahan umum

    • Fungsi yang digunakan sebelum didefinisikan memerlukan prototipe di atas main.
    • Argumen dikirimkan BERDASARKAN NILAI — perubahan di dalam fungsi tidak mempengaruhi Caller kecuali Anda mengirimkan pointer.
    • Variabel yang dideklarasikan di dalam fungsi bersifat lokal terhadapnya.
  • 5 Array
    5.1

    Array 1-D

    Array menyimpan beberapa nilai dari satu tipe. Indeks dimulai dari 0. C tidak menyimpan panjang array, jadi trik umum menghitung jumlah elemen: sizeof(a) / sizeof(a[0]).

    #include <stdio.h>
    
    int main(void) {
        int scores[3] = {88, 71, 95};
        printf("%d\n", scores[0]);     // 88
        scores[1] = 100;
        printf("%d\n", scores[1]);     // 100
        int n = sizeof(scores) / sizeof(scores[0]);
        printf("%d\n", n);             // 3
        return 0;
    }
    
    Slot array diindeks mulai dari 0
    Slot array diindeks mulai dari 0
    5.2

    Algoritma array

    Jelajahi array dengan perulangan for untuk mencari nilai maksimum, total, atau jumlah. Selalu loop dari 0 hingga n - 1.

    #include <stdio.h>
    
    int main(void) {
        int a[] = {3, 9, 2, 7};
        int n = sizeof(a) / sizeof(a[0]);
        int max = a[0], total = 0;
        for (int i = 0; i < n; i++) {
            if (a[i] > max) max = a[i];
            total += a[i];
        }
        printf("%d %d\n", max, total);   // 9 21
        return 0;
    }
    
    5.3

    Array 2-D

    Array 2-D adalah grid baris dan kolom: grid[row][col]. Gunakan dua perulangan bersarang untuk mengunjungi setiap sel.

    #include <stdio.h>
    
    int main(void) {
        int grid[2][3] = {{1, 2, 3}, {4, 5, 6}};
        printf("%d\n", grid[1][2]);    // 6
        for (int r = 0; r < 2; r++) {
            for (int c = 0; c < 3; c++) {
                printf("%d ", grid[r][c]);
            }
        }
        printf("\n");                  // 1 2 3 4 5 6
        return 0;
    }
    

    Kesalahan umum

    • C TIDAK memeriksa batas array: menulis a[n] dalam array ukuran-n adalah perilaku tak terdefinisi.
    • Indeks valid berjalan dari 0 hingga n - 1.
    • Dalam kebanyakan ungkapan, array bertukar kepada penunjuk kepada elemen pertamanya, tetapi array itu sendiri bukan penunjuk. sizeof(a) memberikan keseluruhan saiz byte untuk array sebenar; parameter array disesuaikan kepada penunjuk, jadi fungsi itu memerlukan panjang yang dibekalkan secara berasingan.
  • 6 Pointer
    6.1

    &, * dan kirim-berdasarkan-pointer

    Pointer menyimpan alamat variabel. &x memberikan alamat x; *p mendereferensikan pointer — ia membaca atau menulis nilai yang disimpan di sana. Mengirimkan pointer memungkinkan fungsi mengubah variabel Caller (kirim-berdasarkan-pointer).

    Pointer menyimpan alamat; dereferensinya mengikuti panah menuju nilai
    Pointer menyimpan alamat; dereferensinya mengikuti panah menuju nilai
    #include <stdio.h>
    
    void addOne(int *p) {     // p holds an address
        *p = *p + 1;          // change the value at that address
    }
    
    int main(void) {
        int x = 10;
        int *ptr = &x;        // & takes the address of x
        printf("%d\n", *ptr); // * reads the value: 10
        addOne(&x);
        printf("%d\n", x);    // 11 — changed through the pointer
        return 0;
    }
    

    Penggunaan klasik adalah fungsi tukar. Mengirimkan nilai hanya menyalinnya — pertukaran hilang. Mengirimkan pointer memungkinkan fungsi mencapai variabel Caller:

    #include <stdio.h>
    
    void swap_values(int a, int b) {      // copies: the caller sees nothing
        int t = a; a = b; b = t;
    }
    
    void swap_pointers(int *a, int *b) {  // addresses: the swap is real
        int t = *a; *a = *b; *b = t;
    }
    
    int main(void) {
        int x = 1, y = 2;
        swap_values(x, y);
        printf("%d %d\n", x, y);   // 1 2  (unchanged!)
        swap_pointers(&x, &y);
        printf("%d %d\n", x, y);   // 2 1  (swapped)
        return 0;
    }
    

    Nama array bertindak sebagai pointer ke elemennya pertama, dan aritmatika pointer melangkah dengan seluruh elemen:

    #include <stdio.h>
    
    int main(void) {
        int a[] = {10, 20, 30};
        int *p = a;                 // same as &a[0]
        printf("%d\n", *p);         // 10
        printf("%d\n", *(p + 2));   // 30 — same as a[2]
        return 0;
    }
    
    • NULL adalah pointer yang tidak menunjuk ke apa pun — periksa ada atau tidaknya sebelum Anda mendereferensikannya.

    Kesalahan umum

    • &x adalah alamat dari x; *p adalah nilai yang disimpan di p.
    • Jangan gunakan *p pada pointer yang tidak diinisialisasi atau NULL — ini menyebabkan crash atau merusak memori.
    • Untuk mengubah variabel Caller, kirimkan alamatnya dan tulis melalui pointer.
  • 7 String
    7.1

    Array char & terminator null

    Rantai C adalah array dari char. Setiap rantai diakhiri dengan penanda null tersembunyi '\0', yang menandai di mana rantai tersebut berhenti. strlen (dari <string.h>) menghitung karakter hingga penanda '\0' tersebut. Cetak seluruh rantai dengan %s dan satu karakter dengan %c.

    #include <stdio.h>
    #include <string.h>
    
    int main(void) {
        char name[] = "Mei";            // 'M', 'e', 'i', '\0'
        printf("%s\n", name);           // Mei
        printf("%zu\n", strlen(name));  // 3 (stops at '\0')
        printf("%c\n", name[0]);        // M
        return 0;
    }
    
    String C adalah array char yang diakhiri terminator null tersembunyi
    String C adalah array char yang diakhiri terminator null tersembunyi

    Anda dapat menjelajahi string dengan looping hingga Anda mencapai '\0'.

    #include <stdio.h>
    
    int main(void) {
        char word[] = "banana";
        int count = 0;
        for (int i = 0; word[i] != '\0'; i++) {
            if (word[i] == 'a') count++;
        }
        printf("%d\n", count);   // 3
        return 0;
    }
    
    7.2

    Pustaka string.h

    #include <string.h> menyediakan alat-alat string sehari-hari untuk Anda:

    Fungsi Melakukan
    strlen(s) panjang, tidak termasuk pengakhir
    strcpy(dst, src) salin — dst harus cukup besar
    strcat(dst, src) tambahkan src ke akhir dst
    strcmp(a, b) bandingkan: 0 jika sama, jika tidak negatif / positif
    #include <stdio.h>
    #include <string.h>
    
    int main(void) {
        char full[40];
        strcpy(full, "Mei");           // full is now "Mei"
        strcat(full, " Chen");         // append -> "Mei Chen"
        printf("%s (%zu)\n", full, strlen(full));       // Mei Chen (8)
        printf("%d\n", strcmp("apple", "apple") == 0);  // 1 (equal)
        return 0;
    }
    
    • strcmp mengembalikan 0 untuk kesamaan, sehingga ujiannya adalah strcmp(a, b) == 0 — jangan pernah a == b.
    • Array tujuan harus memiliki ruang untuk hasil ditambah terminator.

    Kesalahan umum

    • String C membutuhkan satu byte ekstra untuk terminator \0: kata 5 huruf butuh char[6].
    • Salin dan bandingkan string dengan strcpy / strcmp, bukan = / ==.
    • Melupakan \0 membuat printf("%s", ...) berjalan melewati akhir teks.
  • 8 Struktur (structs)
    8.1

    struct, typedef, . vs ->

    Sebuah struct mengelompokkan nilai-nilai terkait menjadi satu tipe. Setiap nilai adalah anggota. typedef memberikan nama singkat pada struct agar Anda dapat menulis Dog alih-alih struct Dog. Gunakan . pada nilai struct, tetapi gunakan -> pada pointer ke struct.

    #include <stdio.h>
    
    typedef struct {
        char name[20];
        int age;
    } Dog;
    
    int main(void) {
        Dog d = {"Rex", 3};
        printf("%s is %d\n", d.name, d.age);   // Rex is 3   (. on a value)
    
        Dog *p = &d;
        p->age = 4;                            // -> on a pointer
        printf("%s is %d\n", d.name, d.age);   // Rex is 4
        return 0;
    }
    

    Kesalahan umum

    • Gunakan . pada nilai struct dan -> pada pointer struct.
    • typedef memungkinkan Anda menghilangkan kata struct saat mendeklarasikan; tanpanya Anda menulis struct Point p;.
    • Menugaskan satu struct ke struct lain menyalin semua bidangnya.
    . untuk nilai struct; -> untuk pointer ke structs
    . untuk nilai struct; -> untuk pointer ke structs
  • 9 Memori dinamis
    9.1

    malloc, free & realloc

    malloc mengalokasikan memori di heap pada waktu run-time dan mengembalikan pointer ke sana. realloc mengubah ukuran blok itu; free mengembalikannya. Setiap malloc memerlukan matching free, atau Anda akan mengalami kebocoran memori. Semua ini hidup di <stdlib.h>.

    Lokal tersimpan di stack; memori malloc tersimpan di heap hingga Anda membebasinya
    Lokal tersimpan di stack; memori malloc tersimpan di heap hingga Anda membebasinya
    #include <stdio.h>
    #include <stdlib.h>
    
    int main(void) {
        int n = 3;
        int *a = malloc(n * sizeof(int));    // room for 3 ints
        if (a == NULL) return EXIT_FAILURE;
        for (int i = 0; i < n; i++) a[i] = i * 10;
    
        int *grown = realloc(a, 4 * sizeof *a); // positive size
        if (grown == NULL) {
            free(a);
            return EXIT_FAILURE;
        }
        a = grown;
        a[3] = 30;
    
        for (int i = 0; i < 4; i++) printf("%d ", a[i]);
        printf("\n");                        // 0 10 20 30
    
        free(a);                             // hand the memory back
        return 0;
    }
    
    • calloc(n, size) mengalokasi array seperti malloc DAN mengisinya dengan nol.

    Kesalahan umum

    • Setiap malloc memerlukan free yang sesuai; melupakan untuk membebaskan akan menyebabkan kebocoran memori.
    • Menggunakan memori setelah free ("use-after-free") adalah bug serius.
    • Periksa bahwa malloc tidak mengembalikan NULL sebelum Anda menggunakan memori.

    Untuk saiz positif, kegagalan realloc mengembalikan NULL dan mengekalkan alokasi lama utuh: semak hasil sementara sebelum menggantikan penunjuk tunggal anda. Kejayaan mengekalkan bilangan byte yang lebih kecil antara lama/baru; sel yang ditambah tidak dimulakan. Contoh ini mengelakkan permintaan saiz sifar dan lufah saiz. Pembolehubah tempatan biasa bukan-statik mempunyai tempoh storan automatik dan biasanya diimplementasikan pada tumpukan; C tidak mewajibkan susunan tersebut.

  • 10 Struktur data
    10.1

    Daftar terikat

    Daftar terikat adalah rantai node. Setiap node menyimpan nilai dan pointer ke node next berikutnya; node terakhir menunjuk ke NULL. Berbeda dengan array, daftar ini bertambah satu node pada satu waktu dengan malloc. Selalu free setiap node saat selesai.

    Daftar terikat: setiap node menyimpan nilai dan pointer ke node berikutnya, berakhir di NULL
    Daftar terikat: setiap node menyimpan nilai dan pointer ke node berikutnya, berakhir di NULL
    #include <stdio.h>
    #include <stdlib.h>
    
    typedef struct Node {
        int value;
        struct Node *next;
    } Node;
    
    int main(void) {
        Node *head = NULL;
        for (int v = 10; v <= 30; v += 10) {   // prepend 10, 20, 30
            Node *n = malloc(sizeof(Node));
            n->value = v;
            n->next = head;
            head = n;
        }
        for (Node *p = head; p != NULL; p = p->next) {
            printf("%d ", p->value);           // 30 20 10
        }
        printf("\n");
    
        while (head != NULL) {                 // free the whole list
            Node *t = head;
            head = head->next;
            free(t);
        }
        return 0;
    }
    
    10.2

    Tumpukan & antrean

    Tumpukan bersifat LIFO (last in, first out): push dan pop dilakukan di ujung yang sama. Antrean bersifat FIFO (first in, first out): tambah di belakang, hapus dari depan. Keduanya mudah dibangun di atas array dengan variabel indeks.

    #include <stdio.h>
    
    int main(void) {
        int stack[10];
        int top = 0;                       // next free slot
        stack[top++] = 1;                  // push
        stack[top++] = 2;
        stack[top++] = 3;
        while (top > 0) {
            printf("%d ", stack[--top]);   // pop: 3 2 1
        }
        printf("\n");
        return 0;
    }
    
    #include <stdio.h>
    
    int main(void) {
        int queue[10];
        int front = 0, back = 0;
        queue[back++] = 1;                       // enqueue
        queue[back++] = 2;
        queue[back++] = 3;
        while (front < back) {
            printf("%d ", queue[front++]);       // dequeue: 1 2 3
        }
        printf("\n");
        return 0;
    }
    

    Kesalahan umum

    • Dalam daftar terikat, jangan pernah kehilangan pointer head, atau seluruh daftar tidak dapat diakses.
    • Bebas setiap node saat selesai, jalankan traversal daftar sebelum memutuskan tautannya.
    • Periksa apakah daftar kosong (head NULL) sebelum melakukan pop.
  • 11 Pencarian, pengurutan & rekursi
    11.1

    Pencarian linear & biner

    Pencarian linear memeriksa setiap elemen secara berurutan — bekerja pada array apa pun. Pencarian biner jauh lebih cepat tetapi memerlukan array yang sudah terurut: ia memeriksa nilai tengah dan membuang separuh data setiap langkahnya. Keduanya mengembalikan indeks, atau -1 jika tidak ditemukan.

    #include <stdio.h>
    
    int linear(int a[], int n, int target) {
        for (int i = 0; i < n; i++)
            if (a[i] == target) return i;
        return -1;
    }
    
    int binary(int a[], int n, int target) {
        int lo = 0, hi = n - 1;
        while (lo <= hi) {
            int mid = (lo + hi) / 2;
            if (a[mid] == target) return mid;
            else if (a[mid] < target) lo = mid + 1;
            else hi = mid - 1;
        }
        return -1;
    }
    
    int main(void) {
        int a[] = {2, 5, 8, 12, 16, 23};
        int n = sizeof(a) / sizeof(a[0]);
        printf("%d %d %d\n", linear(a, n, 12), binary(a, n, 12), binary(a, n, 9));
        return 0;   // 3 3 -1
    }
    
    Pencarian linear memeriksa semua; pencarian biner membagi dua rentang yang terurut
    Pencarian linear memeriksa semua; pencarian biner membagi dua rentang yang terurut
    11.2

    Pengurutan

    Bubble sort berulang kali membandingkan elemen tetangga dan menukar pasangan mana pun yang tidak berurutan. Setelah setiap lintasan, nilai terbesar "menggelembung" ke bagian akhir.

    #include <stdio.h>
    
    int main(void) {
        int a[] = {5, 2, 9, 1, 7};
        int n = sizeof(a) / sizeof(a[0]);
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - 1 - i; j++) {
                if (a[j] > a[j + 1]) {
                    int t = a[j]; a[j] = a[j + 1]; a[j + 1] = t;
                }
            }
        }
        for (int i = 0; i < n; i++) printf("%d ", a[i]);
        printf("\n");   // 1 2 5 7 9
        return 0;
    }
    
    11.3

    Rekursi

    Rekursi adalah fungsi yang memanggil dirinya sendiri. Fungsi ini membutuhkan kasus dasar untuk berhenti, dan pemanggilan rekursif yang mendekati kasus dasar tersebut. Tanpa kasus dasar, fungsi tidak akan pernah berakhir.

    #include <stdio.h>
    
    int factorial(int n) {
        if (n <= 1) return 1;          // base case
        return n * factorial(n - 1);   // recursive call
    }
    
    int main(void) {
        printf("%d\n", factorial(5));  // 120
        return 0;
    }
    

    Kesalahan umum

    • Pencarian biner memerlukan array yang terurut; rekursi memerlukan kasus dasar.
    • Setiap pemanggilan rekursif harus mendekat ke kasus dasar, atau tumpukan akan penuh (stack overflow).
    • Bubble sort dan insertion sort memiliki kompleksitas O(n²) — baik untuk dipelajari, namun lambat dalam skala besar.
  • 12 File & kesalahan
    12.1

    File teks

    fopen mengembalikan pointer file; string mode menyatakan tindakan apa yang akan dilakukan — "w" tulis, "r" baca, "a" lampirkan. Tulis dengan fprintf, baca dengan fscanf, dan selalu fclose saat selesai.

    #include <stdio.h>
    
    int main(void) {
        FILE *out = fopen("scores.txt", "w");   // open for writing
        if (out == NULL) {
            perror("scores.txt");
            return 1;
        }
        fprintf(out, "Alice 80\nBob 95\n");
        fclose(out);
    
        FILE *in = fopen("scores.txt", "r");    // open for reading
        if (in == NULL) {
            perror("scores.txt");
            return 1;
        }
        char name[20];
        int score;
        while (fscanf(in, "%19s %d", name, &score) == 2) {   // %19s leaves room for '\0'
            printf("%s -> %d\n", name, score);
        }
        fclose(in);
        return 0;
    }
    
    fopen → baca/tulis → fclose
    fopen → baca/tulis → fclose
    12.2

    Penanganan error dengan kode pengembalian

    C tidak memiliki exception bawaan. Fungsi dapat melaporkan hasilnya melalui kode pengembalian; periksa aturan fungsi tersebut sebelum menggunakan hasilnya. Contoh di bawah ini menggunakan 0 untuk sukses dan -1 untuk gagal. fopen alih-alih mengembalikan pointer stream, atau NULL ketika gagal.

    #include <stdio.h>
    
    // returns 0 on success, -1 if the divisor is 0
    int safe_divide(int a, int b, int *result) {
        if (b == 0) return -1;          // error code
        *result = a / b;
        return 0;                       // success
    }
    
    int main(void) {
        int r;
        if (safe_divide(10, 2, &r) == 0)
            printf("10 / 2 = %d\n", r);          // 10 / 2 = 5
        if (safe_divide(10, 0, &r) != 0)
            printf("cannot divide by zero\n");   // error reported
        return 0;
    }
    

    Kesalahan umum

    • Pastikan bahwa fopen tidak mengembalikan NULL sebelum membaca atau menulis.
    • Selalu fclose sebuah file saat selesai.
    • Kembalikan kode non-nol dari main untuk menandakan kesalahan kepada pemanggil.
  • 13 Bit & data
    13.1

    Bit, biner & operator bitwise

    Bit adalah digit tunggal 0 atau 1; angka disimpan dalam format biner. Operator bitwise bekerja langsung pada bit: & AND, | OR, ^ XOR, << geser kiri (×2 setiap langkah), >> geser kanan (÷2).

    #include <stdio.h>
    
    int main(void) {
        int a = 12;              // 1100
        int b = 10;              // 1010
        printf("%d\n", a & b);   // 8   AND  -> 1000
        printf("%d\n", a | b);   // 14  OR   -> 1110
        printf("%d\n", a ^ b);   // 6   XOR  -> 0110
        printf("%d\n", a << 1);  // 24  left shift
        printf("%d\n", a >> 1);  // 6   right shift
        return 0;
    }
    

    Heksadesimal (basis 16) menulis biner secara ringkas: satu digit heksadecimal setara dengan tepat empat bit. Tulis literal heksa dengan 0x; cetak dengan %x:

    #include <stdio.h>
    
    int main(void) {
        printf("%d\n", 0xFF);   // 255  (0x marks a hex literal)
        printf("%x\n", 255);    // ff
        printf("%x\n", 12);     // c
        return 0;
    }
    
    Operator bitwise bekerja pada bit bilangan bulat
    Operator bitwise bekerja pada bit bilangan bulat
    13.2

    Pengkodean panjang larian

    Pengkodean panjang-lari (RLE) adalah metode kompresi sederhana: ganti setiap rentang karakter berulang dengan jumlah kemunculannya dan karakternya. Metode ini tanpa kerugian (lossless) — data asli dapat dipulihkan sepenuhnya.

    #include <stdio.h>
    #include <string.h>
    
    int main(void) {
        char *s = "aaabbc";
        int n = strlen(s);
        for (int i = 0; i < n; ) {
            char c = s[i];
            int run = 0;
            while (i < n && s[i] == c) { run++; i++; }
            printf("%d%c", run, c);     // 3a2b1c
        }
        printf("\n");
        return 0;
    }
    

    Kesalahan umum

    • & adalah AND bitwise dan && adalah AND logika — jangan tertukar.
    • Geser kiri << 1 menggandakan nilai; geser kanan >> 1 membaginya dua.
    • Bit n memiliki nilai 1 << n (C tidak memiliki operator pangkat **); periksa status bit dengan (x >> n) & 1.
  • 14 Preprocessor & kualifier
    14.1

    Preprocessor, const, static, enum

    Preprocessor berjalan sebelum kompilasi. #define membuat makro — teks biasa yang diganti di mana saja. const membuat konstanta yang tidak dapat diubah. static di dalam fungsi mempertahankan nilai variabel antar pemanggilan. Enum (enum) memberikan nama pada sekumpulan bilangan bulat yang dimulai dari 0.

    #include <stdio.h>
    
    #define MAX 100                     // macro: text replaced before compiling
    
    enum Color { RED, GREEN, BLUE };    // named integers 0, 1, 2
    
    int next_id(void) {
        static int count = 0;           // keeps its value between calls
        count++;
        return count;
    }
    
    int main(void) {
        const double PI = 3.14;         // cannot be changed
        printf("%d %.2f\n", MAX, PI);            // 100 3.14
        printf("%d %d %d\n", RED, GREEN, BLUE);  // 0 1 2
        int a = next_id();
        int b = next_id();
        printf("%d %d\n", a, b);                 // 1 2
        return 0;
    }
    

    Program yang lebih besar dibagi menjadi beberapa file: deklarasi diletakkan dalam file header (mine.h), disertakan dengan #include "mine.h" — tanda kutip berarti file Anda sendiri, < > berarti pustaka standar. Include guard (#ifndef MINE_H / #define MINE_H / #endif) mencegah header disertakan dua kali.

    Kesalahan umum

    • #define melakukan penggantian teks biasa tanpa pengecekan tipe; bungkus tubuh makro dan argumennya dengan tanda kurung.
    • Nilai const tidak dapat diubah setelah ditetapkan.
    • Variabel lokal static mempertahankan nilainya antar pemanggilan fungsi.
    #define, const, enum, dan static menjaga kode tetap jelas
    #define, const, enum, dan static menjaga kode tetap jelas

Masuk atau buat akun

IGCSE, A-Level & AP