Saat menulis kode C sehari-hari, kita sering perlu mengingat kembali bentuk sintaks untuk berbagai konstruksi—dari deklarasi variabel, struktur kontrol, definisi fungsi, hingga deklarasi struct. Bab ini berfungsi sebagai lembar ringkas satu halaman yang merangkum sintaks C modern (C11/C17) yang paling sering kita pakai. Kita tidak akan membahas teori mendalam di sini—fokusnya adalah pola sintaks yang dapat langsung kita salin dan sesuaikan.

Deklarasi Variabel #

Variabel di C harus dideklarasikan dengan tipe data eksplisit. Kita dapat menggabungkan beberapa variabel bertipe sama dalam satu statement, menginisialisasi saat deklarasi, dan menggunakan const untuk nilai yang tidak boleh diubah.

c 
int a;                       /* belum diinisialisasi */
int b = 10;                  /* inisialisasi saat deklarasi */
int c = 20, d = 30;          /* beberapa variabel bertipe sama */
const double PI = 3.14159;   /* konstanta */
char *nama = "Budi";          /* pointer ke string literal */
static int counter = 0;       /* variabel statis (lifetime sepanjang program) */

Tipe Data Primitif #

Tabel berikut merangkum tipe data primitif standar C beserta ukuran umumnya pada platform 64-bit (Linux x86_64). Ukuran sebenarnya bergantung pada compiler dan arsitektur—kita sebaiknya menggunakan <stdint.h> jika butuh ukuran pasti.

KategoriTipeUkuran umumCatatan
Karakterchar1 byteSigned/unsigned bergantung compiler
Bilangan bulatshort2 byte
Bilangan bulatint4 byteUkuran “natural” CPU
Bilangan bulatlong8 byte (LP64) / 4 byte (LLP64)Berbeda Linux vs Windows
Bilangan bulatlong long8 byteC99, minimal 64 bit
Floating pointfloat4 byteIEEE-754 single
Floating pointdouble8 byteIEEE-754 double
Voidvoid—Tipe kosong (untuk fungsi/pointer generik)

Control Flow: Percabangan dan Perulangan #

C menyediakan lima konstruksi control flow utama: if/else, switch, for, while, dan do/while. Kita juga dapat menggunakan break untuk keluar dari loop dan continue untuk melompat ke iterasi berikutnya.

c 
/* if / else if / else */
if (x > 0) {
    printf("positif\n");
} else if (x < 0) {
    printf("negatif\n");
} else {
    printf("nol\n");
}

/* switch dengan break */
switch (kode) {
    case 1:
        printf("satu\n");
        break;
    case 2:
        printf("dua\n");
        break;
    default:
        printf("lainnya\n");
        break;
}

/* for loop dengan iterasi counter */
for (int i = 0; i < 10; i++) {
    printf("%d ", i);
}

/* while loop dengan kondisi */
while (x > 0) {
    x--;
}

/* do/while loop - minimum sekali jalan */
do {
    baca_input();
} while (!valid);

Fungsi #

Fungsi di C terdiri dari prototipe (deklarasi), definisi, dan pemanggilan. Prototipe memberitahu compiler tentang signature fungsi sebelum definisi penuh ditemukan—biasanya diletakkan di header file.

c 
/* Prototipe */
static int kuadrat(int x);

/* Definisi */
static int kuadrat(int x) {
    return x * x;
}

/* Pemanggilan */
int hasil = kuadrat(5);   /* hasil = 25 */

Bentuk umum definisi fungsi:

text 
[tipe_kembalian] [nama_fungsi]([parameter1], [parameter2], ...) {
    /* badan fungsi */
    return [nilai];
}

Jika fungsi tidak menerima parameter, gunakan void secara eksplisit (int f(void)), bukan int f()—bentuk kosong ( ) di C berarti “parameter tidak ditentukan” dan dapat menyebabkan bug halus.

Struct, Union, dan Enum #

Struct mengelompokkan beberapa field menjadi satu tipe. Union mirip struct tetapi semua field berbagi memori yang sama—hanya satu field yang aktif pada satu waktu. Enum mendefinisikan konstanta bilangan bulat bernama.

c 
/* Struct dengan typedef */
typedef struct {
    int  x;
    int  y;
} Titik;

