TEKNIK GENERISITAS DALAM BAHASA PEMROGRAMAN C++

MENGGUNAKAN TEMPLATE PADA IMPLEMENTASI STACK

Nanang Sadikin, Achmad Benny Mutiara

Jurusan Teknik Informatika, Fakultas Teknologi Industri, Universitas Gunadarma
Jl. Margonda Raya 100, Pondok Cina-Depok, Jawa-Barat
E-mail: amutiara@staff.gunadarma.ac.id

ABSTRAK
++
Sebagai bahasa pemrograman berorientasi obyek (OOP), C mendukung
generisitas. Generisitas merupakan konsep penggunaan berbagai macam tipe
data secara bersamaan dalam satu program yang digunakan oleh fungsi dan
++
kelas. Ada beberapa teknik generisitas yang didukung oleh C antara lain
template, #define dan polimorfisme. Dalam tulisan singkat ini, teknik generisitas
tersebut dibandingkan. Dari hasil perbandingan didapatkan kesimpulan bahwa
teknik generisitas template merupakan teknik yang paling baik, karena sederhana,
cepat dan paling luas penerapannya. Dalam tulisan ini, sebagai contoh
implementasinya adalah program stack.

Keyword: Programming, OOP, Generisitas, Stack

I. Pendahuluan
Bahasa C++ merupakan penerus bahasa C yang mendukung pemrograman berorientasi
objek (OOP, Object Oriented Programming). C++ mempunyai fasilitas template untuk
mendukung konsep generisitas. Generisitas atau kegenerikan adalah konsep baru dalam C++
yang memungkinkan program digunakan secara generik, yakni dapat digunakan untuk berbagai
tipe data. Generisitas memungkinkan terciptanya kelas atau fungsi generik. Kelas generik adalah
kelas yang salah satu data anggotanya dapat berupa sembarang tipe data, sedangkan fungsi
generik adalah suatu fungsi yang tipe parameternya dapat berupa sembarang tipe data. Kelas
atau fungsi generik ini dapat digunakan tanpa harus menulis ulang program. Jadi tujuan
generisitas adalah penghematan kode dan waktu pemrograman (Kadir 1995, Liberty 1997,
Weiskamp 1994, Hermanto 1996).

II. Teori Dasar

Data merupakan suatu hal yang penting dalam penggunaan komputer. Struktur data
adalah suatu koleksi atau kelompok data yang dapat dikarakterisasikan oleh organisasi serta
operasi yang didefinisikan terhadapnya. Array adalah sekelompok data bertipe sama yang
menduduki lokasi memori yang berurutan. Stack atau tumpukan adalah sebuah struktur data
yang menyimpan (push) dan menghapus (pop) data hanya dari ujung yang sama atau dari
puncak (top), (Wirth 1976, Hermanto 1994). Operasi push akan menambah sebanyak satu
elemen dan operasi pop akan mengurangi sebanyak satu elemen. Stack memiliki prinsip kerja
LIFO (Last In First Out). Stack diimplementasikan dalam array karena C++ tidak memiliki tipe
stack built-in.
Generisitas atau kegenerikan adalah konsep baru dalam C++ yang memungkinkan
program digunakan secara generik, yakni dapat digunakan dengan berbagai tipe data.
Generisitas memungkinkan terciptanya kelas atau fungsi generik. Kelas generik adalah kelas
yang salah satu data anggotanya dapat berupa sembarang tipe data sedangkan fungsi generik
adalah fungsi yang tipe parameternya dapat berupa sembarang tipe data, (Kadir 1995, Liberty
1997, Weiskamp 1994, Hermanto 1996). Artinya fungsi dan kelas tersebut dapat digunakan untuk
tipe int, long, char * dan sebagainya tanpa harus menulis ulang program.
Template adalah kata kunci khusus yang disediakan oleh C++ untuk menciptakan
generisitas sejati. Secara fungsional, template digunakan untuk mendefinisikan suatu tipe
generik. Sekali tipe ini didefinisikan di dalam kelas atau fungsi, kita dapat memasok tipe generik
ini dengan tipe sebenarnya (tipe aktual) saat menciptakan objek dari kelas atau saat memanggil
fungsi. Suatu kelas dengan tipe generik disebut dengan kelas generik atau kelas template dan
suatu fungsi yang menerima parameter generik disebut dengan fungsi generik atau fungsi
template, (Kadir 1995, Liberty 1997, Weiskamp 1994, Hermanto 1996).

