Konstanta di C: const, #define, dan enum

Konstanta adalah nilai yang punya nama dan janji bahwa nilainya tidak akan berubah. C memberimu tiga mekanisme untuk itu, dan ketiganya benar-benar berbeda di balik layar: satu adalah variabel, satu penggantian teks, dan satu lagi tipe integer.

Kenapa Nilai Perlu Diberi Nama

Bandingkan dua baris ini:

double area = 3.14159 * r * r;
double area = PI * r * r;

Baris kedua lebih baik karena tiga alasan yang semuanya akan terasa nanti. Ia menyatakan arti angkanya. Ia muncul di tepat satu tempat, jadi mengubah presisinya cukup satu kali edit, bukan pencarian. Dan salah ketik di PI adalah error kompilasi, sedangkan salah ketik di 3.14195 adalah jawaban yang salah.

Angka tanpa nama yang tersebar di dalam kode disebut magic number, dan menghilangkannya adalah salah satu perbaikan paling murah yang bisa kamu lakukan pada program C.

const

Kata kunci const menandai sebuah variabel sebagai hanya-baca:

#include <stdio.h>

int main(void) {
    const double PI = 3.14159265358979;
    const int MAX_USERS = 100;

    double r = 2.0;
    printf("Area of r=%.1f: %.4f\n", r, PI * r * r);
    printf("Capacity: %d users\n", MAX_USERS);

    /* PI = 3.0;  <- uncomment this line and the program will not compile */
    return 0;
}

Hapus tanda komentar pada assignment itu dan compiler menolak: assignment of read-only variable 'PI'. Error saat build itulah intinya.

Variabel const adalah variabel sungguhan. Ia punya tipe, sehingga compiler memeriksa cara kamu memakainya. Ia mengikuti scope, jadi const di dalam fungsi tidak bocor ke luar. Ia punya alamat, jadi kamu bisa membuat pointer ke sana. Dan debugger bisa menampilkan nama dan nilainya.

const harus diinisialisasi di tempat deklarasi, tidak ada kesempatan kedua:

const int limit;       /* error (or garbage forever): nothing can assign to it later */
const int limit = 50;  /* correct */

#define

Alternatif dari preprocessor adalah macro:

#include <stdio.h>

#define PI 3.14159265358979
#define MAX_USERS 100
#define GREETING "Welcome to the system"

int main(void) {
    double r = 2.0;
    printf("%s\n", GREETING);
    printf("Area of r=%.1f: %.4f\n", r, PI * r * r);
    printf("Capacity: %d users\n", MAX_USERS);
    return 0;
}

Ini bukan variabel. Sebelum compiler berjalan, preprocessor mengganti setiap kemunculan PI di kode sumber dengan karakter 3.14159265358979. Compiler sama sekali tidak pernah melihat namanya, dan justru karena itulah #define tidak punya tipe dan tidak bisa muncul di debugger.

Perhatikan bahwa tidak ada titik koma dan tidak ada =. Macro adalah teks mentah, jadi kesalahan umum ini:

#define MAX_USERS 100;        /* note the semicolon */

int limit = MAX_USERS + 1;    /* expands to: int limit = 100; + 1;  -> error */

menghasilkan error di baris yang sama sekali tidak mirip dengan definisinya. Konvensi penamaan huruf besar untuk macro ada justru agar pembaca tahu ada penggantian teks yang terjadi.

Macro biasanya ditulis dalam UPPER_CASE; variabel const biasanya juga mengikuti gaya ini kalau mewakili ide yang sama.

Konstanta Enum

Bentuk ketiga memberimu sekumpulan integer bernama:

#include <stdio.h>

enum { MAX_USERS = 100, BUFFER_SIZE = 256 };

enum Weekday { MON, TUE, WED, THU, FRI };

int main(void) {
    char buffer[BUFFER_SIZE];   /* a genuine compile-time constant */

    printf("buffer holds %zu bytes\n", sizeof(buffer));
    printf("MAX_USERS = %d\n", MAX_USERS);

    enum Weekday today = WED;
    printf("MON=%d TUE=%d WED=%d, today=%d\n", MON, TUE, WED, today);
    return 0;
}