Titik p = {3, 4};              /* inisialisasi aggregate */
p.x = 10;                       /* akses field */

/* Union */
typedef union {
    int    i;
    float  f;
} Angka;
Angka u;
u.i = 65;
printf("%c\n", (char)u.i);      /* mencetak 'A' */

/* Enum */
typedef enum { MERAH, HIJAU, BIRU } Warna;
Warna w = HIJAU;                 /* w bernilai 1 */

Pointer dan Array #

Pointer menyimpan alamat memori. Array adalah blok memori kontigu dengan tipe elemen tertentu. Nama array dapat meluruk menjadi pointer ke elemen pertama dalam banyak konteks.

c 
int  a = 42;
int *p = &a;              /* p menyimpan alamat a */
printf("%d\n", *p);       /* dereference: cetak 42 */

int arr[5] = {10, 20, 30, 40, 50};
int *q = arr;             /* arr meluruk menjadi &arr[0] */
printf("%d\n", q[2]);     /* cetak 30 */

/* Pointer arithmetic */
q++;
printf("%d\n", *q);       /* cetak 20 (arr[1]) */

Program Lengkap #

Program berikut menyatukan semua konstruksi dasar—variabel, control flow, fungsi, struct, pointer—menjadi satu contoh yang dapat kita jadikan referensi cepat.

c 
/* File: sintaks1.c - Ringkasan sintaks C */
#include <stdio.h>
#include <stdbool.h>

static int tambah(int a, int b);   /* prototipe */
static void cetak_status(bool ok);

typedef struct { char nama[32]; int umur; } Orang;
typedef enum { HARI_KERJA, HARI_LIBUR } JenisHari;

int main(void) {
    int nilai = 42;
    const char *sapa = "Halo";
    int arr[3] = {10, 20, 30};
    int *p = arr;

    printf("%s\n", sapa);

    if (nilai > 50) { printf("Besar\n"); }
    else            { printf("Kecil\n"); }

    for (int i = 0; i < 3; i++) {
        printf("arr[%d] = %d\n", i, arr[i]);
    }

    int n = 3;
    while (n > 0) { printf("n = %d\n", n); n--; }

    JenisHari hari = HARI_LIBUR;
    switch (hari) {
        case HARI_KERJA: printf("Bekerja\n"); break;
        case HARI_LIBUR: printf("Istirahat\n"); break;
        default:         printf("Tidak diketahui\n"); break;
    }

    int hasil = tambah(nilai, 8);
    printf("hasil = %d\n", hasil);

    Orang budi = {"Budi", 30};
    printf("%s berumur %d\n", budi.nama, budi.umur);
    printf("*p = %d, p[1] = %d\n", *p, p[1]);

    cetak_status(true);
    return 0;
}

static int tambah(int a, int b) { return a + b; }
static void cetak_status(bool ok) {
    printf("Status: %s\n", ok ? "OK" : "GAGAL");
}

Compile dan jalankan:

bash 
gcc -std=c11 -Wall -Wextra -o sintaks1 sintaks1.c
./sintaks1

Output yang Dihasilkan:

text 
Halo
Kecil
arr[0] = 10
arr[1] = 20
arr[2] = 30
n = 3
n = 2
n = 1
Istirahat
hasil = 50
Budi berumur 30
*p = 10, p[1] = 20
Status: OK

Mari kita telaah baris-baris kode di atas:

  1. Baris 4-5 (static int tambah(...) dan static void cetak_status(...)): Prototipe fungsi dideklarasikan dengan static agar hanya terlihat di dalam file ini (linkage internal). Praktik baik untuk fungsi pembantu private.
  2. Baris 7 (typedef struct { ... } Orang;): Kita menggabungkan deklarasi struct dan typedef dalam satu statement—bentuk yang paling sering dipakai di kode modern.
  3. Baris 17 (int *p = arr;): Nama array arr meluruk menjadi pointer ke elemen pertama. Assignment ini menyebabkan p dan arr menunjuk ke lokasi memori yang sama.
  4. Baris 24 (for (int i = 0; i < 3; i++)): Loop counter i dideklarasikan di dalam for—legal sejak C99. Lingkup i terbatas pada blok loop.
  5. Baris 38-39 (Orang budi = {"Budi", 30};): Inisialisasi aggregate dengan urutan field sesuai deklarasi struct.