III. Implementasi
Dalam C++ fungsi merupakan kumpulan perintah atau kode yang melakukan tugas
tertentu. Pemrograman berorientasi object mengelompokkan data dan fungsi ke dalam objek.
Objek yang sama digolongkan dalam satu kelas.
Langkah-langkah implementasi stack generik menggunakan template :

1. Deklarasi Kelas stack generik

#include <stdio.h>
#include <iostream.h>
#include <string.h>
#define MAX 20
//definisi tipe generik
template <class object>
//definisi kelas temstack
class temstack {
protected:
static unsigned stacknum; //jumlah objek stack
unsigned number; //jumlah elemen stack
object data[MAX];
public:
temstack();
virtual ~temstack();
unsigned len(void) const {return(number); };
unsigned stacklen(void) const {return(stacknum); };
void push (object);
object pop(void);
#ifdef _CHARPTR
void pop (char * ); //khusus untuk char *
#endif
};

2. Mendefinisikan Fungsi-fungsi kelas stack generik

//inisialisasi stacknum
template <class object>
unsigned temstack<object>::stacknum=0;
//konstruktor
template <class object>
temstack<object>::temstack() {
number = 0;
stacknum++;
};
//destruktor
template <class object>
temstack<object>::~temstack() {
stacknum--;
};
//definisi fungsi anggota
template <class object>
void temstack<object>::push(object gendata) {
if (number < MAX) data[number++] = gendata;
else cout << "stack overflow";
}
#ifdef _CHARPTR
//fungsi spesiifik untuk char *
void temstack<char *>::push(char * szdata ) {
if ( number < MAX ) {
//ciptakan salinan string
char *temp = new char [ strlen(szdata)+1 ];
strcpy ( temp, szdata );
//simpan penunjuknya
data[number++] = temp;
}
else cout << "stack overflow";
}
#endif
template <class object>
object temstack<object>::pop(void) {
if (number > 0 ) return (data[--number]);
else cout << " stack underflow" ;}
#ifdef _CHARPTR
//fungsi spesifik untuk char *
void temstack<char *>::pop( char * szdata) {
if ( number < MAX ) {
//kembalikan salinan string
char *temp = data [--number];
strcpy( szdata, temp );
//hapus salinan tersebut
delete[] temp;}
else cout << " stack underflow" ;}
#endif
IV. Analisis
Generisitas dapat dilakukan dengan beberapa cara, antara lain :
1. #define
2. Polimorfisme dan pewarisan
3. Template
Implementasi stack menggunakan #define dapat dilihat sebagai berikut :

#include <stdio.h>
#include <iostream.h>
#include <string.h>
#define MAX 20
class temstack {
protected:
static unsigned stacknum; //jumlah objek stack
unsigned number; //jumlah elemen stack
TYPE data[MAX];
public:
temstack();
virtual ~temstack();
unsigned len(void) const {return(number); };
unsigned stacklen(void) const {return(stacknum); };
void push (TYPE);
TYPE pop(void);
};
//inisialisasi stacknum
unsigned temstack::stacknum=0;
//konstruktor
void temstack::temstack() {
number = 0;
stacknum++;
};
//destruktor
temstack::~temstack() {
stacknum--;
};
//definisi fungsi anggota
void temstack::push(TYPE idata) {
if (number < MAX) data[number++] = idata;
else cout << "stack overflow";
}
TYPE temstack::pop(void) {
if (number > 0 ) return (data[--number]);
else cout << "stack underflow " ;
}
#define TYPE int
void main()
{
temstack stack;
stack.push(2);
stack.push(3);
stack.push(4);
while (stack.len() ) cout << stack.pop << endl;
}
 #define di atas akan mengganti TYPE dengan int. Untuk menggunakan tipe long maka
harus diganti menjadi TYPE long. Program stack generik dengan #define di atas tidak bisa
menggunakan berbagai tipe data sekaligus dan ini merupakan kelemahan #define.
Implementasi stack menggunakan polimorfisme dan pewarisan dapat dilihat sebagai
berikut :

