Menulis C portabel adalah keterampilan yang menggabungkan pilihan tipe data yang tepat, abstraksi platform lewat macro, dan disiplin menghindari asumsi platform-specific. Kode portabel dapat dikompilasi di GCC, Clang, MSVC, dan compiler embedded tanpa perubahan sumber—hanya konfigurasi build yang berbeda. Bab penutup section ini merangkum praktik terbaik yang sudah kita pelajari di bab-bab sebelumnya: pakai stdint.h untuk tipe integer eksak, size_t untuk ukuran buffer, intptr_t untuk pointer arithmetic, _Static_assert untuk invariant compile-time, dan serialisasi byte-per-byte untuk format biner. Kita juga akan melihat pola abstraksi platform yang memisahkan kode bisnis dari panggilan sistem operasi, sehingga kode dapat dipindahkan antara Linux, Windows, dan embedded tanpa duplikasi.

Praktik 1: Tipe Eksak dan size_t #

Praktik paling dasar portabilitas adalah memilih tipe berdasarkan kontrak, bukan asumsi platform. Untuk ukuran buffer, gunakan size_t (bukan int). Untuk integer dengan lebar eksak, gunakan int32_t/int64_t/uint8_t dari stdint.h. Untuk menyimpan pointer sebagai integer, gunakan uintptr_t (bukan long atau int). Untuk akumulasi yang bisa overflow, gunakan tipe lebih besar (mis. int64_t untuk akumulasi int32_t):

c 
// File: portabel_1.c - Praktik terbaik: stdint, size_t, dan tipe portabel
#include <stdio.h>
#include <stdint.h>
#include <stddef.h>

// Pola: parameter ukuran selalu size_t
static size_t hitung_jumlah_huruf(const char *s, size_t panjang_max) {
    size_t count = 0;
    for (size_t i = 0; i < panjang_max && s[i] != '\0'; ++i) {
        if ((s[i] >= 'A' && s[i] <= 'Z') ||
            (s[i] >= 'a' && s[i] <= 'z')) {
            ++count;
        }
    }
    return count;
}

// Pola: return status code, hasil via pointer out-param
static int hitung_rata2(const int32_t *data, size_t n, int64_t *hasil) {
    if (data == NULL || hasil == NULL || n == 0) {
        return -1;   // argumen tidak valid
    }
    int64_t total = 0;
    for (size_t i = 0; i < n; ++i) {
        total += data[i];   // int64_t aman dari overflow untuk akumulasi int32
    }
    *hasil = total / (int64_t)n;
    return 0;
}

int main(void) {
    char buf[] = "Halo Dunia 12345!";
    size_t n = hitung_jumlah_huruf(buf, sizeof buf);
    printf("String        : '%s'\n", buf);
    printf("Jumlah huruf  : %zu\n", n);

    int32_t nilai[] = {85, 90, 78, 92, 88};
    int64_t rata;
    if (hitung_rata2(nilai, 5, &rata) == 0) {
        printf("Rata-rata     : %lld\n", (long long)rata);
    }

    // Pola: intptr_t/uintptr_t untuk pointer arithmetic portabel
    int x = 42;
    uintptr_t addr = (uintptr_t)&x;
    printf("\nAlamat x      : 0x%lx\n", (unsigned long)addr);
    int *p = (int *)addr;   // cast balik, well-defined via uintptr_t
    printf("Nilai via addr: %d\n", *p);

    return 0;
}

Compile dan jalankan:

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

Output yang Dihasilkan:

text 
String        : 'Halo Dunia 12345!'
Jumlah huruf  : 9
Rata-rata     : 86

Alamat x      : 0x7fff02354924
Nilai via addr: 42

Mari kita telaah baris-baris kode di atas:

  1. Baris 8-17 (size_t hitung_jumlah_huruf(const char *s, size_t panjang_max)): Fungsi menerima string dan batas panjang sebagai size_t. Return value juga size_t. Tipe int akan overflow di objek besar (>2GB di 32-bit); size_t selalu cukup besar karena definisinya adalah “tipe yang dapat menyimpan ukuran objek apapun di memori”.
  2. Baris 20-30 (static int hitung_rata2(..., int64_t *hasil)): Pola return status code (0 untuk sukses, -1 untuk error) dengan hasil dikembalikan via pointer out-parameter. Akumulasi di int64_t agar tidak overflow saat menjumlahkan banyak int32_t—dengan int64_t, kita bisa menjumlahkan hingga 2^32 angka INT32_MAX tanpa overflow.
  3. Baris 38-42 (uintptr_t addr = (uintptr_t)&x;): Untuk menyimpan alamat pointer sebagai integer (mis. untuk hashing, ID, atau debug print), gunakan uintptr_t—bukan long atau int. Di Windows 64-bit, long hanya 4 byte sehingga tidak cukup menyimpan pointer 8-byte. uintptr_t selalu cukup besar.
  4. Baris 44 (int *p = (int *)addr;): Cast balik dari uintptr_t ke pointer bersifat well-defined. Ini berguna untuk menyimpan pointer di struktur data generik (mis. hashmap yang memakai uintptr_t sebagai key).

Praktik 2: Abstraksi Platform dan Serialisasi Eksplisit #

Untuk kode yang memanggil API sistem operasi (file I/O, threading, networking), pisahkan panggilan platform-specific ke lapisan abstraksi dengan macro. Kode bisnis hanya memanggil fungsi abstrak, bukan API sistem operasi langsung. Untuk format data biner yang dipertukarkan antar mesin, gunakan serialisasi byte-per-byte eksplisit dengan _Static_assert untuk memastikan layout struct konsisten:

