Macro function-like adalah macro yang menerima parameter—secara tampilan menyerupai fungsi, tetapi secara mekanisme tetap berupa substitusi teks oleh preprocessor. Fasilitas ini berguna untuk operasi kecil yang ingin kita hindari overhead pemanggilan fungsi, atau untuk operasi generik yang harus bekerja pada banyak tipe data (mis. MAX antara dua int, dua double, atau dua char). Namun, karena tidak ada pemeriksaan tipe dan tidak ada evaluation order seperti fungsi biasa, macro berparameter sarat jebakan. Pada chapter ini kita akan mempelajari cara mendefinisikan macro berparameter, kewajiban menambahkan tanda kurung di sekitar parameter, dan bahaya side effect ganda saat argumen mengandung operator ++ atau pemanggilan fungsi.

Definisi dan Sintaks Dasar #

Macro function-like didefinisikan dengan menempatkan tanda kurung (...) tepat setelah nama macro—tanpa spasi. Daftar parameter di dalam kurung adalah nama formal yang akan diganti dengan argumen aktual saat macro dipakai. Standar ISO/IEC 9899 §6.10.3 menetapkan aturan ini: jika ada spasi antara nama macro dan kurung buka, macro tersebut menjadi object-like dengan nilai yang mengandung kurung.

c 
#include <stdio.h>

/* Macro function-like dengan satu parameter */
#define KUADRAT(x) ((x) * (x))

/* Macro function-like dengan dua parameter */
#define MAX(a, b) ((a) > (b) ? (a) : (b))

/* Macro dengan tanda kurung ekstra untuk mencegah precedence bug */
#define KALI_DAN_TAMBAH(a, b, c) (((a) * (b)) + (c))

int main(void) {
    int n = 5;
    printf("KUADRAT(5)   = %d\n", KUADRAT(5));
    printf("KUADRAT(n+1) = %d\n", KUADRAT(n + 1));   /* Aman: (n+1) dikelilingi kurung */
    printf("MAX(3, 7)    = %d\n", MAX(3, 7));
    printf("MAX(3.5, 2)  = %.2f\n", MAX(3.5, 2));     /* Generic untuk tipe apapun */
    printf("KALI_DAN_TAMBAH(2,3,4) = %d\n", KALI_DAN_TAMBAH(2, 3, 4));

    return 0;
}

Output yang Dihasilkan:

text 
KUADRAT(5)   = 25
KUADRAT(n+1) = 36
MAX(3, 7)    = 7
MAX(3.5, 2)  = 3.50
KALI_DAN_TAMBAH(2,3,4) = 10

Perhatikan bahwa MAX(3.5, 2) mengembalikan 3.50—bekerja pada tipe double tanpa perlu template seperti di C++. Ini adalah salah satu daya tarik utama macro berparameter: sifat generik tanpa overhead.

Kenapa Tanda Kurung Wajib di Sekitar Parameter? #

Mari kita lihat apa yang terjadi jika kita melupakan tanda kurung. Misalkan kita mendefinisikan #define KUADRAT_BURUK(x) x * x (tanpa tanda kurung di sekitar x). Saat macro dipanggil dengan KUADRAT_BURUK(n + 1), preprocessor menghasilkan n + 1 * n + 1. Karena operator * memiliki precedence lebih tinggi dari +, ekspresi dievaluasi sebagai n + (1 * n) + 1 = n + n + 1, yang sama sekali berbeda dari (n+1) * (n+1).

Mari kita telaah baris-baris macro KUADRAT(x) yang benar:

  1. Baris #define KUADRAT(x) ((x) * (x)): tanda kurung terluar ((x) * (x)) melindungi seluruh ekspresi agar tidak tercampur dengan operator di sekitarnya saat macro dipakai dalam ekspresi yang lebih besar. Tanda kurung dalam (x) melindungi parameter x sendiri jika argumen adalah ekspresi seperti n + 1.
  2. Baris #define MAX(a, b) ((a) > (b) ? (a) : (b)): macro ini menggunakan operator ternary ?:. Tanpa tanda kurung luar, pemanggilan if (MAX(x, y) > 0) akan menghasilkan kode ambigu yang dapat di-parses secara salah.
  3. Baris #define KALI_DAN_TAMBAH(a, b, c) (((a) * (b)) + (c)): macro tiga parameter. Setiap parameter dikelilingi tanda kurung, dan seluruh sub-ekspresi (a) * (b) juga dikelilingi tanda kurung agar urutan evaluasi sesuai harapan.

Jebakan Side Effect Ganda #

Karena macro adalah substitusi teks, argumen yang dievaluasi dapat muncul lebih dari sekali pada hasil ekspansi. Jika argumen mengandung side effect seperti i++ atau pemanggilan fungsi yang mengubah state, side effect tersebut akan dipicu untuk setiap kemunculan argumen pada badan macro. Inilah perbedaan paling fundamental antara macro dan fungsi biasa.

c 
#include <stdio.h>

#define MAX(a, b) ((a) > (b) ? (a) : (b))

int main(void) {
    int i = 1, j = 5;
    /* BUG side effect ganda: i++ dievaluasi 2 kali */
    int m = MAX(i++, j++);

    printf("m = %d, i = %d, j = %d\n", m, i, j);
    return 0;
}

Output yang Dihasilkan:

text 
m = 6, i = 2, j = 7

Setelah preprocessing, baris int m = MAX(i++, j++); menjadi:

text 
int m = ((i++) > (j++) ? (i++) : (j++));

Mari kita telaah apa yang terjadi pada baris di atas:

  1. Tahap 1 (evaluasi kondisi): ekspresi (i++) > (j++) dievaluasi. i bernilai 1, lalu naik menjadi 2. j bernilai 5, lalu naik menjadi 6. Nilai perbandingan: 1 > 5 adalah false.
  2. Tahap 2 (cabang false dieksekusi): karena kondisi false, operator ternary memilih cabang kanan (j++). Pada titik ini j sudah bernilai 6 (akibat evaluasi kondisi), jadi j++ mengembalikan 6 dan menaikkan j menjadi 7. Nilai 6 inilah yang dimasukkan ke m.
  3. Tahap 3 (cabang true tidak dieksekusi): (i++) pada cabang true tidak dievaluasi sama sekali. Inilah alasan i hanya naik sekali menjadi 2, bukan menjadi 3.

Jika kita menulis MAX sebagai fungsi biasa int max(int a, int b), argumen i++ dan j++ akan dievaluasi sekali sebelum dipakai sebagai parameter. Hasil yang diharapkan—m=5, i=2, j=6—jauh berbeda dari hasil macro yang sebenarnya m=6, i=2, j=7. Perbedaan ini sering menjadi sumber bug yang sangat sulit dilacak.