C Handout · ⁨C Lembar Kerja⁩

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

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:

scanf("%d", &n) membaca input keyboard dengan penanda yang sama (perhatikan tanda &). Saudaranya sscanf menafsirkan nilai dari sebuah string, sehingga dapat dijalankan di mana saja:

#include <stdio.h>

int main(void) {
    char line[] = "Mei 88";
    char name[20];
    int score;
    sscanf(line, "%19s %d", name, &score);   // parse text -> values
    printf("%s scored %d\n", name, score);   // Mei scored 88
    return 0;
}

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

• Setiap pernyataan diakhiri dengan ;, dan main harus 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 akan mencetak sampah — cocokkan dengan tipenya.

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

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.

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

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

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.

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

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.

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

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

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.
• Nama array adalah pointer ke elemennya pertama; sizeof hanya memberikan ukuran dalam jangkauan array itu sendiri.

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).

#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.

A C string 字符串 is an array of char. Every string ends with a hidden null terminator 空终止符 '\0', which marks where it stops. strlen (from <string.h>) counts characters up to that '\0'. Print a whole string with %s and one character 字符 with %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;
}

You can traverse a string by looping until you reach '\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;
}

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.

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>.

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

int main(void) {
    int n = 3;
    int *a = malloc(n * sizeof(int));    // room for 3 ints
    for (int i = 0; i < n; i++) a[i] = i * 10;

    a = realloc(a, 4 * sizeof(int));     // grow to 4 ints
    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.

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.

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

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.

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
}

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

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.

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
    fprintf(out, "Alice 80\nBob 95\n");
    fclose(out);

    FILE *in = fopen("scores.txt", "r");    // open for reading
    char name[20];
    int score;
    while (fscanf(in, "%s %d", name, &score) == 2) {
        printf("%s -> %d\n", name, score);
    }
    fclose(in);
    return 0;
}

C tidak memiliki pengecualian. Sebagai gantinya, sebuah fungsi menandakan kegagalan dengan kode pengembalian — secara konvensi 0 berarti sukses dan non-nol berarti kesalahan. Pemanggil memeriksa kode sebelum mempercayai hasilnya. (fopen mengikuti ide yang sama: ia mengembalikan 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.

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

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 bitwise AND dan && adalah logical AND — jangan bingung将它们混淆它们。
• 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.

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.