#include <stdio.h>
#include <iostream.h>
#include <string.h>
#define MAX 20
//deklarasi kelas objek generik
class object {};
//deklarasi kelas intstack
class intstack {
protected:
static unsigned stacknum; //jumlah objek stack
unsigned number; //jumlah elemen stack
object *data[MAX];
public:
intstack();
virtual ~intstack();
unsigned len(void) const {return(number); };
unsigned stacklen(void) const {return(stacknum); };
void push (object *);
object *pop(void);
};
//inisialisasi stacknum
unsigned intstack::stacknum=0;
//konstruktor
void intstack::intstack() {
number = 0;
stacknum++;
};
//destruktor
intstack::~intstack() {
stacknum--;
};
//definisi fungsi anggota
void intstack::push(object *ptrdata) {
if (number < MAX) data[number++] = ptrdata;
else cout << "stack overflow";
}
object *intstack::pop(void) {
if (number > 0 ) return (data[--number]);
else cout << "stack overflow " ;
}
class strobject: public object {
public:
char *value;
strobject( char *szvalue ) {
value = new char [strlen (szvalue ) + 1 ];
strcpy( value, szvalue);
 };
~strobject() {
delete[] value;
}
};

void main()
{
intstack stack, stack1;
stack.push(new intobject(2) );
stack.push(new intobject(3) );
stack.push(new intobject(4) );
stack1.push(new strobject(“brothers!”) );
stack1.push(new strobject(“my”) );
stack1.push(new strobject(“Hello”) );
while (stack.len() )
cout << (intobject * ) stack.pop() ) ->value << endl;
while (stack1.len() )
cout << (strobject * ) stack1.pop() ) ->value << endl;
}

Pada program di atas, untuk menciptakan kelas generik salah satu anggota kelas intstack
didefinisikan berupa array penunjuk terhadap objek dari kelas objek generik object. Sembarang
kelas yang diturunkan dari object, dalam hal ini intobject dan strobject, sekarang dapat
dimanipulasi dengan kelas intstack.
Tidak seperti #define, dengan cara pewarisan ini kita dapat menangani objek dari kelas
yang berbeda pada waktu yang bersamaan. Tetapi, ada kerugian yang didapat, yaitu
memerlukan serangkaian operator ubahpaksa yang membuat program sulit dibaca.

V. KESIMPULAN
Dari hasil implementasi dan analisis mengenai perbandingan berbagai teknik generisitas,
maka hal-hal berikut, sepert tampak pada tabel.1, dapat disimpulkan :
Tabel 1. Perbandingan Teknik Generisitas
Teknik Generisitas Ukuran kode Waktu pemrograman Tingkat Penerapan
#define Kecil Cepat mudah Terbatas
Polimorfisme Kecil Lama rumit Luas
Template Kecil Cepat mudah Luas

VI. Daftar Pustaka

Herianto, Tjendry, 1995, Tuntunan Praktis Pemrograman C++, Elex Media Komputindo,
Jakarta.

Hermanto, S. Suryadi, 1996, Pengantar Struktur Data, Gunadarma, Edisi Pertama Cetakan
Kelima, Jakarta.
Jogiyanto, 1997, Konsep Dasar Pemrograman Bahasa C, Andi Offset, Edisi Pertama Cetakan
Kedua, Yogyakarta.

Kadir, Abdul, 1995, Pemrograman C++, Andi Offset, Edisi Pertama Cetakan Pertama,
Yogyakarta.

Liberty, Jesse, 1997, Teach YourSelf C++ in 21 Days, SAMS Publishing, Indianapolis USA.

Nugroho, Eko, 1996, Pemrograman Terstruktur dengan Pascal, Andi Offset, Edisi Pertama
Cetakan Pertama, Yogyakarta.

Sadikin, Nanang, 2000, Skripsi, Universitas Gunadarma

Weiskamp, Keith, The Borland C++ 4.0 Premier, Academic Press Inc.

Wirth, Niklaus, 1976, Algorithms + Data Structures = Programs, Prentice Hall Inc.