2.

Abstract Data Type (ADT)

Sebuah program dalam bahasa C yang "utuh", seringkali terdiri dari beberapa modul program.
Sebuah modul mungkin mewakili sekumpulan rutin sejenis, ADT (Abstract Data Type: definisi
type dan primitifnya), atau mesin (definisi state variable dari mesin dan primiritfnya).

Pada hakekatnya sebuah program utuh terdiri dari kelompok file sebagai berikut:
1. File header, dengan nama xxx.h. Untuk setiap type dan primitifnya, ada sebuah file xxx.h.
Contoh:
Jika anda memerlukan ADT JAM, DATE dan mesin KATA maka ada 3 buah file header
yaitu Jam.h, DATE.h dan KATA.h

2. File yang berisi BODY dari File header yang bersangkutan: xxx.c. File ini disebut sebagai
file realisasi dari prototype yang didefinisikan pada xxx.h. Akan ada sebuah xxx.c untuk
setiap xxx.h.
Untuk contoh di atas, akan ada JAM.c, DATE.c dan KATA.c.

3. File yang berisi main program (dan prosedur/fungsi lain yang hanya dibutuhkan oleh main),
misalnya dengan nama main.c

Contoh program dalam beberapa file atau biasa disebut dengan modul. Modul berikut adalah
untuk manipulasi jam :

File Deskripsi isi

jam.h Type dan prototype Jam
jam.c Realisasi (body) dari jam.h
mjam.c Main program untuk mentest beberapa fungsi/prosedur pada jam.c

/* File : jam.h */
/* deklarasi TYPE dan prototype type jam */
#ifndef jam_H
#define jam_H

typedef struct {
int HH;
int MM;
int SS;
}jam;

/* prototype */
void ResetJam (jam * J);
/* Mengisi sebuah jam J dengan 00:00:00 */
void TulisJam (jam J);
/* menulis sebuah jam */
int JamToDetik (jam J);
/* konversi jam ke detik */
jam DetikToJam (int d);
/* konversi dari detik menjadi jam */

#endif
/* File : jam.c */
/* Body prototype type jam */

#include "jam.h"

/* BODY prototype */
void ResetJam (jam * J)
/* Mengisi sebuah jam J dengan 00:00:00 */
{
/* KAMUS LOKAL */
/* ALGORITMA */
(*J).HH = 0;
(*J).MM = 0;
(*J).SS = 0;
}

void TulisJam (jam J)

/* menulis sebuah jam */
{
/* KAMUS LOKAL */
/* ALGORITMA */
printf ("Jam : %2d:%2d:%2d\n", J.HH, J.MM, J.SS);
}

int JamToDetik (jam J)

/* konversi jam ke detik */
{
/* KAMUS LOKAL */
/* ALGORITMA */
return (J.HH * 3600 + J.MM * 60 + J.SS);
}

jam DetikToJam (int d)

/* konversi dari detik ke struktur jam */
{
/* KAMUS LOKAL */
jam J;
int sisa;

/* ALGORITMA */
J.HH = d / 3600;
sisa = d % 3600;
J.MM = sisa / 60;
J.SS = sisa % 60;
return J;
}

/* File : mjam.c */
/* memanfaatkan primitif jam */
#include "jam.h"

int main ()
{/* KAMUS */
jam J1;
jam J2;
int dt=1000;
/* PROGRAM */
printf ("hello\n");
ResetJam (&J1);
 TulisJam (J1);
printf("Konversi jam ke detik: %d\n",JamToDetik(J1));
J2=DetikToJam(dt);
TulisJam(J2);
return 0;
}

Studi kasus
1. Dari contoh modul di atas, representasikan jam.c di atas kedalam jam dengan format am/pm

ADT GARIS dalam bahasa algoritma