Nilainya dimulai dari 0 dan bertambah satu kecuali kamu menetapkannya, jadi MON bernilai 0 dan FRI bernilai 4. enum { ... } tanpa nama adalah pola umum untuk konstanta integer biasa.

Konstanta enum punya kelebihan nyata dibanding kedua alternatif lainnya: keduanya adalah konstanta integer saat kompilasi yang dipahami compiler, dan terlihat di debugger. Penjelasan lengkapnya ada di enum di C.

Mana yang Dipakai

Pilihan default sebaiknya const. Gunakan #define kalau nilainya harus sudah ada sebelum kompilasi, dan enum kalau kamu butuh integer saat kompilasi atau sekelompok nilai bernama.

Satu tempat di mana hal ini benar-benar terasa adalah ukuran array:

#include <stdio.h>

#define DEFINED_SIZE 5
enum { ENUM_SIZE = 5 };

int global_a[DEFINED_SIZE];   /* fine */
int global_b[ENUM_SIZE];      /* fine */

int main(void) {
    const int const_size = 5;
    int local[const_size];    /* C99 variable-length array - works here... */

    for (int i = 0; i < const_size; i++) local[i] = i * i;
    printf("local[4] = %d\n", local[4]);
    printf("globals: %zu %zu\n", sizeof(global_a), sizeof(global_b));
    return 0;
}

const int di C adalah variabel hanya-baca, bukan ekspresi konstan saat kompilasi. Di dalam fungsi, C99 menerima int local[const_size] dengan menjadikannya variable-length array; di file scope, di dalam struct, atau sebagai label case, kode itu langsung ditolak. enum dan #define bisa dipakai di mana saja.

(Ini salah satu perbedaan nyata dari C++, di mana const int adalah ekspresi konstan. Kode yang dipindah antara kedua bahasa itu sering tersandung di sini.)

const dengan Pointer

const dan pointer bisa digabung dengan tiga cara, dan artinya tidak bisa saling dipertukarkan. Baca deklarasinya dari nama ke arah luar:

const char *p;          /* p points at chars that must not be modified */
char * const q;         /* q itself cannot be re-pointed; the chars can change */
const char * const r;   /* neither the pointer nor the chars can change */

#include <stdio.h>

int main(void) {
    char text[] = "hello";

    const char *p = text;
    /* *p = 'H';  <- error: the data is const through p */
    p = "world";  /* but re-pointing p is fine */
    printf("p now points at: %s\n", p);

    char * const q = text;
    q[0] = 'H';   /* modifying the data through q is fine */
    /* q = "world";  <- error: q itself is const */
    printf("text is now: %s\n", text);
    return 0;
}

Bentuk const char * adalah yang paling sering akan kamu tulis, karena itulah tipe yang tepat untuk parameter fungsi yang membaca string tanpa mengubahnya:

#include <stdio.h>

/* The const promises the caller: this function will not modify your string. */
size_t count_vowels(const char *s) {
    size_t n = 0;
    for (size_t i = 0; s[i] != '\0'; i++) {
        char c = s[i];
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') n++;
    }
    return n;
}

int main(void) {
    printf("vowels in \"programming\": %zu\n", count_vowels("programming"));
    return 0;
}

Menambahkan const pada parameter yang hanya dibaca tidak ada biayanya dan mendokumentasikan kontraknya dengan cara yang ditegakkan compiler. Layak dilakukan di mana saja.

String Literal Pada Dasarnya const

Jebakan halus yang memang ingin ditangkap oleh const:

char *s = "hello";   /* legal C, but s points into read-only memory */
s[0] = 'H';          /* undefined behavior - usually a crash */

String literal disimpan di bagian executable yang hanya-baca. Menulis lewat pointer itu biasanya berujung segfault. Mendeklarasikan pointer-nya sebagai const char *s = "hello"; membuat compiler menolak assignment itu, alih-alih membiarkannya crash saat program berjalan.

Kalau kamu butuh string yang bisa diubah, salin ke sebuah array:

#include <stdio.h>

int main(void) {
    const char *literal = "hello";   /* read-only, cannot be modified */
    char copy[] = "hello";           /* an array: a private, modifiable copy */

    copy[0] = 'H';
    printf("literal: %s\n", literal);
    printf("copy:    %s\n", copy);
    return 0;
}