Opaque Data Types

/* Header non-opaque (BURUK untuk encapsulation) */
typedef struct {
    char   *nama;
    double  saldo;
} akun_t;

/* File: akun.h - Header publik dengan opaque type */
#ifndef AKUN_H
#define AKUN_H

#include <stddef.h>

/* Forward declaration - detail struct disembunyikan.
   Klien hanya pegang pointer; tidak bisa akses field internal. */
typedef struct akun akun_t;

/* Konstruktor: buat akun baru. NULL jika gagal. */
akun_t *akun_buat(const char *nama, double saldo_awal);

/* Destruktor: bebaskan akun. Set *a = NULL setelah dibebaskan. */
void akun_hancurkan(akun_t **a);

/* Mutator: setor tarik. 0=OK, -1=error (saldo negatif). */
int akun_setor(akun_t *a, double jumlah);
int akun_tarik(akun_t *a, double jumlah);

/* Aksesor: baca saldo dan nama (tidak bisa diubah). */
double       akun_saldo(const akun_t *a);
const char   *akun_nama(const akun_t *a);

#endif /* AKUN_H */

/* File: akun.c - Implementasi dengan struct lengkap (private) */
#include "akun.h"
#include <stdlib.h>
#include <string.h>

/* Detail struct hanya ada di file .c. Header hanya forward-declare.
   Klien yang #include "akun.h" tidak bisa mengakses field nama/saldo. */
struct akun {
    char   *nama;
    double  saldo;
};

akun_t *akun_buat(const char *nama, double saldo_awal)
{
    if (nama == NULL || saldo_awal < 0) return NULL;
    akun_t *a = malloc(sizeof(*a));
    if (a == NULL) return NULL;
    a->nama = malloc(strlen(nama) + 1);
    if (a->nama == NULL) {
        free(a);
        return NULL;
    }
    strcpy(a->nama, nama);
    a->saldo = saldo_awal;
    return a;
}

void akun_hancurkan(akun_t **a)
{
    if (a == NULL || *a == NULL) return;
    free((*a)->nama);
    free(*a);
    *a = NULL;
}

int akun_setor(akun_t *a, double jumlah)
{
    if (a == NULL || jumlah <= 0) return -1;
    a->saldo += jumlah;
    return 0;
}

int akun_tarik(akun_t *a, double jumlah)
{
    if (a == NULL || jumlah <= 0) return -1;
    if (a->saldo < jumlah) return -1;
    a->saldo -= jumlah;
    return 0;
}

double akun_saldo(const akun_t *a)
{
    return (a == NULL) ? 0.0 : a->saldo;
}

const char *akun_nama(const akun_t *a)
{
    return (a == NULL) ? NULL : a->nama;
}

/* File: main_akun.c - Klien memakai akun_t tanpa tahu layout struct */
#include <stdio.h>
#include "akun.h"

int main(void)
{
    akun_t *a = akun_buat("Budi", 100000.0);
    if (a == NULL) {
        fprintf(stderr, "akun_buat gagal\n");
        return 1;
    }
    printf("Awal: %-6s saldo %.2f\n", akun_nama(a), akun_saldo(a));

    akun_setor(a, 50000.0);
    printf("Setor 50000 -> saldo %.2f\n", akun_saldo(a));

    if (akun_tarik(a, 30000.0) == 0) {
        printf("Tarik 30000 -> saldo %.2f\n", akun_saldo(a));
    }
    if (akun_tarik(a, 999999.0) != 0) {
        printf("Tarik 999999 ditolak (saldo kurang)\n");
    }

    /* Baris berikut tidak akan compile karena a->saldo tidak terlihat:
       a->saldo = 0;  // error: dereferencing pointer to incomplete type
    */

    akun_hancurkan(&a);
    printf("Setelah hancurkan: %p\n", (void *)a);
    return 0;
}

gcc -std=c11 -Wall -Wextra -o demo_akun akun.c main_akun.c
./demo_akun

Awal: Budi   saldo 100000.00
Setor 50000 -> saldo 150000.00
Tarik 30000 -> saldo 120000.00
Tarik 999999 ditolak (saldo kurang)
Setelah hancurkan: (nil)

/* File: test_opaque2.c - Opaque dengan handle pattern (id integer) */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* Pola handle: alih-alih pointer ke struct opaque, klien pegang
   integer index ke tabel internal. Pola ini dipakai POSIX (int fd
   untuk file descriptor, int socket untuk socket). */

#define MAX_FD 8

typedef struct {
    int   used;
    char  nama[32];
    int   umur;
} person_t;

static person_t g_table[MAX_FD];

/* "Buka" person baru - return handle (>=0) atau -1 jika tabel penuh */
static int person_open(const char *nama, int umur)
{
    for (int i = 0; i < MAX_FD; i++) {
        if (!g_table[i].used) {
            strncpy(g_table[i].nama, nama, sizeof(g_table[i].nama) - 1);
            g_table[i].nama[sizeof(g_table[i].nama) - 1] = '\0';
            g_table[i].umur = umur;
            g_table[i].used = 1;
            return i;
        }
    }
    return -1;
}

static void person_close(int h)
{
    if (h >= 0 && h < MAX_FD) {
        g_table[h].used = 0;
    }
}

static const char *person_nama(int h)
{
    if (h < 0 || h >= MAX_FD || !g_table[h].used) return NULL;
    return g_table[h].nama;
}

static int person_umur(int h)
{
    if (h < 0 || h >= MAX_FD || !g_table[h].used) return -1;
    return g_table[h].umur;
}

int main(void)
{
    int h1 = person_open("Siti", 28);
    int h2 = person_open("Budi", 32);

    printf("h1=%d nama=%s umur=%d\n", h1, person_nama(h1), person_umur(h1));
    printf("h2=%d nama=%s umur=%d\n", h2, person_nama(h2), person_umur(h2));

    person_close(h1);
    printf("Setelah close h1, nama h1 = %s\n",
           person_nama(h1) == NULL ? "(NULL)" : person_nama(h1));

    person_close(h2);
    return 0;
}

h1=0 nama=Siti umur=28
h2=1 nama=Budi umur=32
Setelah close h1, nama h1 = (NULL)