c 
// File: portabel_2.c - Praktik terbaik: abstraksi platform dan serialisasi
#include <stdio.h>
#include <stdint.h>
#include <string.h>

// Pola: abstraksi platform via macro - hindari #ifdef berantakan di kode bisnis
#if defined(_WIN32)
#  define PLATFORM_WINDOWS 1
#  include <windows.h>
   typedef HANDLE file_handle_t;
#elif defined(__linux__)
#  define PLATFORM_LINUX 1
#  include <unistd.h>
#  include <fcntl.h>
   typedef int file_handle_t;
#else
#  define PLATFORM_UNKNOWN 1
   typedef int file_handle_t;
#endif

// Pola: tipe data dipilih berdasarkan kontrak, bukan asumsi platform
typedef struct {
    uint32_t magic;        // 4 byte, eksak
    uint32_t version;      // 4 byte, eksak
    uint64_t timestamp;    // 8 byte, eksak
    char     name[32];     // 32 byte, eksak
} PacketHeader;

// Static assert: pastikan layout struct konsisten
_Static_assert(sizeof(PacketHeader) == 48, "PacketHeader harus 48 byte");

// Pola: serialisasi eksplisit (big-endian) - tidak tergantung endianness mesin
static void packet_to_bytes(const PacketHeader *p, unsigned char *buf) {
    uint32_t magic = p->magic;
    uint32_t ver   = p->version;
    uint64_t ts    = p->timestamp;

    // Tulis magic dan version big-endian
    buf[0] = (unsigned char)(magic >> 24);
    buf[1] = (unsigned char)(magic >> 16);
    buf[2] = (unsigned char)(magic >>  8);
    buf[3] = (unsigned char)(magic      );
    buf[4] = (unsigned char)(ver   >> 24);
    buf[5] = (unsigned char)(ver   >> 16);
    buf[6] = (unsigned char)(ver   >>  8);
    buf[7] = (unsigned char)(ver        );
    // Tulis timestamp big-endian (8 byte)
    for (int i = 0; i < 8; ++i) {
        buf[8 + i] = (unsigned char)(ts >> (56 - 8*i));
    }
    // Name: copy langsung (already portable byte array)
    memcpy(buf + 16, p->name, 32);
}

int main(void) {
    PacketHeader p = {
        .magic = 0xDEADBEEF,
        .version = 0x00010002,
        .timestamp = 0x123456789ABCDEF0ULL,
        .name = "test packet"
    };

    unsigned char buf[sizeof(PacketHeader)];
    packet_to_bytes(&p, buf);

    printf("sizeof(PacketHeader) = %zu\n", sizeof(PacketHeader));
    printf("Bytes 0-7 (magic+ver): ");
    for (size_t i = 0; i < 8; ++i) printf("%02x ", buf[i]);
    printf("\nBytes 8-15 (timestamp): ");
    for (size_t i = 8; i < 16; ++i) printf("%02x ", buf[i]);
    printf("\nBytes 16+ (name)       : %.16s...\n", buf + 16);

    return 0;
}

Compile dan jalankan:

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

Output yang Dihasilkan:

text 
sizeof(PacketHeader) = 48
Bytes 0-7 (magic+ver): de ad be ef 00 01 00 02 
Bytes 8-15 (timestamp): 12 34 56 78 9a bc de f0 
Bytes 16+ (name)       : test packet...

Pada contoh di atas, PacketHeader memakai tipe uint32_t dan uint64_t yang ukurannya eksak di platform apapun. _Static_assert(sizeof(PacketHeader) == 48, ...) memverifikasi bahwa total ukuran struct adalah 48 byte—jika ada compiler yang menambah padding tidak terduga, build gagal dengan pesan yang jelas. Fungsi packet_to_bytes menulis setiap field ke buffer dalam urutan big-endian (network byte order) menggunakan operasi shift—kode ini menghasilkan output yang sama baik di mesin little-endian (x86) maupun big-endian (SPARC).

Ringkasan Praktik Portabilitas #

Berikut ringkasan praktik terbaik yang sudah kita pelajari sepanjang section ini:

AreaPraktikBab Penjelasan
StandarPilih -std=c17 -pedantic untuk proyek barumemilih-language-standard
Fitur compilerBungkus ekstensi GCC dengan __has_attribute/__has_builtinfitur-compiler-extensions
Deteksi fiturGunakan __STDC_VERSION__ dan __has_includeconditional-feature-support
Tipe integerPakai int32_t/int64_t dari stdint.h, bukan int/longportability-checks
Ukuran bufferPakai size_t, bukan intportability-checks
Pointer arithmeticPakai uintptr_t/intptr_tmenulis-c-portabel
EndiannessSerialisasi byte-per-byte eksplisitendianess-dan-representasi-data
OverflowCek eksplisit sebelum operasi signedportability-checks
Char signnessPakai unsigned char/uint8_t untuk byte dataportability-checks
KonstantaPakai INT32_MAX, SIZE_MAX dari header, bukan magic numberportability-checks
Invariant compile-time_Static_assert untuk layout structc11
KonkurensiPakai stdatomic.h (C11+), bukan inline assemblyc11
Pointer nullGunakan nullptr di C23, NULL di C17 sebelumnyac23