/* ADT Garis “garis.h” */
{contoh ADT yang memanfaatkan ADT lain}
{Definisi : GARIS dibentuk oleh dua buah POINT yang berbeda}
{*** ADT lain yang dipakai ***}
USE POINT
{********************* Definisi TYPE **************************}
TYPE GARIS : <PAw :POINT, {Titik AWal}
PAkhr : POINT, {Titik Akhir}
>
{********************* Definisi METHOD ************************}
{DEFINISI PRIMITIF }
{** Kontruksi membuka GARIS **}

procedure MakeGARIS (Input P1, P2 : POINT, output L :GARIS)

{I.S P1 dan P2 terdefinisi}
{F.S L terdefinisi dengan L.PAw = P1 dan L.PAkh = P2}
{Membentuk sebuah L dari komponen-komponennya}

{** Selektor GARIS **}

function GetPAw(G :GARIS)POINT
{Mengirimkan komponen titik pertama dari L GARIS}

function GetPAkh(G : GARIS)POINT

{Mengirimkan komponen titik kedua dari L GARIS}

{** set nilai komponen **}

procedure SetPAw(Input/Output G :GARIS, Input newPAw : POINT)
{Mengubah nilai komponen PAw dari G}

procedure SetPAkh(Input/Output G :GARIS, Input newPAkh: POINT)

{Mengubah nilai komponen PAkh dari G}

{** KELOMPOK Interaksi dengan I/O device, BACA/TULIS **}

procedure BacaGARIS(Output L : GARIS)
{I.S sembarang}
{F.S mengulangi membaca dua buah nilai P1 dan P2 sehingga dapat
membentuk GARIS yang valid}
{MakeGARIS(P1,P2) dari P1 dan P2 yang dibaca}

procedure TulisGARIS(Input L : GARIS)

{Nilai L ditulis kelayar dengan format (x1, y1), (x2, y2)}

{** Kelompok operasi relasional terhadap GARIS **}

function EQ(L1, L2 : GARIS)boolean;
{Mengirimkan true jika L1 = L2}
{L1 dikatakan sama dengan L2 jika titik awal L1 = titik awal L2}
{dan titik akhir L1 = titik akhir L2}
 function NEQ(L1, L2 : GARIS)boolean
{Mengirimkan true jika L tidak sama dengan L}
{Negasi dari fungsi EQ}

{** Kelompok menentukan dimana L berada}

function IsOnSbX(L : GARIS)boolean
{menghasilkan true jika L terletak pada sumbu X}

function IsOnSbY(L : GARIS)boolean

{menghasilkan true jika L terletak pada sumbu Y}

{** Kelompok predikat lain **}

function IsTegakLurus (L1, L2 : GARIS)boolean
{Menghasilkan true jika L tegak lurus terhadap L1}

function IsSejajar (L1, L2 : GARIS)boolean

{Menghasilkan true jika L 'sejajar' terhadap L1}

{** Kelompok operasi lain **}

function HslGeser (L : GARIS, DX, DY : integer)GARIS
{Menghasilkan salinan L yang titik awal dan akhirnya digeser
sejauh DX dan DY}

function MirrorOf (L : GARIS, SbX, SbY : boolean)GARIS

{Menghasilkan salinan L yang dicerminkan}
{tergantung nilai SbX dan SbY}
{Jika SbX bernilai true, maka dicerminkan thd sumbu X}
{Jika SbY bernilai true, maka dicerminkan thd sumbu Y}

function Panjang (L : GARIS)real

{Menghitung panjang garis L :berikan rumusnya}

function Arah (L : GARIS)real

{Menghitung arah dari garis L}
{yaitu sudut yang dibentuk dengan sumbu X+}

function Panjang (L : GARIS)real

{Menghitung panjang garis L :berikan rumusnya}

function SudutGaris(L1, L ; GARIS)real

{Menghasilkan sudut perpotongan antara L dengan L1}
{Precondition : L tidak sejajar dengan L1 dan}
{ L tidak berimpit dengan L1}

procedure Geser(Input/Output L : GARIS, Input : DeltaX, DeltaY :

integer)
{I.S L terdefinisi}
{F.S L digeser sebesar DeltaX dan ordinatnya sebesar DeltaY}
{PAw dan PAkh digeser}

prosedure Mirror(Input/Output L : GARIS, Input : SbX, SbY :

boolean)
{I.S L terdefini)
{F.S L dicerminkan tergantung nilai SbX atau SbY}
{Jika SbX true maka dicerminkan terhadap sumbu X}
{Jika SbY true maka dicerminkan terhadap sumbu Y}
{L dicerminkan tergantung nilai SbX dan SbY}

Dari Algoritma ADT Garis diatas, implementasikan kedalam bahasa C sehingga

menjadi modul lengkap (Garis.h, Garis.c mainGaris.c).
Catatan implementasi :
 Dalam implementasi dengan bahasa C “USE” ADT POINT menjadi “include” file
header dari ADT yang dipakai. Itu berarti ADT POINT dibuat terlebih dahulu.
 Constraint/invariant, tidak dapat dituliskan tetapi menjadi sebuah fungsi yang akan
memerika validasi Paw dan PAkh, sehingga dapat membentuk sebuah GARIS (lihat
contoh jam)
File header untuk ADT Point
/* Program : Point.h */
/* Deskripsi : Spesifikasi ADT Point*/
/* Author : */
/* Tanggal/Versi : */

#ifndef POINT_H
#define POINT_H

/* definisi type data POINT */

typedef struct {
int x;
int y;
} POINT;

/* PROTOTYPE */
/*KELOMPOK CREATOR */
void MakePoint(POINT *P, int XX, int YY);
/*Prosedur untuk membuat POINT dengan nilai dari user*/

POINT CreatePoint(int XX, int YY);

/*Fungsi untuk menghasilkan sebuah POINT berdasarkan nilai-nilai
dari user*/

/*KELOMPOK VALIDASI*/
/* Tidak ada Validasi, Asumsi : koordinat Point tidak terbatas*/

/*KELOMPOK GET/SET */
int GetX(POINT P);
/*mengembalikan nilai X dari sebuah Point P */

int GetY(POINT P);

/*mengembalikan nilai Y dari sebuah Point P */

void SetX(POINT *P);

/*memberikan/mengubah nilai X dari sebuah Point P */

void SetY(POINT *P);

/*memberikan/mengubah nilai Y dari sebuah Point P */

/*KELOMPOK PRINT/CETAK*/

void PrintPoint(POINT P);

/* Menampilkan POINT dengan format (x,y) */

/*KELOMPOK LAIN */

boolean IsEqual(POINT P1, POINT P2);

/*Mengembalikan True jika P1 = P2, dan False jika sebaliknya */

int Kuadran(POINT P);

/* menghasilkan kuadran dari POINT P*/

boolean IsOnSumbuX(POINT P);

/* Mengirimkan True jika P ada di sumbu X */

boolean IsOnSumbuY(POINT P);

/* Mengirimkan True jika P ada di sumbu Y */

boolean IsOrigin(POINT P);

/* Mengirimkan True jika P ada di titik pusat */

void NextX(POINT *P);

/* Menggeser P 1 koordinat ke kanan*/
void PrevX(POINT *P);
/* Menggeser P 1 koordinat ke kiri*/
void NextY(POINT *P);
/* Menggeser P 1 koordinat ke atas*/
void PrevY(POINT *P);
/* Menggeser P 1 koordinat ke bawah*/

void NextX_N(POINT *P, int N);

/* Menggeser P, sejauh N koordinat ke kanan*/
void PrevX_N(POINT *P, int N);
/* Menggeser P, sejauh N koordinat ke kiri*/
void NextY_N(POINT *P, int N);
/* Menggeser P, sejauh N koordinat ke atas*/
void PrevY_N(POINT *P, int N);
/* Menggeser P, sejauh N koordinat ke bawah*/

/*MENGHITUNG JARAK DUA POINT */

float Jarak (POINT P1, POINT P2);
/*Menghasilkan jarak P1 dan P2 */