OBJEK

Pemrograman Berorientasi Objek WAGITO
PEMROGRAMAN BERORIENTASI OBJEK

Teori dan Aplikasi dengan C++ berbasis Windows dan Linux
oleh: WAGITO
(wagito@akakom.ac.id)
1
Daftar Isi
Daftar Isi..................................................................................................................................................... 2
Daftar Tabel................................................................................................................................................ 4
Daftar Gambar............................................................................................................................................ 5
Kata Pengantar.......................................................................................................................................... 6
I.PENDAHULUAN....................................................................................................................................... 8
1.Pemrograman Berorientasi Objek Dengan C++....................................................................................8
2.Perkembangan Bahasa C++................................................................................................................. 9
Pertanyaan dan Tugas.......................................................................................................................... 9
II.DASAR PEMROGRAMAN..................................................................................................................... 11
A.Bentuk Umum Program C++............................................................................................................... 11
2.Menuliskan Program Dalam Beberapa Versi C++...............................................................................13
Borland C++ dan Turbo C++.............................................................................................................. 13
Borland C++ Builder........................................................................................................................... 13
GNU C++ (Redhat 8.0, Mandrake 9.0, Slackware 9.0)......................................................................15
3.Pengenal............................................................................................................................................. 16
4.Reserved Word................................................................................................................................... 17
5.Tipe Data............................................................................................................................................. 17
6.Variabel............................................................................................................................................... 19
7.Konstanta............................................................................................................................................ 20
8.Operator.............................................................................................................................................. 21
Operator Aritmetika............................................................................................................................. 21
Operator Logika.................................................................................................................................. 21
Operator Penaikan dan Penurunan.................................................................................................... 21
Operator Relasional............................................................................................................................ 22
9.Operator Penugasan dan Penugasan Khusus....................................................................................23
10.Perintah Input/Output........................................................................................................................ 23
Pertanyaan dan Tugas........................................................................................................................ 27
III.STRUKTUR KONDISIONAL................................................................................................................. 28
A.Bentuk if pertama............................................................................................................................... 28
2.Bentuk if kedua................................................................................................................................... 29
3.Bentuk if ketiga (if bertumpuk)............................................................................................................ 31
4.switch.................................................................................................................................................. 32
IV.PERULANGAN..................................................................................................................................... 36
A.Struktur do-while................................................................................................................................. 36
2.Struktur while...................................................................................................................................... 38
3.Struktur for.......................................................................................................................................... 39
4.Perintah break, continue dan exit ().................................................................................................... 42
V.TIPE DATA TERSTRUKTUR................................................................................................................. 46
A.Larik.................................................................................................................................................... 46
2.Pointer................................................................................................................................................. 51
3.Struktur............................................................................................................................................... 55
4.Union................................................................................................................................................... 57
VI.FUNGSI................................................................................................................................................ 60
A.Fungsi................................................................................................................................................. 60
2.Variabel Lokal dan Variabel Eksternal................................................................................................. 63
3.Parameter........................................................................................................................................... 64
4.Rekursi................................................................................................................................................ 67
2
VII.KELAS................................................................................................................................................. 71
A.Lebih Lanjut Tentang Struktur............................................................................................................. 71
2.Kelas................................................................................................................................................... 75
3.Konstruktor dan Destruktor................................................................................................................. 81
4.Data Anggota Kelas............................................................................................................................ 87
VIII.FUNGSI LANJUTAN.......................................................................................................................... 92
A.Teman................................................................................................................................................. 92
2.Fungsi Overload.................................................................................................................................. 96
3.Operator Overload............................................................................................................................ 100
Pertanyaan dan Tugas...................................................................................................................... 104
IX.PEWARISAN...................................................................................................................................... 106
A.Pewarisan Tunggal........................................................................................................................... 107
2.Kostruktor Pada Pewarisan............................................................................................................... 109
3.Pewarisan Jamak.............................................................................................................................. 112
4.Pewarisan Jamak Virtual................................................................................................................... 115
X.POLIMORFISME................................................................................................................................. 122
A.Polimorfisme Pada Pewarisan Tunggal............................................................................................ 122
2.Polimorfisme Pada Pewarisan Jamak...............................................................................................124
3.Polimorfisme Pada Pewarisan Jamak Virtual....................................................................................126
XI.STREAM............................................................................................................................................. 129
A.Lebih Lanjut Tentang cin................................................................................................................... 129
2.Lebih Lanjut Tentang cout................................................................................................................. 132
3.Stream File........................................................................................................................................ 135
XII.STRING.............................................................................................................................................. 143
XIII.TEMPLATE....................................................................................................................................... 146
A.Fungsi Template............................................................................................................................... 146
2.Kelas Template.................................................................................................................................. 150
XIV.KONTAINER DAN ITERATOR......................................................................................................... 153
A.Kontainer pair................................................................................................................................... 153
2.Kontainer vector................................................................................................................................ 154
3.Kontainer list..................................................................................................................................... 156
4.Kontainer queue................................................................................................................................ 157
5.Kontainer deque................................................................................................................................ 158
6.Kontainer map................................................................................................................................... 159
7.Kontainer set..................................................................................................................................... 160
8.Kontainer stack................................................................................................................................. 161
DAFTAR PUSTAKA................................................................................................................................ 163
Index....................................................................................................................................................... 164
3
Daftar Tabel
Tabel 1.Tipe Data Dasar.......................................................................................................................... 17

Tabel 2.Tipe Data Dengan Awalan.......................................................................................................... 18
Tabel 3.Tipe Data Turunan...................................................................................................................... 18
Tabel 4.Operator Aritmetika.................................................................................................................... 21
Tabel 5.Operator Logika.......................................................................................................................... 21
Tabel 6.Operator Relasional................................................................................................................... 22
Tabel 7.Operator Penugasan Khusus.................................................................................................... 23
4
Daftar Gambar
Gambar 1.Tampilan Awal Borland C++.................................................................................................. 13

Gambar 2.Tampilan Awal C++ Builder................................................................................................... 14
Gambar 3.Dialog Untuk New.................................................................................................................. 14
Gambar 4.Editor C++ Builder................................................................................................................. 15
Gambar 5.Skema Pembentukan Pointer pdata.....................................................................................52
Gambar 6.Skema Pembentukan Pointer pdata.....................................................................................53
Gambar 7.Hirarki Kelas......................................................................................................................... 106
Gambar 8.Hirarki Kelas Pewarisan Tunggal........................................................................................ 107
Gambar 9.Hirarki Kelas Kendaraan dan Pesawat...............................................................................110
Gambar 10.Hirarki Kelas Segiempat dan Bujursangkar.....................................................................111
Gambar 11.Hirarki Kelas Pegasus........................................................................................................ 113
Gambar 12.Hirarki Kelas Fan................................................................................................................ 114
Gambar 13.Hirarki Kelas Hewan Sampai Pegasus.............................................................................116
Gambar 14.Hirarki Kelas Virtual Hewan Sampai Pegasus.................................................................116
Gambar 15.Hirarki Kelas Alat Sampai Fan.......................................................................................... 118
Gambar 16.Hirarki Kelas Virtual Alat Sampai Fan..............................................................................118
Gambar 17.Hirarki Kelas iostream.h.................................................................................................... 129
Gambar 18.Hirarki Kelas fstream.h...................................................................................................... 136
5
Kata Pengantar
Buku yang membahas secara khusus tentang pemrograman berorientasi objek belum banyak beredar di
pasaran terutama buku berbahasa Indonesia. Sehingga bagi mereka yang ingin mempelajari teknik
pemrograman berorientasi objek, buku ini merupakan pilihan yang tepat.
Buku ini ditujukan bagi mahasiswa yang berminat untuk mempelajari pemrograman berorientasi objek
dan pemrograman bahasa C++. Tentu saja tidak menutup kemungkinan mereka yang ingin mempelajari
pemrograman berorientasi objek untuk menggunakan buku ini. Maksud penulisan buku terutama untuk
mendukung mata kuliah pemrograman berorientasi objek dan pemrograman C++ di perguruan tinggi
komputer. Buku ini ditulis berdasarkan pengalaman mengajar penulis dalam mata kuliah tersebut.
Bahasan buku ini dititik beratkan pada pemrograman berorientasi objek menggunakan C++. Meskipun
demikian, penulis tetap berusaha menguraikan pemrograman C++ dari tingkat dasar, supaya bagi
mereka yang awan tetap dengan mudah dapat mengikuti uraiannya.
Pembahasan buku ini dimulai dari dasar pemrograman sampai fungsi yang diuraikan secara mudah,
praktis dan dapat diterapkan dalam program. Selanjutnya pembaca diajak masuk pembahasan tentang
objek dari tipe struktur disertai contoh program. Pembahasan berikutnya, seluruhnya adalah
pemrograman berorientasi pada objek yang meliputi enkapsulasi, penyembunyian data, pewarisan dan
polimorfisme. Bahasan berikutnya adalah tentang kelas string, stream dan template yang merupakan
penerapan pemrograman berorientasi objek. Penulis memandang template cukup penting dibahas lebih
lanjut, sehingga dalam bahasan berikutnya diuraikan tentang penerapan template untuk kontainer.
Kontainer merupakan penerapan beberapa konsep struktur data dalam pemrograman berorientasi objek.
Dalam buku ini disertakan contoh-contoh program, sehingga diharapkan hal ini dapat membantu
pembaca dalam memahami materi secara lebih baik. Walaupun dalam buku ini ditampilkan juga hasil
keluaran dari program yang dijalankan, diharapkan pembaca tetap berusaha untuk mencoba menuliskan
kode-kode program yang tertulis, kemudian menjalankan sendiri, sehingga pembaca akan lebih mahir
dan lancar menuliskan kode-kode program.
Bahasa pemrograman yang dipakai untuk membahas teknik pemrograman berorientasi objek adalah
bahasa pemrograman C++. Bahasa C++ yang digunakan dalam buku ini memperhatikan dua sistem
operasi yang berkembang saat ini yaitu Windows dan Linux. Bagi para pengguna Windows dapat
menuliskan kode-kode program yang ada dalam buku ini menggunakan perangkat lunak C++ yang
dikeluarkan oleh Borland dan Microsoft, sedangkan bagi mereka pengguna Linux dapat menggunakan
GNU C++. Program-program yang diberikan dalam buku ini sudah diuji dijalankan pada perangkat lunak
C++ pada Windows dan Linux. Bagi pengguna Linux perlu menambahkan satu baris perintah supaya
program dapat berjalan secara benar.
Bagi mereka yang masih enggan menggunakan sistem operasi Linux, tetapi ingin menjalankan program
seperti pada Linux, sekarang tersedia perangkat lunak GNU C++ yang bekerja pada Windows yang
dapat diperoleh pada situs http://www.delorie.com/djgpp secara gratis.
Selanjutnya penulis menyadari bahwa buku ini masih banyak kekurangan dan kekhilafan. Oleh karena itu
penulis dengan senang hati menerima kritik dan saran demi perbaikan buku ini.
Semoga buku ini memberikan manfaat.
penulis
Wagito
6
Kuberikan buku ini

untuk istriku tercinta, Irna
untuk anak-anakku tersayang, Ilham dan Ismah
7
I. PENDAHULUAN
1. Pemrograman Berorientasi Objek Dengan C++

Objek adalah semua yang terdapat di sekitar kita. Batu, tumbuhan, hewan, buku, kotak dan sebagainya,
semuanya adalah objek. Pemrograman berorientasi objek yang dimaksud adalah pemrograman yang
orientasinya pada kebendaan. Jika dibuat program tentang hewan, maka pemrogram harus berpikir apa
nama hewan, apa warna hewan, bagaimana hewan berkembang, bagaimana hewan bergerak dan
sebagainya. Jika dibuat program tentang buku, maka pemrogram harus berpikir tentang judul buku, siapa
pengarangnya, berapa jumlah halaman, bagaimana mengakses buku tersebut dan sebagainya. Jika
dibuat program tentang kotak, maka pemrogram harus perpikir berapa ukuran kotak, bagaimana
memasukkan data kotak, bagaimana warna kotak, bagaimana menghitung luas, bagaimana menghitung
isi dan sebagainya. Jika dibuat program tentang benda, maka pemrogram harus berpikir tentang data
yang berhubungan dengan benda tersebut dan apa yang dapat dikerjakan oleh maupun terhadap benda
tersebut. Dalam hal ini pemrograman menjadi lebih luas cakupannya.
Pemrograman berorientasi objek mempunyai tiga pilar pendukung yaitu:
 enkapsulasi (encapsulation),
 pewarisan (inheritance), dan
 polimorfisme (polymorphism).
Prinsip enkapsulasi merupakan dasar pertama bagi pemrograman berorientasi objek yang secara mudah
dapat digambarkan dengan contoh berikut. Jika seorang ahli elektronika ingin membuat rangkaian
elektronik dan memerlukan kapasitor, maka ahli elektronika tersebut cukup membaca kode yang ada
pada tubuh kapasitor untuk mengetahui kapasitasnya. Ahli elektronika tersebut tidak perlu tahu tentang
isi dan bagaimana membentuk kapasitor. Ini merupakan prinsip penyembunyian data (data hiding) yang
ada pada enkapsulasi. Kapasitor baginya merupakan black box, dia tidak perlu tahu bagaimana kapasitor
dibentuk, dia hanya perlu mengetahui bagaimana menggunakannya.
Dalam kapasitor terdapat beberapa bahan yang digunakan untuk membentuk kapasitor. Bahan-bahan ini
merupakan data anggota dari kapasitor tersebut. Dalam kapasitor juga terdapat susunan bahan-bahan
tersebut supaya kapasitor dapat bekerja. Cara supaya kapasitor dapat bekerja ini disebut fungsi anggota
atau metode yang digunakan dalam kapasitor. Data anggota dan metode supaya kapasitor mempunyai
kapasitas tertentu sudah dienkapsulasi dalam objek yang namanya kapasitor. Tentang bahan dan
susunan kerja kapasitor disembunyikan dalam wadah tertentu dari kapasitor.
Bahasa C++ mendukung prinsip enkapsulasi dan penyembunyian data dengan tipe data yang namanya
class (kelas).
Dari kapasitor yang sudah tersusun tersebut dapat dibuat kapasitor lain yang data anggota dan
metodenya hampir mirip. Dalam kapasitor baru, mungkin fasilitasnya ditambah atau dikurangi, sehingga
lebih baik kerjanya. Ada data anggota dan metode yang diturunkan dari kapasitor pertama, atau bahkan
menambah bahan baru dan menambah rangkaian baru, tetapi tetap menggunakan teknik kapasitor
sebelumnya. Ini merupakan prinsip pewarisan yang mana data anggota dan metode yang ada dalam
kapasitor dapat diwariskan pada kapasitor lainnya.
Bahasa C++ juga dapat mendukung pewarisan ini, yang mana data anggota dan metode yang ada pada
suatu kelas dapat diwariskan pada kelas lain, sehingga kelas lain tersebut memiliki data anggota dan
metode yang sama.
Antara kapasitor yang satu dengan yang lain mempunyai sifat yang sama yaitu menyimpan muatan
listrik. Walaupun fungsinya sama, kapasitor akan menghasilkan perilaku yang berbeda dalam menyimpan
muatan listrik. Ada yang menyimpan muatan dengan cara tertentu, sehingga simpanannya menjadi lebih
baik, ada yang menyimpan dengan cara lain, sehingga hasilnya kurang begitu baik. Beberapa kapasitor
dengan kapasitas yang sama dapat menyimpan muatan listrik yang sama tetapi hasil yang diperoleh
berbeda karena caranya berbeda. Ini adalah prinsip polimorfisme yang mana metode yang digunakan
mempunyai nama sama, tetapi karena isinya berbeda, maka kapasitor yang satu dengan yang lainnya
menghasilkan hasil yang berbeda.
8
Bahasa C++ juga mendukung prinsip polimorfisme ini, yang mana satu objek dapat mempunyai
beberapa bentuk tergantung kelas yang diikat pada saat program dijalankan. Objek ini dapat mengikat
fungsi dinamis yang menjadi fungsi anggota kelas turunan. Fungsi dinamis mempunyai nama yang sama,
tetapi mempunyai definisi yang berbeda untuk masing-masing kelas yang berbeda, sehingga
menghasilkan hasil yang berbeda untuk masing-masing kelas.
2. Perkembangan Bahasa C++

Bahasa C++ merupakan perkembangan dari bahasa C. Bahasa C pertama kali disusun oleh Dennis
Ritchie pada tahun 1972 di laboratorium AT&T BELL, suatu laboratorium tempat merancang sistem
operasi UNIX yang sangat terkenal. Mengapa bahasa ini diberi nama bahasa C?
Sejarah perkembangan bahasa C dimulai pada saat Ken Thompson membuat bahasa B untuk menyusun
sistem operasi UNIX. Huruf B diambil dari nama depan laboratorium tersebut, BELL. Karena banyak
mengalami kesulitan, bahasa B dikembangkan menjadi bahasa C dengan beberapa penambahan tipe
data dan sintaksis baru, oleh Dennis Ritchie. Pertama kali, bahasa C dimaksudkan untuk tujuan
pembuatan sistem operasi UNIX.
Dennis Ritchie dan Brian Kernighan pada tahun 1978 mempublikasikan buku berjudul The C
Programming Language. Dalam perkembangan selanjutnya, bahasa C menjadi bahasa pemrograman
yang digunakan secara luas. Bahasa ini sangat powerful dan fleksibel, sehingga berkembang secara
cepat. Beberapa perusahaan mulai mengembangkan utilitas untuk melengkapi bahasa C, sehingga
terdapat beberapa versi bahasa C yang berbeda-beda.
Pada tahun 1983 American National Standards Institute (ANSI) membakukan bahasa C dalam bentuk
standar C ANSI atau yang disebut ANSI C. Seluruh perusahaan dalam mengembangkan bahasa C,
mengacu pada standar ini. Bahasa C secara luas digunakan untuk pemrograman terstruktur. Beberapa
perusahaan yang mengembangkan bahasa C antara lain Borland yang mengembangkan Borland C dan
Turbo C serta Microsoft yang mengembangkan Ms. C. Selain itu ada compiler C yang dikembangkan
pada platform Linux yang disebut GNU C.
Dalam perkembangan cara pembuatan program, dari teknik pemrograman terstruktur berkembang
menjadi apa yang disebut pemrograman berorientasi objek (object oriented programming atau OOP).
Bahasa C juga mengalami perkembangan sesuai berkembangnya cara pemrograman.
Pada tahun 1986 Bjarne Stroustrup dari laboratorium AT&T BELL, mengembangkan bahasa C menjadi
bahasa C++ yang dapat digunakan untuk pemrograman berorientasi objek. Fasilitas tambahan yang
diberikan pada bahasa C++ adalah tipe data class. Tipe data class digunakan untuk mendukung objek
pada bahasa C++.
Dengan perkembangan ini, Borland mengembangkan Borland C menjadi Borland C++, Turbo C menjadi
Turbo C++. Demikian juga dengan Microsoft yang mengembangkan Ms. C menjadi Ms. C++. Dalam
platform Linux GNU C juga dikembangkan menjadi GNU C++.
Bahasa C++ adalah bahasa yang menggunakan kompiler untuk translator dari kode program menjadi
bahasa mesin. Bahasa C++ mempunyai dua beban yaitu harus mendukung pemrograman terstruktur
menggunakan bahasa C dan pemrograman berorientasi objek menggunakan bahasa C++. Dengan
demikian, program dalam bahasa C dapat dikompilasi menggunakan kompiler C++, tetapi program dalam
bahasa C++ tidak dapat dikompilasi menggunakan kompiler C.
Pertanyaan dan Tugas
1. Sebutkan bahasa pemrograman yang anda ketahui

2. Dari yang anda sebutkan, mana yang menggunakan kompiler, mana yang menggunakan iterpreter
dan mana yang menggunakan assembler
3. Dari yang anda sebutkan, mana yang mendukung dan mana yang tidak mendukung pemrograman
berorientasi objek.
4. Carilah informasi, perubahan tipe data dan perintah apakah yang terjadi, ketika bahasa B diubah
9
manjadi bahasa C
5. Carilah informasi, tentang orang-orang yang berperan dalam perkembangan C++ seperti Ken
Thompson, Dennis Ritchie, Brian Kernighan dan Bjarne Stroustrup
6. Cari informasi, perusahaan software lain yang mengembangkan bahasa C++ selain yang ada pada
buku ini
10
II. DASAR PEMROGRAMAN

A. Bentuk Umum Program C++
Masing-masing bahasa pemrograman mempunyai cara tersendiri dalam membuat suatu kode-kode
program. Demikian pula dengan bahasa C++. Bahasa C++ mempunyai bentuk umum program seperti
tertulis di bawah ini.
// nama program: cpertama.cpp

// sebagai latihan dasar
// komentar-komentar lain
#include<header>
main()
{
deklarasi variabel;
deklarasi konstanta;
perintah-perintah;
}
Baris-baris pernyataan yang diawali dengan double slash ( // ) akan dianggap sebagai komentar,
sehingga baris perintah ini
// nama program
// komentar-komentar lain
akan dianggap sebagai komentar, tidak akan dieksekusi. Walaupun tidak dieksekusi, tetapi baris
komentar ini tetap berguna misalnya untuk memberi judul program, memberi catatan tertentu dalam
program, atau untuk memberi keterangan tentang maksud program dibuat.
Baris berikutnya adalah pengarah kompiler (compiler directive).
#include<header.h>
Baris ini digunakan untuk mengarahkan kompiler tentang file header yang digunakan. Maksud perintah ini
adalah bahwa program yang dibuat ini menggunakan file header yang namanya header yang biasanya
berekstensi *.h. Program dalam C++ sebagian besar akan menyertakan file header yang berisi prototipe
fungsi yang nantinya akan digunakan dalam program. Penyertaan file header ini tergantung pada fungsi-
fungsi yang digunakan dalam program. File header secara default berekstensi *.h. Kadang-kadang
ekstensi *h pada penyertaan file header tidak dituliskan. Dengan demikian pernyataan dapat ditulis
sebagai berikut.
#include<header>
Bahasa C++ mempunyai banyak sekali file header misalnya iostream.h, stdlib.h, conio.h, dan
sebagainya. File-file header tersebut disimpan dalam direktori tertentu dalam struktur direktori program
bahasa C++ yang digunakan. Untuk versi Borland C++, file header disimpan dalam direktori include di
bawah direktori root program.
Pada kasus tertentu, pemrogram dapat membuat file header sendiri yang disimpan pada direktori yang
sama dengan aplikasi yang dibuat. Jika kasusnya demikian, maka pernyataan pengarah kompiler dapat
diganti dengan pernyataan
#include "header"
11
yaitu menggunakan tanda kutip ganda.

Baris berikutnya adalah program utama atau fungsi utama yang dinyatakan sebagai berikut.
main()
{
}
Bagian ini merupakan awal dari eksekusi program dalam bahasa C++. Tiap program yang dibuat, supaya
dapat dieksekusi harus mempunyai program utama. Setiap blok pernyataan dalam bahasa C++ termasuk
blok program utama harus diawali dengan kurung buka ( { ) dan diakhiri dengan kurung tutup ( } ).
Bentuk-bentuk program utama dapat bermacam macam. Paling tidak ada tiga macam bentuk program
utama yang dapat digunakan.
Yang pertama yaitu:
void main()
{
}
Yang kedua yaitu:
main()
{
}
Yang ketiga yaitu:
int main()
{
}
Setiap program dalam bahasa C++ harus mempunyai salah satu dari tiga bentuk program utama
tersebut. Program utama tidak boleh lebih dari satu. Dalam program utama dapat berisi deklarasi
variabel, deklarasi konstansta serta perintah-perintah program. Setiap deklarasi maupun perintah yang
ada dalam program utama harus diakhiri dengan tanda titik-koma ( ; ).
Berikut ini diberikan contoh program sederhana yang ditulis menggunakan bahasa C++
// nama program: ccontoh.cpp

// sebagai program contoh dalam mempelajari C++
#include<iostream>
#include<conio>
main()
{
cout<<"Pemrograman C++"<<endl;
cout<<"Pemrograman Berorientasi Objek"<<endl;
getch();
}
keluaran:
Pemrograman C++
Pemrograman Berorientasi Objek
Dalam program tersebut terdapat dua baris komentar yang berisi penjelasan tentang program. Dalam
program tersebut baris komentar digunakan untuk memberi tahu nama programnya serta guna dari
12
programnya.
Program tersebut menyertakan dua file header yaitu: iostream.h dan conio.h sekaligus. Mengapa dua file
header ini disertakan, tentunya ada alasannya. File header iostream.h harus disertakan karena dalam
program utama terdapat perintah cout. Perintah cout ini protipenya disimpan dalam file header
iostream.h. Mengapa harus menyertakan file header conio.h, karena dalam program tersebut digunakan
perintah getch(). Jika dalam program tersebut perintah getch() dihilangkan, maka file header conio.h
dapat dihilangkan.
Beberapa perintah dalam program tersebut dapat dijelaskan secara singkat sebagai berikut.
Perintah cout digunakan untuk menampilkan sederetan data pada layar monitor. Dalam perintah cout
ada perintah endl untuk berganti baris.
Perintah getch() digunakan untuk menghentikan sementara eksekusi program, menunggu perintah
ENTER dari papan ketik.
2. Menuliskan Program Dalam Beberapa Versi C++

Borland C++ dan Turbo C++
Borland C++ merupakan software pemrograman yang dibuat oleh Borland. Selain mengeluarkan Borland
C++, juga mengeluarkan versi Turbo C++. Dua software tersebut dapat digunakan untuk membuat
program dalam bahasa C++.
Langkah-langkah :
1. Bukalah software Borland C++, akan terlihat tampilan awal Borland C++ sebagai berikut.
Gambar 1. Tampilan Awal Borland C++
2. Tulislah program di atas pada editor tersebut.

3. Pilih menu File
4. Pilih sub menu Save, untuk menyimpan
5. Jalankan program dengan menekan CTRL-F9 atau tombol Run.
Borland C++ Builder
Borland C++ Builder merupakan software bahasa pemrograman visual yang dikeluarkan oleh Borland.
Sebetulnya software ini digunakan untuk pemrograman visual, tetapi software ini juga dapat digunakan
untuk membuat program secara aplikasi konsol. Untuk menuliskan program C++ menggunakan software
ini ikuti langkah-langkah berikut ini.
1. Bukalah software C++ Builder : akan terbuka tampilan sebagai berikut.
13
Gambar 2. Tampilan Awal C++ Builder
2. Tampilan ini merupakan fasilitas form yang biasa digunakan untuk pemrograman visual. Untuk
menuliskan kode-kode C++ yang akan dibuat, belum diperlukan fasilitas ini. Oleh sebab itu, fasilitas
ini ditutup dengan langkah berikutnya.
3. Pilih menu File
4. Pilih submenu Close All : untuk menutup seluruh aplikasi
Dengan langkah ini, maka tampilan C++ Builder akan menjadi tanpa form. Langkah selanjutnya
membuka editor sebagai tempat untuk menuliskan kode-kode program dalam bahasa C++. Langkah-
langkah yang dilakukan adalah:
5. Pilih menu File
6. Pilih submenu New
Dengan perintah ini, akan muncul suatu dialog dengan beberapa pilihan.
Gambar 3. Dialog Untuk New
7. Pilihlah icon Console App, dengan cara double klik icon tersebut. Akan muncul editor yang sudah
berisi kode-kode program yang ditulis dalam bahasa C++ sebagai berikut.
14
Gambar 4. Editor C++ Builder
Supaya tidak mengacaukan, sebaiknya tulisan-tulisan yang ada dalam editor tersebut lebih baik dihapus
semua. Dengan demikian diperoleh editor yang bersih dan siap digunakan untuk menuliskan kode-kode
program. Kemudian tulislah kode-kode program contoh.cpp secara lengkap. Selanjutnya simpan dengan
perintah
8. Pilih menu File
9. Pilih submenu Save
Langkah selanjutnya adalah mengeksekusi program. Untuk mengeksekusi program dapat dilakukan
dengan beberapa cara:
 menekan tombol F9 dari papan ketik, atau
 klik menu Run, dilanjutkan submenu Run, atau
 pilih tombol Run.
Jika tidak ada kesalahan, maka akan menghasilkan tampilan hasil program. Program berhenti sebentar
untuk menunggu perintah ENTER. Tekanlah ENTER sehingga akan kembali pada editor utama.
GNU C++ (Redhat 8.0, Mandrake 9.0, Slackware 9.0)
Untuk menuliskan program C++ dalam platform Linux, diperlukan beberapa software yang harus
dipasang. Software yang diperlukan antara lain:
 software GNU C++
Software ini diperlukan sebagai kompiler C++ dalam platform Linux. Dalam distro Redhat 8.0 software
disimpan dalam file rpm dengan nama gcc-c++-3.2-7.i386.rpm. Dalam distro Mandrake 9.0 software ini
disimpan dalam suatu file rpm yang bernama gcc-c++-3.2-1mdk.i586.rpm. Sedangkan dalam distro
Slackware 9.0 software ini disimpan dalam file tar ball yang bernama gcc-g++-3.2.2-i386-1.tgz.
 software GNU C
Software ini diperlukan sebagai kompiler bahasa C. Walaupun yang digunakan g++, tetapi gcc tetap
diperlukan, karena g++ memerlukan gcc. Dalam distro Redhat 8.0 disimpan dalam file rpm dengan nama
gcc-3.2-7.i386.rpm. Dalam distro Mandrake 9.0 disimpan dalam file rpm yang bernama gcc-3.2-
1mdk.i586.rpm. Sedangkan dalam distro Slackware 9.0 disimpan dalam file tar ball yang bernama gcc-
3.2.2-i386-3.tgz.
 software editor teks
Software ini diperlukan sebagai tempat untuk menuliskan kode-kode program yang akan dibuat. Ada
beberapa software yang dapat digunakan misalnya vi, pico dan joe. Software editor ini diperlukan karena
tidak ada editor khusus untuk compiler C++ dalam Linux. Sebagai contoh untuk menuliskan langkah-
15
langkah program digunakan pico.

Setelah software-software tersebut diinstal, maka Linux siap digunakan untuk menjalankan bahasa C++.
Sebelum dimulai membuat program C++ dalam Linux, perlu diperhatikan bahwa dalam platform Linux
tidak dikenal file header yang bernama conio.h, sehingga file header ini tidak boleh disertakan. Karena
file conio.h tidak disertakan, perintah getch() juga harus dihilangkan tanpa banyak berpengaruh pada
program. Selain itu perlu ditambah satu baris pernyataan berikut ini
using namespace std;
pada bagian yang sejajar pengarah kompiler. Program yang ditulis dalam buku ini secara default dapat
dijalankan pada software bahasa C++ yang bekerja pada platform Windows. Jika akan dijalankan pada
platform Linux, maka perlu ditambah pernyataan di atas. Untuk lebih jelasnya perhatikan perubahan yang
terjadi pada program contoh.cpp di atas. Supaya dapat dikompilasi pada platform Linux, maka program
contoh.cpp harus diubah menjadi sebagai berikut.
// nama program: ccontoh1.cpp

// contoh program supaya jalan di Linux
#include<iostream>
main()
{
cout<<"Pemrograman C++"<<endl;
cout<<"Pemrograman Berorientasi Objek"<<endl;
}
Berikut ini diberikan langkah-langkah pembuatan program bahasa C++ pada platform Linux. Langkah
pertama untuk membuat adalah menuliskan kode-kode program dalam editor.
Bukalah program editor pico dengan perintah
pico
maka akan keluar editor text. Tuliskan program di tas dalam editor tersebut secara lengkap. Kemudian
simpanlah dengan perintah
^O (control-O)
Akan muncul dialog untuk memasukkan nama file. Ketikkan nama file contoh.cpp, kemudian tekan
ENTER. Selanjutnya keluar dari editor pico dengan perintah
^X (control-X)
Dengan demikian dalam direktori sudah terdapat file contoh.cpp yang berisi kode-kode program yang
dibuat.
Kompilasi program contoh1.cpp dengan perintah sebagai berikut
g++ contoh1.cpp -o contoh.exe
Maksud perintah tersebut adalah mengkompilasi file contoh1.cpp dan hasil kompilasinya diberi nama
contoh.exe. Jika tidak ada kesalahan, maka akan diperoleh file contoh.exe. File hasil kompilasi ini dapat
dieksekusi dengan perintah
./contoh.exe
Untuk beberapa distro Linux yang lain, perintahnya juga mirip atau bahkan sama.
3. Pengenal
Pengenal (identifier) adalah nama yang digunakan untuk memberi identitas pada fungsi, variabel,
konstanta dan pengenal-pengenal lain dalam bahasa C++. Pengenal merupakan pembeda antara yang
16
satu dengan yang lain. Untuk menuliskan suatu pengenal perlu diperhatikan beberapa aturan dalam
pemberian nama pada pengenal. Yang perlu diperhatikan dalam pemberian nama suatu pengenal adalah
sebagai berikut.
 Nama pengenal harus dimulai dengan karakter yang berupa huruf (huruf a sampai z dan A sampai
Z) atau karakter garis bawah ( _ ).
 Karakter berikutnya dapat berupa huruf, angka (0 sampai 9) atau karakter garis bawah ( _ )
 Tidak boleh sama dengan reserved word (nama-nama yang sudah digunakan dalam bahasa C++)
 Panjang karakter maksimum adalah 32 karakter. Jika jumlahnya lebih dari 32 karakter, maka secara
automatis akan dipotong oleh bahasa C++.
 Bersifat case sensitive artinya huruf besar (capital) dan huruf kecil (small) dibedakan.
Berikut ini diberikan contoh pemberian nama, dengan memperhatikan peraturan di atas.
2data --> tidak diijinkan

data2 --> diijinkan
-keliling2 --> tidak diijinkan

_keliling2 --> diijinkan
Panjang |
panjang |--> dianggap berbeda
panJang |
4. Reserved Word
Reserved word adalah kata-kata yang khusus yang dipakai oleh bahasa C++ untuk keperluan tertentu.
Reserved word tidak boleh digunakan untuk memberi nama suatu identifier. Berikut ini daftar beberapa
reserved word.
asm mutable this
bool namespace throw
catch new true
class operator try
const_cast private typeid
delete explicit protected
dynamic_cast public using
false __rtti virtual
friend static_cast wchar_t
inline template typename
5. Tipe Data
Data dalam bahasa C++ biasanya berbentuk variabel maupun konstanta. Dalam bahasa C++, tipe data
dibagi menjadi dua kelompok yaitu: tipe data dasar dan tipe data turunan.
Tipe data dasar dalam bahasa C++ ada lima macam dituliskan dalam tabel berikut.
Tabel 1. Tipe Data Dasar

No. Tipe ukuran Range keterangan
17
1 char 1 byte -128 s/d 127 karakter

2 int 4 byte -2,147,483,648 integer
s/d 2,147,483,647
3 float 4 byte 3.4x10-38 s/d presisi tunggal
3.4x10+38
4 double 8 byte 1.7x10-308 s/d presisi ganda
1.7x10+308
5 void 0 byte - tidak bertipe
Tipe data dasar dapat diberi variasi dengan menambah awalan pada masing-masing tipe data. Awalan
yang sering dipakai yaitu:
 signed : bilangan bertanda
 unsigned : bilangan tidak bertanda
 short : bilangan dengan range yang lebih kecil
 long : bilangan dengan range yang lebih besar
Contoh penggunaan awalan-awalan tersebut terdapat pada tabel berikut.
Tabel 2. Tipe Data Dengan Awalan

No. Tipe Ukuran Range
1 unsigned char 1 byte 0 s/d 255
2 signed char 1 byte -128 s/d 127
3 short int 2 byte -32,768 s/d 32,767
4 unsigned int 4 byte 0 s/d 4,294,967,295
5 signed int 4 byte -2,147,483,648 s/d
2,147,483,647
6 double 64 bits 1.7x10-308 s/d
1.7x10+308
7 long double 80 bits 3.4x10-4932 s/d
1.1x10+4932
Referensi yang dipakai untuk menentukan ukuran byte tersebut menggunakan referensi bahasa
pemrograman 32 bit. Untuk bahasa pemrograman 16 bit, ukuran serta rangenya berbeda. Dalam bahasa
C++ ada tipe data khusus yang tidak memerlukan simpanan, tipe data tersebut namanya void. Tipe data
ini digunakan untuk memberi tipe pada suatu fungsi yang tidak memerlukan suatu nilai balik (return)
tertentu.
Selain tipe data dasar, juga dikenal tipe data turunan. Tipe data ini diturunkan dari tipe data dasar. Tipe
data turunan tertulis dalam tabel berikut.
Tabel 3. Tipe Data Turunan

No. Tipe Keterangan
1 larik variabel berindeks
2 Union (union) menggunakan memori
18
secara berbagi
3 Struktur (struct) mengumpulkan variabel
dalam satu record
4 Kelas (class) membentuk kelas
6. Variabel
Variabel merupakan salah satu bentuk identifier. Variabel adalah kuantitas yang akan diubah selama
proses program berjalan. Aturan pemberian nama variabel mengikuti aturan pemberian nama identifier.
Dalam bahasa C++, tipe variabel juga sesuai dengan tipe data yang ada dalam bahasa C++.
Sebelum variabel digunakan dalam suatu operasi, harus dideklarasikan terlebih dahulu. Variabel harus
dideklarasikan karena dua alasan yaitu:
 Nama variabel harus dihubungkan dengan suatu tipe tertentu.
 Compiler dapat menentukan berapa banyak simpanan yang diperlukan
Cara mendeklarasikan suatu variabel dijelaskan dengan sintaksis berikut.
nama_tipe nama_variabel
contoh:
int data_nomor; //variabel data_nomor bertipe int

float jumlah; //variabel jumlah bertipe float
double data[100]; //variabel data bertipe larik double berukuran 100
char Kalimat[20]; //variabel Kalimat bertipe larik char berukuran 20
Program berikut memberi gambaran bagaimana menggunakan variabel.
// nama program: cvariabel.cpp

// contoh penggunaan variabel
#include<iostream>
main()
{
int panjang, tinggi;
double Luas;
panjang=10;
tinggi=5;
Luas=0.5*panjang*tinggi;
cout<<"Panjang = "<<panjang<<endl;
cout<<"Tinggi = "<<tinggi<<endl;
cout<<"Luas = "<<Luas<<endl;
}
keluaran:
Panjang=10
Tinggi=5
Luas = 25
Pada dasarnya mendeklarasikan suatu variabel bisa di mana saja dalam deretan program bahasa C++,
asalkan masih berada di dalam fungsi yang bersangkutan serta sebelum variabel tersebut digunakan.
19
Misalkan saja untuk program di atas, pernyataan
double Luas;
dapat ditempatkan setelah pernyataan
tinggi = 5;
tanpa mempengaruhi hasil program.
7. Konstanta
Konstanta juga merupakan salah satu bentuk identifier seperti variabel. Perbedaannya bahwa selama
proses program berjalan, nilai variabel berubah-ubah, sedangkan nilai konstanta tidak berubah.
Pengertiannya adalah tidak diijinkan merubah nilai konstanta selama proses program berjalan. Konstanta
juga mempunyai tipe tertentu seperti variabel. Cara mendeklarasikan suatu konstanta dapat dituliskan
sebagai berikut.
const nama_tipe nama_constanta = nilai_konstanta
contoh:
const double konstan = 10.0; //konstan bertipe double dan bernilai 10.0
const char kar = 'B'; //kar bertipe char dan bernilai 'B'
const int data = 2000; //data bertipe int dan bernilai 2000
Berikut ini contoh penggunaan konstanta dalam program
// nama program: ckonstanta.cpp

// contoh penggunaan konstanta
#include<iostream>
main()
{
//konstanta fi bertipe float, bernilai 3.14
const float fi = 3.14;
//variabel jari_jari bertipe int, nilai awal 10
int jari_jari = 10;
float Luas;
Luas=fi*jari_jari*jari_jari;
cout<<"Luas = "<<Luas<<endl;
}
keluaran
Luas = 314
Dalam program di atas ada dua deklarasi yang hampir mirip, yaitu deklarasi konstanta dan deklarasi
variabel. Dalam program di atas, nilai konstanta fi tidak dapat diubah selama proses program, sedangkan
nilai variabel jari_jari dapat diubah selama proses program. Jika konstanta fi diubah pada proses
program, maka kompiler akan menganggap sebagai kesalahan sintaksis.
20
8. Operator
Operator sangat penting dalam suatu bahasa pemrograman. Operator ini digunakan untuk
mengoperasikan operan baik satu atau lebih operan. Operator dalam bahasa C++ macamnya banyak,
tetapi dapat dikelompokkan dalam beberapa kelompok.
Operator Aritmetika
Operator aritmetika merupakan operator yang paling banyak penggunaannya. Ada lima macam operator
aritmetika yang digunakan dalam bahasa C++ yang dapat dilihat dalam tabel berikut.
Tabel 4. Operator Aritmetika

No. Operator Keterangan
1 + operasi penambahan
2 - operasi pengurangan
3 * operasi perkalian
4 / operasi pembagian
5 % operasi mencari sisa pembagian
Kelima jenis operator dapat digunakan untuk semua jenis tipe data numeris kecuali untuk operator %
(sisa pembagian) yang hanya dapat digunakan untuk data bertipe int.
Operator Logika
Operator logika banyak digunakan untuk struktur kondisional atau keputusan. Bahasa C++ mengenal
beberapa operator logika antara lain terdapat pada tabel berikut.
Tabel 5. Operator Logika

1 && Operator AND
2 || Operator OR
3 | Operator NOT
Dua operator yang pertama && dan || bersifat biner (mengoperasikan dua operan), sedangkan operator !
bersifat uner (mengoperasikan satu operan).
Operator Penaikan dan Penurunan
Operator penaikan dan penurunan digunakan untuk menaikkan ataupun menurunkan nilai suatu variabel
satu tingkat.
Cara penulisan operator penaikan dan penurunan adalah sebagai berikut.
nama_variabel++
++nama_variabel++
nama_variabel--
21
--nama_variabel
Contoh penggunaannya
k++ sama dengan k=k+1

++k sama dengan k=k+1
m-- sama dengan m=m-1
--m sama dengan m=m-1
Penggunaan ++k maupun k++ maksudnya sama yaitu menaikkan k sebanyak satu tingkat.
Penggunaannya akan mempunyai arti yang berbeda jika sudah masuk dalam rangkaian pernyataan
contoh:
w = p + k++;
pernyataan tersebut seperti menuliskan dua pernyataan
w = p + k;
k = k + 1;
contoh:
w = p + ++k
pernyataan tersebut seperti menuliskan dua pernyataan
k = k + 1;
w = p + k;
Jadi dalam dua contoh di atas penggunaan k+= dan ++k menghasilkan urutan eksekusi yang berbeda.
Operator Relasional
Operator relasional biasanya digunakan dalam struktur kondisional program. Operator relational dalam
bahasa C++ dituliskan dalam tabel berikut.
Tabel 6. Operator Relasional

1 < lebih kecil
2 <= lebih kecil atau sama dengan
3 > lebih besar
4 >= lebih besar atau sama dengan
5 == sama dengan
6 != tidak sama dengan
22
9. Operator Penugasan dan Penugasan Khusus

Operator penugasan digunakan untuk memberikan nilai pada suatu variabel. Dalam bahasa C++
operator penugasan berupa = ( tanda sama dengan )
contoh:
nomor_induk = 20012;
tahun = 2003;
Luas = 100*20
Operator penugasan khusus merupakan operator penugasan juga, tetapi bentuknya spesifik. Beberapa
operator penugasan khusus dicontohkan dalam tabel berikut.
Tabel 7. Operator Penugasan Khusus

No. Contoh Maksud
1 x += y x=x+y
2 x -= y x=x-y
3 x *= y x= x * y
4 x /= y x=x/y
5 x %= y x=x%y
Khusus untuk bentuk x%=y, tipe x dan y harus int.
10.Perintah Input/Output
Bahasa C++ mendefinisikan stream input-output standar yang dibuka pada saat program dijalankan.
Stream tersebut meliputi:
 cout
 cin
 cerr
Secara sintaksis, stream-stream tersebut bukanlah fungsi, data ditulis pada stream menggunakan
operator << (extraction operator), sedangkan data dibaca dari stream menggunakan operator >>
(insertion operator).
Perintah input/output ke layar monitor yang digunakan dalam bahasa C++ meliputi dua perintah utama
yaitu:
 cout : untuk menampilkan keluaran ke layar monitor
 cin : untuk mengambil masukan dari papan ketik
Sintaksis yang digunakan pada perintah keluaran tersebut adalah:
cout << daftar_keluaran
Perintah tersebut dapat digunakan untuk semua jenis tipe data dasar. Operator << disebut operator
ekstraksi (extraction operator). Contoh penggunaannya:
cout<<”belajar pemrograman C++”<<endl;
23
cout<<”nomor = “<<nomor<<endl;
cout<<”nilai = “<<100.00<<endl
<<”karakter =“<<’K’<<endl;
cout<<”no.mhs = “<<200056<<” : nama = “
<<”Yusuf”<<endl;
Sintaksis yang digunakan untuk perintah masukan adalah sebagai berikut.
cin >> daftar_masukan
Perintah ini dapat digunakan untuk mengambil semua tipe data dasar dari papan ketik. Operator >>
disebut operator insersi (insertion operator). Contoh penggunaannya adalah
cin>>nilai; //mengambil data nilai dari papan ketik

cin>>nilai>>nama; //mengambil dua data sekaligus
cin>>A>>B>>C; //mengambil tiga data sekaligus, A, B, C
Untuk lebih memahami penggunaan perintah input/output, berikut ini dicontohkan program untuk
menghitung luas suatu segitiga.
// nama program: csegitiga.cpp

// program luas segitiga, contoh cout dan cin
#include<iostream>
main()
{
int alas, tinggi;
double luas;
cout<<”masukkan nilai alas : ? “;
cin>>alas; // minta masukan alas
cout<<”masukkan nilai tinggi : ? ”;
cin>>tinggi; // minta masukan tinggi
luas = 0.5*alas*tinggi;
cout<<”Luas segitiga = “<<luas<<endl;
}
keluaran:
masukkan nilai alas : ? 10
masukkan nilai tinggi : ? 20
Luas segitiga = 100
Pada saat program dijalankan, program akan meminta masukan dua kali yaitu meminta masukan data
alas dan data tinggi. Masukkan nilai alasnya 10 dan nilai tingginya 20. maka hasilnya luasnya 100.
Untuk memasukkan data alas dan tinggi dapat sekaligus satu perintah, sehingga programnya lebih
ringkas, misalkan:
cout<<”Masukkan nilai alas dan tinggi : ? ”;

cin>>alas>>tinggi;
Dengan perintah program tersebut, masukan data alas dan tinggi dapat dimasukkan secara bersama.
Contoh hasil keluarannya:
masukkan nilai alas dan tinggi: ? 10 20

Luas segitiga = 100
24
Dalam hal ini untuk memisahkan data alas dan data tinggi digunakan spasi.
Perintah cout jika digunakan begitu saja, maka tampilannya kurang bagus. Perintah cout dapat diatur
cara penampilannya menggunakan beberapa format tampilan yang disebut manipulator.
Manipulator yang pertama berupa perintah setiosflags(). Perintah ini berhubungan dengan pengaturan
bilangan real. Bilangan real dapat ditampilkan dengan tiga format yaitu:
 fixed : tanpa notasi scientific
 scientific : notasi scientific
 showpoint : menentukan jumlah desimal.
Cara menggunakan perintah setiosflag adalah sebagai berikut.
setiosflags(ios::format)
setiosflags(ios::format1 | ios::format2)
contoh:
setiosflags(ios::fixed)
setiosflags(ios::fixed | ios::showpoint)
Perintah setiosflags() akan berpengaruh sampai secara eksplisit dinyatakan perubahan menggunakan
perintah setiosflags() juga.
Contoh penggunaannya dalam program.
// nama program: cflags.cpp

// memberi contoh penggunaan setiosflags
#include<iostream>
#include<iomanip>
main()
{
float x = 123.12345, y=12345.12345;
cout<<setiosflags(ios::fixed | ios::showpoint)
<<”nilai x = “<<x<<endl
<<”nilai y = “<<y<<endl;
}
keluaran:
nilai x = 123.123
nilai y = 12345.1
Secara default, kalau tidak ditentukan jumlah angka dibelakang koma, maka akan tertulis sebanyak 6
digit angka. Jumlah desimal menyesuaikan. Jumlah digit angka dapat diatur menggunakan perintah
setprecision(). Cara menuliskan perintah setprecision() adalah sebagai berikut.
setprecision(presisi)
presisi menyatakan berapa jumlah angka yang dikehendaki. Sebagai gambaran program diatas akan
dimodifikasi dengan perintah ini.
// nama program: cpresisi.cpp

// memberi contoh penggunaan setprecision
#include<iostream>
#include<iomanip>
25
main()
{
float x = 123.12345, y=12345.12345;
<<"nilai x = "<<setprecision(9)<<x<<endl
<<"nilai y = "<<setprecision(5)<<y<<endl;
}
keluaran:
nilai x = 123.123451
nilai y = 12345
Pada program tersebut data x ditampilkan menggunakan 9 angka, sedangkan data y ditampilkan
menggunakan 5 angka. Perintah setprecision() hanya mempengaruhi satu tampilan perintah yang
mengikutinya.
Manipulator lain yang dapat digunakan untuk memberikan efek pada cout adalah perintah setw().
Perintah ini digunakan untuk menentukan lebar medan yang akan digunakan untuk menampilkan
keluaran. Nilai yang ditampilkan akan dibuat menjadi rata kanan (right justified). Perintah setw() hanya
berpengaruh pada satu keluaran yang mengikutinya. Cara penggunaannya manipulator ini diberikan
pada program berikut.
// nama program: csetw.cpp

// memberi contoh penggunaan setw
#include<iostream>
#include<iomanip>
main()
{
float data_x=123.53, data_y;
data_y=data_x;
<<”nilai data x = “<<setw(7)<<data_x<<endl
<<”nilai data y = “<<setw(10)<<data_y<<endl;
}
keluaran:
nilai data x = 123.53
nilai data y = 123.53
Kadang-kadang diinginkan untuk menampilkan bilangan oktal, heksadesimal maupun desimal. Stream
cout dapat diatur untuk manampilkan beberapa macam bilangan tersebut. Berikut adalah contoh
programnya.
// nama program: cbilangan.cpp

// memberi contoh tampilan bilangan
#include<iostream>
int main()
{
int x=100;
cout<<"Tampilan dalam beberapa bentuk:"<<endl;
cout<<"desimal = "<<dec<<x<<endl
<<"heksadesimal = "<<hex<<x<<endl
<<"oktal = "<<oct<<x<<endl;
}
keluaran:
Tampilan dalam beberapa bentuk:
desimal = 100
26
heksadesimal = 64
oktal = 144
Untuk menampilkan bilangan desimal cukup dengan stream dec, untuk heksadesimal dengan stream
hex, sedangkan untuk bilangan oktal dengan stream oct.
1. Apakah perbedaan antara fungsi utama bentuk:
void main()
dan
int main()
2. Apakah perbedaan perintah berikut
y = 100 + x--;
dan
y = 100 + --x
3. Pernyataan mana yang benar dan mana yang salah, jika salah, maka betulkan
y = 100 + 10;
x = 200,00 + 20;
k = 56 * 23.00;
m = 30.00 / 2.00;
k = 60.00 % 7;
4. Berapa nilai hasil dari pernyataan berikut.
hasil = 100.00 / 3;
hasil = 100 / 3;
hasil = 100 % 3;
5. Berikut ini ada program untuk menghitung luas segiempat, tunjukkan kesalahannya dan betulkan.
#include<iostream>
main()
{
double 3panjang = 10.00, -lebar = 5,66;
double luas = 3panjang * -lebar;
cout<<luas<<endl
}
27
III. STRUKTUR KONDISIONAL

Dalam pemrograman terdapat tiga struktur program dasar yaitu: struktur urut, struktur kondisional dan
struktur kalang. Struktur urut adalah bentuk struktur program yang mana aliran program tidak ada yang
membentuk percabangan, perintah program dijalankan secara urut dari awal sampai akhir. Pada struktur
kondisional, terdapat perintah yang memungkinkan arah aliran program mengalami percabangan.
Sedangkan dalam struktur kalang, terdapat perintah yang memungkinkan suatu perintah diulang-ulang.
Struktur kondisional disebut juga struktur cabang (karena dalam aliran program terdapat percabangan)
atau struktur seleksi (karena memungkinkan arah jalannya program memilih sesuai dengan kondisi yang
dijumpai). Disebut kondisional karena arah aliran program ditentukan oleh kondisi yang dijumpai.
Dalam bahasa C++, struktur kondisional didukung oleh dua perintah dasar yaitu: if dan switch. Bentuk
perintah if mempunyai beberapa variasi sebagai berikut.
A. Bentuk if pertama
Struktur sintaksis if pertama mempunyai bentuk sebagai berikut.
if (ekspresi)
{
pernyataan;
}
Bentuk pertama ini dibaca:

JIKA ekspresi benar, MAKA kerjakan pernyataan
Bentuk pertama ini merupakan bentuk perintah if yang paling sederhana. Dalam bentuk ini, pernyataan
akan dikerjakan jika ekspresi bernilai benar. Nilai benar dalam bahasa C++ dinyatakan dengan nilai 1
(satu) sedang Nilai salah dinyatakan dengan nilai 0 (nol). Contoh penerapan perintah if terdapat pada
program berikut.
// nama program : ccontoh_if.cpp

// sebagai contoh perintah if
#include<iostream>
main()
{
double nilai;
cout<<"Masukkan Nilai Anda : ";
cin>>nilai;
if (nilai<=50)
{
cout<<"Nilai Anda = "<<nilai<<endl;
cout<<"Anda dinyatakan gagal"<<endl;
}
}
keluaran
Masukkan Nilai Anda : 45
Nilai Anda = 45
Anda dinyatakan gagal
Dalam program tersebut terdapat perintah kondisional untuk menentukan apakah seseorang lulus atau
tidak. Program tersebut kalau dijalankan akan meminta masukan dari papan ketik berupa nilai, kemudian
menentukan apakah nilai tersebut termasuk kriteria lulus atau tidak.
28
Berikutnya contoh penggunaan perintah if lainnya.
// nama program : ccontoh_if2.cpp

// sebagai contoh perintah if
#include<iostream>
main()
{
int data_1, data_2;
cout<<"Masukkan data pertama dan kedua : ";
cin>>data_1>>data_2;
if (data_1>data_2)
{
cout<<"Nilai data pertama = "<<data_1<<endl;
cout<<"Nilai data kedua = "<<data_2<<endl;
cout<<"Data pertama lebih besar"<<endl;
}
}
keluaran:
Masukkan data pertama dan kedua : 100 75
Nilai data pertama = 100
Nilai data kedua = 75
Data pertama lebih besar
Program tersebut, memerlukan dua data yang dimasukkan melalui papan ketik. Setelah dimasukkan,
maka dua data tersebut dibandingkan, jika data_1 lebih besar dibanding data_2, maka akan ditampilkan
pesan-pesan.
2. Bentuk if kedua
Struktur sintaksis if kedua mempunyai bentuk sebagai berikut.
if (ekspresi)
{
pernyataan;
}
else
{
pernyataan lain;
}
Bentuk kedua ini dibaca:

JIKA ekspresi benar, MAKA kerjakan pernyataan,
JIKA TIDAK, kerjakan pernyataan lain.
Dalam bentuk pertama, pernyataan hanya dikerjakan jika ekspresi bernilai benar, kalau bernilai salah,
maka tidak mengerjakan apapun. Dalam bentuk yang kedua, jika ekspresi bernilai benar, maka
mengerjakan pernyataan, tetapi jika ekspresi bernilai salah, maka yang dikerjakan pernyataan lainnya.
Contoh penggunaan perintah if bentuk kedua dituliskan dalam program berikut.
//nama program: ccontoh_ifelse.cpp

// contoh penggunaan perintah if-else
#include <iostream>
main()
29
{
double tinggi;
cout<<"Masukkan berapa tinggi anda : "<<endl;
cin>>tinggi;
if (tinggi>=160)
{
cout<<"Tinggi badan = "<<tinggi<<endl;
cout<<"Anda termasuk tinggi"<<endl;
}
else
{
cout<<"Tinggi badan = "<<tinggi<<endl;
cout<<"Anda termasuk rendah"<<endl;
}
}
keluaran:
Masukkan berapa tinggi anda :
178
Tinggi badan = 178
Anda termasuk tinggi
Program tersebut pada saat dijalankan akan meminta data tentang tinggi seseorang. Jika nilai tinggi yang
dimasukkan lebih besar dibanding 160, maka akan keluar komentar tentang tinggi yang dimasukkan
tersebut.
Contoh lain tentang penggunaan if-else adalah dalam menentukan apakah suatu persamaan kuadrat
punya nilai akar real atau tidak. Persamaan kuadrat ax 2+bx+c=0 akan mempunyai akar real jika nilai
diskriminan lebih besar atau sama dengan nol.
// nama program: cper_kuadrat.cpp

// memberi contoh penggunaan if-else
#include<iostream>
#include<math.h>
main()
{
double a, b, c;
double D, x1, x2;
cout<<"Masukkan nilai a b dan c ? ";
cin>>a>>b>>c;
D = b*b-4*a*c;
if (D>=0)
{
x1 = (-b+sqrt(D) ) /( 2*a);
x2 = (-b-sqrt(D) ) /( 2*a);
cout<<"akar pertama = "<<x1<<endl;
cout<<"akar kedua = "<<x2<<endl;
}
else
{
cout<<"persamaan tidak punya akar real"<<endl;
}
}
keluaran:
Masukkan nilai a b dan c ? 1 -5 6
akar pertama = 3
akar kedua = 2
30
Masukan untuk program tersebut berupa data a, b dan c. Dari tiga data ini akan diperoleh nilai
diskriminan D. Jika nilai diskriminan lebih besar atau sama dengan 0, maka persamaan kuadrat akan
mempunyai nilai akar real, jika tidak, maka tidak mempunyai nilai akar real. Dalam program tersebut
terdapat fungsi sqrt() yang berguna untuk mencari nilai akar suatu bilangan.
3. Bentuk if ketiga (if bertumpuk)

Struktur sintaksis if ketiga yaitu if bertumpuk mempunyai bentuk sebagai berikut.
if(ekspresi1)
{
pernyataan1;
}
else if(ekspresi2)
{
pernyataan2
}
. . . . .
else
{
pernyataan lain;
}
Bentuk ketiga if tersebut dibaca:

JIKA ekspresi1 benar, MAKA kerjakan pernyataan1
JIKA TIDAK,
JIKA ekspresi2 benar, MAKA kerjakan pernyataan2
dst.
JIKA TIDAK, kerjakan pernyataan lain.
Bentuk ketiga if ini merupakan perluasan bentuk kedua if yang mana dalam pernyataan else terdapat if
lagi. Bentuk ini digunakan untuk menyatakan pilihan yang lebih dari dua. Dalam bentuk ini terdapat
beberapa ekspresi yang akan diuji oleh perintah if. Jika salah satu ekspresi benar, maka pernyataan yang
bersesuaian dengan ekspresi tersebut akan dikerjakan. Jika seluruh ekspresi tidak ada yang benar, maka
akan dikerjakan pernyataan yang lain.
Contoh penggunaan if bertumpuk adalah untuk mengkonversi nilai hari menjadi nama hari. Misalnya hari
Senin diberi kode 0, hari Selasa diberi kode 1, hari Kamis diberi kode 2 dan seterusnya. Contoh
programnya adalah sebagai berikut.
// nama program: ckode_hari.cpp

// konversi kode angka menjadi nama hari
#include<iostream>
main()
{
int kode;
cout<<”Masukkan kode hari = ? “;
cin>>kode;
if(kode==0)
cout<<”kode “<<kode<<” = Senin”<<endl;
else if(kode==1)
cout<<”kode “<<kode<<” = Selasa”<<endl;
else if(kode==2)
cout<<”kode “<<kode<<” = Rabu”<<endl;
else if(kode==3)
cout<<”kode “<<kode<<” = Kamis”<<endl;
31
else if(kode==4)
cout<<”kode “<<kode<<” = Jumat”<<endl;
else if(kode==5)
cout<<”kode “<<kode<<” = Sabtu”<<endl;
else if(kode==6)
cout<<”kode “<<kode<<” = Ahad”<<endl;
else
cout<<”kode hari salah”<<endl;
}
keluaran:
Masukkan kode hari = ? 1
kode 1 = Selasa
Jika kode yang dimasukkan salah satu bilangan 0, 1, 2, 3, 4, 5, atau 6, maka keluarannya berupa pesan
nama hari. Jika kode yang dimasukkan bukan dari salah satu bilangan tersebut, maka akan memberi
pesan salah.
4. switch
Kasus yang terjadi pada if bertumpuk, kadang dapat membosankan dalam menulis program, karena
menuliskan beberapa perintah yang hampir sama secara berulang-ulang. Hal demikian akan semakin
terlihat jika ekspresi yang harus diuji oleh perintah if semakin banyak. Dalam kasus seperti ini, bahasa
C++ menyediakan perintah khusus yaitu switch. Bentuk umum perintah switch adalah sebagai berikut.
switch(selektor)
{
case label1: pernyataan1; break;
case label1: pernyataan1; break;
. . . .
default : pernyataan lain;
}
Bentuk perintah di atas dibaca:

JIKA selektor nilainya sama dengan label1,
MAKA dikerjakan pernyataan1.
JIKA selector nilainya sama dengan label2,
MAKA dikerjakan pernyataan2.
. . .
dan seterusnya
JIKA tidak ada label yang benar,
MAKA dikerjakan pernyataan lain.
Perintah switch penggunaannya sangat terbatas. Perintah switch hanya dapat diperlakukan untuk tipe
data int dan char untuk selektor. Keterbatasan lain adalah bahwa label hanya dapat berupa konstanta
bertipe int atau char. Meskipun banyak keterbatasannya, perintah ini tetap berguna untuk kasus-kasus
tertentu.
Sebagai contoh, perintah switch akan digunakan untuk mengganti perintah if-else pada program
kode_hari.cpp. Program tersebut secara mudah dapat dikonversi menjadi program berikut ini.
// nama program: ckode_hari2.cpp

// konversi kode angka menjadi hari dengan switch
#include<iostream>
main()
32
{
int kode;
cout<<”Masukkan kode hari = ? “;
cin>>kode;
switch(kode)
{
case 0 : cout<<”kode “<<kode<<” = Senin”<<endl;
break;
case 1 : cout<<”kode “<<kode<<” = Selasa”<<endl;
break;
case 2 : cout<<”kode “<<kode<<” = Rabu”<<endl;
break;
case 3 : cout<<”kode “<<kode<<” = Kamis”<<endl;
break;
case 4 : cout<<”kode “<<kode<<” = Jumat”<<endl;
break;
case 5 : cout<<”kode “<<kode<<” = Sabtu”<<endl;
break;
case 6 : cout<<”kode “<<kode<<” = Ahad”<<endl;
break;
default : cout<<”kode hari salah”<<endl;
}
}
keluaran:
Masukkan kode hari = ? 2
kode 2 = Rabu
Program di atas menghasilkan keluaran yang sama dengan program sebelumnya. Perhatikan
penggunaan default pada program tersebut. Perintah default digunakan untuk mengarahkan pernyataan
yang tidak bersesuaian dengan perintah case diatasnya. Kasusnya sama untuk mengerjakan perintah
yang tidak sesuai dengan ekspresi yang ada pada perintah if-else.
Selain perintah-perintah kondisional if dan switch, bahasa C++ juga mengenal operator yang fungsinya
seperti perintah kondisional. Operator yang dimaksud adalah ?: dan mempunyai bentuk umum sebagai
berikut.
(ekspresi)?pernyataan1:pernyataan
Bentuk ekspresi biasanya merupakan ekspresi logika yang hanya mempunyai nilai benar dan salah saja,
sedangkan pernyataan dapat berupa pernyataan apapun baik perintah maupun berupa operator
kondisional juga, sehingga dalam operator ada operator lain, seperti if bertumpuk.
Bentuk operator ini dapat digunakan untuk menggantikan perintah if dan berguna untuk lebih
mempersingkat penulisan program karena bentuk perintahnya sangat singkat. Untuk beberapa perintah
kondisional tidak dapat digantikan secara langsung dengan operator ini. Bentuk operator ini lebih singkat
dibandingkan switch. Perubahan dari if bertumpuk menjadi switch memang menyederhanakan penulisan,
tetapi hanya untuk kasus-kasus tertentu. Dengan operator :? maka semua bentuk if dapat ditulis kembali
dengan bentuk yang lebih singkat. Sebagai contoh adalah:
data=(data1<data2)?data1:data2
maksudnya:
if (data1>data2)
data=data1;
else
33
data=data2;
contoh lain:
(nilai_1>nilai_2)?x=nilai_1:x=nilai_2
maksudnya:
if (nilai_1>nilai_2)
x=nilai_1;
else
x=nilai_2;
Contoh penggunaan dalam program, misalnya untuk menentukan apakah seseorang termasuk gemuk
atau kurus, dengan pengujian apakah berat > 60. Jika berat > 60 dikatakan gemuk, kalau tidak dikatakan
kurus.
// nama program: cop_kondisi.cpp

// menerangkan contoh penggunaan operator :?
#include<iostream>
main()
{
int berat;
cout<<”Masukkan berat badan Anda = ? “<<endl;
cin>>berat;
(berat>60)?cout<<”Anda gemuk”<<endl
:cout<<”Anda kurus”<<endl;
}
keluaran:
Masukkan berat badan angka Anda = ?
80
Anda gemuk
Contoh berikutnya adalah untuk mengkonversi nilai angka menjadi nilai huruf. Ketentuan yang
diberlakukan adalah:
0<nilai<20 :E
20<=nilai<40 :D
40<=nilai<60 :C
60<=nilai<80 :B
80<=nilai<=100 :A
Dalam pembuatan program, mungkin tidak perlu sama dengan kondisi yang telah dibuat tersebut, tetapi
hasil keluaran programnya benar.
// nama program: cop_kondisi2.cpp

// contoh penggunaan operator :?
#include<iostream>
main()
{
int nilai_angka;
char nilai_huruf;
cout<<”Masukkan nilai angka Anda = ? “<<endl;
34
cin>>nilai_angka;
nilai_huruf=(nilai_angka<20)?’E’:
(nilai_angka<40)?’D’:
(nilai_angka<60)?’C’:
(nilai_angka<80)?’B’:’A’;
cout<<”Nilai huruf Anda = ”<<nilai_huruf<<endl;
}
keluaran:
Masukkan nilai angka Anda = ?
40
Nilai huruf Anda = C
Mungkin menimbulkan pertanyaan juga, bagaimana jika yang diubah menggunakan operator :? adalah
bentuk pertama dari if, karena dalam operator :? harus ada pernyataan untuk else-nya?. Tidak menjadi
masalah, karena bentuk else-nya dapat disisi dengan pernyataan sembarang saja. Sebagai contoh
misalnya:
if(angka<0)
angka=-1*angka;
Perintah tersebut dapat ditulis menjadi
(angka<0)?angka=-1*angka:0;
Petikan program di atas menyatakan jika angka>0 maka angka dikalikan –1, jika tidak maka tidak
mengerjakan apa-apa. Dalam operator :? cukup diberi pernyataan sembarang untuk menggantikan else.
Dalam petikan program di atas dinyatakan dengan bilangan 0 yang tidak punya pengaruh apapun.
Salah satu keterbatasan operator :? adalah bahwa pernyataan yang diungkapkan harus berupa
pernyataan tunggal, bukan merupakan blok pernyataan (beberapa pernyataan). Tentu saja hal ini dapat
diatasi dengan cara mengumpulkan beberapa pernyataan dalam satu fungsi tertentu yang tipenya bukan
void.
1. Apakah maksud petikan program di bawah ini?
if(bil>=0)
angka = bil++;
else
angka = bill--;
2. Buatlah program untuk membedakan apakah suatu bilangan punya akar real atau akar imaginer
3. Buatlah program untuk menyeleksi suatu bilangan dengan ketentuan sebagai berikut.
0<=nilai<30 : nilai rendah
30<=nilai<60 : nilai sedang
60<=nilai<=100 : nilai tinggi
4. Buatlah juga dengan ketentuan di atas menggunakan struktur perintah switch
5. Apakah pengaruh penghilangan perintah break() pada struktur perintah switch
35
IV. PERULANGAN
Struktur perulangan merupakan hal yang sangat penting dalam algoritma program. Kadang-kadang
diinginkan untuk mengulang-ulang perintah untuk maksud tertentu. Perulangan digunakan untuk
menghindari penggunaan penulisan perintah secara berulang, apalagi perintah tersebut sebetulnya
merupakan perintah yang sama. Perintah perulangan pada dasarnya merupakan kemampuan bahasa
pemrograman untuk mengulang-ulang suatu perintah sampai suatu kondisi dipenuhi.
Misalnya diinginkan untuk menuliskan tampilan dari nol sampai seratus. Secara program dapat ditulis
program yang berulang yaitu mencetak bilangan dari nol sampai seratus. Tentu saja hal ini kurang
bijaksana, karena akan memerlukan jumlah perintah yang banyak sekali. Apalagi kalau yang ditampilkan
tidak hanya sampai seratus, bisa sampai seribu. Tentu saja menjemukan. Hal ini dapat dihindari jika
digunakan perintah perulangan.
Bahasa C++ mempunyai tiga perintah struktur perulangan yaitu:
 do-while
 while, dan
 for.
Struktur perulangan do-while dan while biasanya digunakan untuk perulangan yang jumlah
perulangannya belum dapat dipastikan, sedangkan perintah perulangan for digunakan untuk perulangan
yang jumlah perulangannya sudah dapat dipastikan. Meski demikian, sebetulnya ketiga perintah
perulangan dapat saling menggantikan untuk kasus-kasus tertentu. Artinya program yang ditulis
menggunakan struktur perintah do-while dapat ditulis ulang menggunakan perintah while atau for, begitu
juga sebaliknya.
A. Struktur do-while
Struktur perulangan do-while mempunyai bentuk sebagai berikut.
do
{
perintah;
}
while (kondisi)
Struktur di atas jika diungkapkan dengan bahasa manusia berbunyi:

Kerjakan perintah selama kondisi bernilai benar.
Dalam struktur ini, dapat diamati bahwa perintah paling sedikit akan dikerjakan satu kali. Perintah pasti
dikerjakan, karena langkah pertama struktur perulangan do-while mengerjakan perintah, kemudian baru
diikuti pengujian terhadap kondisi. Tentu saja struktur ini sangat cocok untuk program yang tidak
memerlukan pengujian terlebih dahulu sebelum mengerjakan perintah.
contoh penggunaan:
data = 0;
do
{
data++;
cout<<data<<” “<<endl;
}
while (data <100);
36
Petikan program tersebut digunakan untuk menampilkan bilangan dari 1 sampai 100. Mula-mula data
diberi nilai nol. Langkah pertama perulangan menaikkan nilai data, kemudian mencetak nilai data.
Perintah ini diulang-ulang selama nilai data kurang dari 100. Perulangan berhenti pada saat data
mencapai nilai 100, karena pada keadaan ini kondisi data<100 bernilai salah.
Contoh lain adalah untuk menampilkan bilangan genap dari 0 sampai 30. Pada program ini digunakan
kombinasi perintah perulangan dan kondisional.
// nama program: cdo_while.cpp

// contoh penggunaan perintah do-while
#include<iostream>
main()
{
int angka=0;
do
{
angka++;
if(angka%2==0)
cout<<angka<<” “;
}
while (angka<30);
}
keluaran:
2 4 6 8 10 12 14 16 18 20 22 24 26 28 30
Pada program tersebut, perulangan dilakukan selama angka lebih kecil dibanding 30. Pada blok perintah
do-while terdapat perintah untuk menyeleksi bilangan yang akan ditampilkan. Sebelum bilangan
ditampilkan diuji dahulu, apakah bilangan bersangkutan habis dibagi dua. Jika bilangan habis dibagi dua
maka akan ditampilkan, sehingga secara keseluruhan program tersebut akan menampilkan bilangan
genap sampai 30.
Struktur do-while dapat juga digunakan untuk mengendalikan masukan pada suatu program. Misalkan
diinginkan agar data yang dimasukkan harus bilangan antara 0 sampai 100. Dapat dibuat program
sedemikian sehingga, jika yang dimasukkan tidak pada range tersebut, maka selalu mengulang minta
masukan. Contoh programnya sebagai berikut.
// nama program: cinput.cpp

// penggunaan perulangan untuk pengendalian masukan
#include <iostream>
main()
{
int masukan;
cout<<”Masukkan bilangan dari 0 sampai 100”<<endl;
do
{
cin>>masukan;
}
while(masukan<0 || masukan>100);
cout<<”Bilangan yang dimasukkan = “<<masukan<<endl;
}
keluaran:
Masukkan bilangan dari 0 sampai 100
23
Bilangan yang dimasukkan = 23
Program tersebut pada saat dijalankan akan minta data masukan dari papan ketik. Data yang diinginkan
37
antara 0 sampai 100, jika data yang dimasukkan di luar nilai tersebut, maka perintah minta masukan
akan diulang-ulang terus sampai data yang dimasukkan sesuai.
2. Struktur while
Struktur while mempunyai bentuk perintah sebagai berikut.
while (kondisi)
{
perintah;
}
Struktur tersebut jika diungkapkan dalam bahasa manusia berbunyi:

Selama kondisi bernilai benar, kerjakan perintah.
Struktur while hampir sama dengan struktur do-while. Program yang ditulis menggunakan perintah do-
while dapat diubah menggunakan perintah while tanpa ada perubahan yang berarti.
Perbedaan dengan struktur do-while adalah bahwa pada struktur while perintah belum tentu dikerjakan,
tergantung pada kondisi awalnya. Jika kondisi awalnya sudah bernilai salah, maka perintah tidak pernah
dikerjakan. Berbeda dengan struktur do-while yang mana perintah pasti pernah dikerjakan. Hal ini
disebabkan sebelum mengerjakan perintah, dilakukan pengujian terhadap kondisi terlebih dahulu.
Perintah while lebih cocok digunakan untuk membuat program yang mana sebelum mengerjakan
perintah, harus diuji dahulu suatu kondisi. Contoh yang sederhana dalam operasi file, yang mana
sebelum file dibaca, harus diuji tentang keberadaan file. Meski demikian, pada dasarnya perintah do-
while dan while dapat saling menggantikan.
contoh penggunaan:
data = 0;
while (data <100)
{
data++;
cout<<data<<” “<<endl;
}
Petikan program di atas adalah contoh bagaimana struktur while digunakan. Petikan program tersebut
sama dengan petikan program sebelumnya yang menggunakan perintah do-while. Dapat dilihat bahwa
tidak banyak perubahan yang dilakukan untuk mengubah dari struktur do-while menjadi while. Perintah
perulangan yang digunakan tetap, kemudian kondisi yang digunakan juga tetap, hasil programnya juga
sama.
Contoh yang lain adalah untuk menampilkan bilangan genap dari 0 sampai 30 seperti pada program
sebelumnya.
// nama program: cwhile.cpp

// contoh penggunaan perintah while
#include<iostream>
main()
{
int angka=0;
while (angka<30)
{
angka++;
if(angka%2==0)
cout<<angka<<” “;
38
}
}
keluaran:
2 4 6 8 10 12 14 16 18 20 22 24 26 28 30
Dapat dilihat bahwa perintah program yang digunakan pada struktur while sama persis dengan perintah
program dalam struktur do-while. Tentu saja hal ini tidak berlaku untuk semua kasus. Untuk beberapa
kasus perlu penyesuaian. Contoh berikutnya adalah contoh yang memerlukan penyesuaian.
// nama program: cinput2.cpp

// penggunaan perulangan untuk mengendalikan masukan
#include <iostream>
main()
{
int masukan;
masukan = 200;
cout<<”Masukkan bilangan dari 0 sampai 100”<<endl;
while(masukan<0 || masukan>100);
{
cin>>masukan;
}
cout<<”Bilangan yang dimasukkan = “<<masukan<<endl;
}
keluaran:
Masukkan bilangan dari 0 sampai 100
25
Bilangan yang dimasukkan = 25
Pada contoh di atas, ditambahkan satu perintah yang menyebabkan kondisi while pada awalnya bernilai
salah yaitu mula-mula masukan diberi nilai 200. Perintah ini digunakan untuk memberi nilai salah pada
kondisi while, sehingga perintah perulangan dikerjakan. Jika kondisi awal sudah bernilai benar, yang
mana nilai masukan sudah pada range 0 sampai 100, maka perintah perulangan tidak pernah dikerjakan,
sehingga tidak pernah minta masukan dari papan ketik.
3. Struktur for
Struktur for digunakan untuk perulangan yang mana jumlah perulangan sudah dipastikan. Penggunaan
struktur for banyak untuk matriks dan statistik yang mana ukuran matriks dan ukuran data dalam statistik
sudah tertentu. Struktur for mempunyai bentuk sebagai berikut.
for(inisialisasi; kondisi; perubahan)

{
perintah;
}
keterangan:
inisialisasi : untuk memberi nilai awal pada variabel kendali
kondisi : menyatakan kondisi berhenti perulangan
perubahan : menyatakan perubahan nilai variabel kendali
Struktur for merupakan bentuk khusus dari struktur perulangan do-while atau while, artinya struktur for
dapat diganti menggunakan struktur do-while atau while tetapi tidak berlaku sebaliknya. Sebagai contoh
39
adalah petikan program berikut.
for(int k=0; k<10; k++)

{
cout<<k<<endl;
}
Petikan program tersebut sama dengan petikan program berikut yang menggunakan struktur do-while.
int k=0;
do
{
cout<<k;
k++;
}
while (k<10);
atau dengan struktur while berikut ini.
int k=0;
while (k<10)
{
cout<<k;
k++;
}
Contoh penggunaan struktur for untuk menampilkan bilangan genap dari 0 sampai 30 adalah sebagai
berikut.
// nama program: cfor.cpp

// contoh penggunaan for untuk perulangan
#include<iostream>
main()
{
for(int k=1; k<31; k++)
{
if(k%2==0)
cout<<k<<” “;
}
}
keluaran:
2 4 6 8 10 12 14 16 18 20 22 24 26 28 30
Penggunaan struktur for untuk pengendalian masukan tidak dapat dilakukan secara langsung, tetapi
harus menggunakan mekanisme break() untuk keluar dari kalang yang akan dibahas berikutnya.
Contoh kasus yang lain misalnya diinginkan untuk membuat program yang dapat menjumlahkan seluruh
bilangan ganjil dari 0 sampai 100. Program ini merupakan perluasan dari program di atas.
// nama program: cjumlahan.cpp

// contoh penggunaan for untuk jumlahan berulang
#include<iostream>
main()
{
40
int total = 0;
cout<<”jumlah bilangan ganjil 0 sampai 100”<<endl;
for(int m=0; m<=100; m++)
{
if(m%2!=0)
total += m;
}
cout<<”Hasilnya = “<<total<<endl;
}
keluaran:
jumlah bilangan ganjil 0 sampai 100
Hasilnya = 2500
Pada program di atas, perintah penjumlahan berikut
total += m
hanya akan dikerjakan jika m dibagi dua hasilnya tidak nol, artinya bilangan ganjil, sehingga yang
dijumlahkan hanya bilangan ganjil saja. Sedangkan jika m bilangan genap, maka perintah penjumlahan
tidak dijalankan.
Penggunaan struktur for sangat memudahkan algoritma program terutama jika perulangan dilakukan
secara bertumpuk yang mana dalam struktur perulangan ada perulangan lain. Perulangan bertumpuk,
jika dilakukan menggunakan perintah do-while atau while, maka akan terasa rumit dan mungkin
membingungkan.
Program berikut adalah cara untuk membuat daftar penjumlahan yang biasanya digunakan oleh anak-
anak menghapalkan operasi perkalian matematika untuk bilangan antara 0 sampai 10. Bentuk
programnya sebagai berikut.
// nama program: cperkalian.cpp

// contoh penggunaan perulangan bertumpuk
#include<iostream>
#include<iomanip>
main()
{
for(int k=0; k<=10; k++)
{
for(int m=0; m<=10; m++)
{
cout<<setw(3)<<m*k<<” “;
}
cout<<endl;
}
}
keluaran:
1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60
7 14 21 28 35 42 49 56 63 70
8 16 24 32 40 48 56 64 72 80
9 18 27 36 45 54 63 72 81 90
10 20 30 40 50 60 70 80 90 100
41
Program tersebut menggunakan struktur for yang ditumpuk dua, sehingga jumlah perulangannya menjadi
perkalian masing-masing perulangan. Hasil yang ditampilkan adalah hasil perkalian dari variabel kendali
perintah for, sehingga membentuk tampilan tabel perkalian di atas.
4. Perintah break, continue dan exit ()

Perintah break, continue dan exit() kadang sering digunakan bersama struktur perulangan. Ketiga
perintah tersebut mempunyai kegunaan yang berbeda yaitu:
 break : untuk keluar dari blok perintah, juga blok kalang
 continue : untuk melanjutkan pada iterasi berikutnya
 exit() : untuk keluar dari program.
Kadang-kadang diinginkan untuk menghentikan perputaran perulangan secara paksa untuk suatu
keperluan tertentu. Penghentian ini mungkin dengan pertimbangan, jika dilanjutkan perulangan, maka
akan menyebabkan suatu run-time error atau memang sengaja dihentikan karena perputaran dirasa
cukup. Sebagai contoh akan digunakan perintah break untuk program pengendalian masukan.
// nama program: ckendali.cpp

// penggunaan for dan break
#include<iostream>
main()
{
int angka;
cout<<”Masukkan angka dari 0 sampai 10 ?”<<endl;
for( ; ; )
{
cin>>angka;
if(angka>=0 && angka<=10) break;
}
cout<<”Anda memasukkan angka : “<<angka<<endl;
}
keluaran:
Masukkan angka dari 0 sampai 10 ?
5
Anda memasukkan angka : 5
Pada contoh program di atas terdapat bentuk perulangan for( ; ; ) yang mana merupakan bentuk
perulangan yang tidak pernah berhenti. Bentuk ini dimaksudkan agar perulangan akan selalu dikerjakan,
jika angka yang dimasukkan bukan angka yang terletak antara 0 sampai 10. Pada blok perintah yang ada
dalam perulangan for terdapat dua perintah yaitu: memasukkan data dan pengujian kondisi apakah
angka yang dimasukkan sudah sesuai. Jika angka yang dimasukkan sudah sesuai maka perulangan
akan di-break.
Untuk lebih memperjelas perbedaan penggunaan perintah break, continue dan exit(), perhatikan
program-program berikut ini.
// nama program: cbreak.cpp

// contoh penggunaan break
#include<iostream>
main()
{
int k;
for(k=0; k<30; k++)
42
{
if(k>10)
break;
cout<<k<<” “;
}
cout<<endl;
cout<<”Kalang di-break pada k = “<<k<<endl;
}
keluaran:
0 1 2 3 4 5 6 7 8 9 10
Kalang di-break pada k = 11
Perhatikan hasil keluaran dari program. Perulangan tidak dilakukan sampai 30 kali karena setelah k
mencapai nilai 11, dilakukan break pada perulangan.
Selanjutnya perhatikan program berikut yang menggambarkan penggunaan perintah continue.
// nama program: ccontinue.cpp

// contoh penggunaan perintah continue
#include<iostream>
main()
{
for(int k=0; k<30; k++)
{
if(k%2==0)
continue;
cout<<k<<” “;
}
cout<<endl;
cout<<”Bilangan genap dilompati”<<endl;
}
keluaran:
1 3 5 7 9 11 13 15 17 19 21 23 25 27 29
Bilangan genap dilompati
Pada program tersebut, jika k habis dibagi 2, maka pada kalang akan menjalankan perintah continue.
Perintah ini menyebabkan baris perintah di bawah perintah continue tidak akan dilaksanakan, dalam hal
ini perintah menampilkan nilai k. Perulangan akan melanjutkan pada iterasi berikutnya, yaitu nilai k naik.
Setelah seluruh putaran dilalui terakhir memberi pesan. Akibatnya, bilangan yang ditampilkan hanya
bilangan yang tidak habis dibagi dua atau bilangan ganjil.
Selanjutnya contoh penggunaan perintah exit() dalam program. Perintah ini menyebabkan arah aliran
program keluar, sehingga mungkin hasil eksekusi program tidak akan terlihat. Pada platform Windows,
perintah exit() prototipe fungsinya berada pada file header stdlib.h, sehingga file ini harus disertakan.
Pada platform Linux, prototipe fungsi exit() sudah ada dalam iostream.h, sehingga tidak perlu
menyertakan stdlib.h. Berikut ini adalah contoh programnya.
// nama program: cexit.cpp

// contoh penggunaan exit
#include<iostream>
#include<stdlib>
main()
{
int k;
for(k=0; k<30; k++)
{
43
if(k>10)
exit(1);
cout<<k<<” “;
}
cout<<”Perintah ini tidak dikerjakan“<<endl;
}
keluaran:
1 2 3 4 5 6 7 8 9 10
Hasil keluaran program mungkin tidak terlihat, karena cepatnya eksekusi program. Pada saat nilai k
mencapai nilai 11, eksekusi program akan dihentikan akibat dijumpainya perintah exit(). Dengan
demikian, perintah terakhir tidak dikerjakan.
1. Berikut ini adalah contoh program dalam struktur while
#include<iostream>
main()
{
int bil=0;
double data=0;
while(bil++<10)
{
if(bil%2==0||bil%3==0)
{
data += bil;
}
}
cout<<"data="<<data<<endl;
}
2. Program di atas untuk apa? Berapa nilai yang ditunjukkan data?

3. Ubahlah program tersebut ke dalam struktur do-while
4. Ubahlah program tersebut ke dalam struktur for
5. Berikut ini program sederhana dalam struktur for
#include<iostream>
main()
{
double data=0;
for(int k=0;data<50;k++)
{
data = 2*k;
cout<<data<<" ";
}
}
(a) Ubahlah program tersebut ke dalam struktur do-while

(b) Ubahlah program tersebut ke dalam struktur while
(c) Buatlah program untuk menghitung hasil kali seluruh bilangan ganjil dari 1 sampai 20. Buatlah
menggunakan struktur while, do-while dan for
44
45
V. TIPE DATA TERSTRUKTUR

Tipe data terstruktur adalah tipe data yang dapat diturunkan dari tipe data dasar dalam bahasa C++. Tipe
data ini merupakan perluasan dari tipe data dasar. Ada beberapa tipe data terstruktur antara lain larik,
struktur dan union.
A. Larik
Larik merupakan sekumpulan data yang mempunyai nama dan tipe yang sama. Larik disebut juga
variabel berindeks. Nilai suatu data dalam larik ditentukan oleh nama dan indeksnya. Larik banyak
digunakan pada operasi yang melibatkan indeks seperti pada statistik dan matriks.
Tipe data larik dapat berupa larik satu dimensi (ID), dua dimensi (2D), tiga dimensi (3D) atau banyak
dimensi.
Cara mendeklarasikan suatu larik dalam bahasa C++ sangat mudah.
larik satu dimensi:
tipe_larik nama_larik[ukuran]
larik dua dimensi:

tipe_larik nama_larik[ukuran1][ukuran2]
larik tiga dimensi:

tipe_larik nama_larik[ukuran1][ukuran2][ukuran3]
contoh penggunaan:
double larik_1[10];
char larik_2[5][7];
int larik3[6][4][8];
Yang perlu diingat bahwa larik dalam bahasa C++ tidak dimulai dari indeks satu, tetapi dimulai dari indeks
0 (nol). Misalnya dideklarasikan suatu larik satu dimensi
int x[7];
Larik yang terjadi adalah sebagai berikut.
x[0], x[1], x[2], x[3], x[4], x[5] dan x[6].
Cara memberi nilai pada larik harus satu demi satu sesuai dengan indeksnya.
larik_1[0] = 10.0;
larik_1[1] = 30.0;
larik_1[2] = 40.0;
Nilai larik juga dapat langsung ditampilkan misalnya
cout<<larik_1[0]<<endl;
cout<<larik_2[1][3]<<endl;
46
cout<<larik_3[3][2][2]<<endl;
Untuk memberi nilai awal pada larik biasanya digunakan struktur perulangan for yang mana jumlah
perulangan yang terjadi disesuaikan dengan ukuran larik. Contoh untuk larik satu dimensi, cara
menginisialisasinya sebagai berikut.
for(int k=0; k<10; k++)

{
x[k]=k;
}
Pada petikan program tersebut nilai x diberi nilai sesuai dengan indeksnya. Tentunya dapat dibuat variasi
lain untuk pemberian nilai awal ini.
Jika diinginkan nilai larik dimasukkan dari papan ketik, dapat digunakan perintah cin untuk memasukkan
data.
for(int k=0; k<10; k++)

{
cout<<”masukkan data ke-<<k<<“ = ?“;
cin>>x[k];
}
Untuk menginisialisasi larik yang dua dimensi digunakan perintah perulangan for yang ditumpuk,
sehingga digunakan dua indeks sekaligus.
for(int m=0; m<10; m++)

{
for(int n=0; n<10; n++)
{
y[m][n]=m+n;
}
}
Demikian juga kalau akan dimasukkan data dari papan ketik, dapat digunakan perintah cin misalnya.
for(int m=0; m<10; m++)

{
for(int n=0; n<10; n++)
{
cout<<”Masukkan y[“<<m<<”,”<<n<<”] = ? ”;
cin>>y[m][n];
}
}
Untuk menampilkan isi larik juga sangat mudah, dengan menggunakan perintah cout untuk masing-
masing data. Sebagai contoh program lengkap untuk memasukkan dan menampilkan isi larik dapat
dilihat di bawah ini.
// nama program: clarik.cpp

// contoh memasukkan larik dan menampilkan isinya
#include<iostream>
main()
{
int data[5];
47
for(int k=0; k<5; k++)

{
cout<<”Masukkan data[“<<k<<”] = ? “;
cin>>data[k];
}
{
cout<<”Data[“<<k<<”] = “<<data[k]<<endl;
}
}
keluaran:
Masukkan data[0] = ? 10
Data[0] = 10
Data[1] = 110
Data[2] = 120
Data[3] = 130
Data[4] = 140
Contoh lain yang masih berhubungan dengan larik adalah program untuk mencari nilai rata-rata dari
sekumpulan data. Nilai rata-rata dari sekumpulan data adalah jumlahan dari seluruh data dibagi dengan
jumlah data. Biasanya indeks data dalam statistik dimulai dari satu, sehingga harus disesuaikan dengan
program dalam bahasa C++ yang mana indeks larik dimulai dari nol. Sebetulnya hal ini tidak terlalu sulit
untuk dikerjakan.
Contoh programnya adalah sebagai berikut.
// nama program: crata_rata.cpp

// contoh penggunaan larik untuk mencari rata-rata
#include<iostream>
main()
{
int data[5];
int rata_rata, total=0;
for(int m=0; m<5; m++)
{
cout<<”Masukkan data[“<<m<<”] = ? “;
cin>>data[m];
}
{
total += data[m];
}
rata_rata=total/5;
cout<<”Rata-rata data = “<<rata_rata<<endl;
}
keluaran:
Rata-rata data = 12
48
Berikutnya adalah penggunaan larik dua dimensi untuk operasi pemberian nilai pada matriks. Operasi
pemberian nilai matriks tidak seperti operasi pemberian nilai pada variabel biasa, pemberian nilai
dilakukan elemen demi elemen, sehingga seluruh elemen matriks diberi nilai semua. Programnya cukup
sederhana dan dapat digunakan larik dua dimensi.
// nama program: cinisial_matriks.cpp

// contoh penggunaan larik dua dimensi pada matriks
#include<iostream>
#include<iomanip>
main()
{
double x[3][3];
cout<<"Masukkan elemen matriks ?"<<endl;
for (int k=0; k<3; k++)
{
{
cout<<"x["<<k<<","<<m<<"] = ";
cin>>x[k][m];
}
cout<<endl;
}
cout<<"Hasil matriksnya : "<<endl;
for (int k=0; k<3; k++)
{
{
cout<<setw(5)<<x[k][m];
}
cout<<endl;
}
}
keluarannya:
Masukkan elemen matriks ?
x[0,0] = 12
x[0,1] = 3
x[0,2] = 42
x[1,0] = 3
x[1,1] = 7
x[1,2] = 34
x[2,0] = 7
x[2,1] = 12
x[2,2] = 11
Hasil matriksnya :
12 3 42
3 7 34
7 12 11
Larik yang sudah dibahas adalah larik bertipe numerik. Selain bertipe numerik, larik dapat juga bertipe
char. Larik char dalam bahasa pemrograman lain biasa disebut string. Walaupun tidak persis sama,
tetapi untuk beberapa hal perilaku larik char dan string dapat dikatakan sama. Perbedaan mendasar
antara larik char dan string adalah bahwa pada setiap akhir suatu string terdapat karakter NULL atau ‘\0’
yang menandai akhir suatu string.
contoh:
49
char nama[15] = “Ismah Hanifi”;

char alamat[] = “Yogyakarta”;
char *hobbi = “Belajar”;
Bentuk pendeklarasian suatu string mirip dengan pendeklarasian larik karakter. Bentuk ketiga adalah
teknik lain mendeklarasian larik yang akan dibahas lebih jauh pada pembahasan pointer. Hasil perintah-
perintah tersebut berupa tiga string yang susunannya dapat digambarkan sebagai berikut.
nama --> |I|s|m|a|h| |H|a|n|i|f|i|\0|?|?|

alamat --> |Y|o|g|y|a|k|a|r|t|a|\0|
hobbi --> |B|e|l|a|j|a|r|\0|
Perhatikan bahwa pada tiap akhir suatu string selalu terdapat karakter NULL (‘\0’). Dengan demikian
untuk merubah larik karakter menjadi string, cukup ditambahkan karakter null pada karakter paling akhir.
Untuk memberi nilai pada suatu string, tidak diperbolehkan menggunakan operator penugasan ( = ).
Untuk memberi nilai string dapat menggunakan tiga cara yaitu dengan cara inisialisasi, diambil dari
papan ketik atau menggunakan fungsi strcpy().
// nama program: cstring.cpp

// contoh pemakaian string
#include<iostream>
main()
{
char nama[]=”Ilham Hanif”; //inisialisasi string
int nomor;
char alamat[15], alamat_lain[15];
cout<<”Masukkan data tentang : “<<endl;
cout<<”Masukkan nomor : “;
cin>>nomor;
cout<<”Masukkan alamat : “;
cin>>alamat;
//cara memberi nilai suatu string
strcpy(alamat_lain, alamat);
cout<<”Data yang dimasukkan :”<<endl;
cout<<”nama : “<<nama<<endl
<<”nomor : “<<nomor<<endl
<<”alamat : “<<alamat<<endl
<<”alamat 2 : “<<alamat_lain<<endl;
}
keluaran:
Masukkan data tentang :
Masukkan nomor : 907869
Masukkan alamat : Yogyakarta
Data yang dimasukkan :
nama : Ilham Hanif
nomor : 907869
alamat : Yogyakarta
alamat 2 : Yogyakarta
Pada program tersebut terdapat tiga macam pemberian nilai pada string. Yang pertama dengan cara
inisialisasi string yaitu pada saat variabel nama dideklarasikan langsung diberi nilai dengan suatu isian.
Yang kedua dengan cara dimasukkan dari papan ketik dengan perintah cin yaitu pada saat pemberian
nilai variabel alamat. Kemudian yang ketiga dengan cara menyalin dari string lain dengan fungsi strcpy()
yaitu pada saat pemberian nilai variabel alamat_lain dengan alamat.
50
Untuk pemberian nilai string melalui papan ketik menggunakan cin harus diperhatikan bahwa dalam
string yang dimasukkan tidak boleh mengandung karakter spasi. Karakter spasi oleh perintah cin
dianggap sebagai batas masukan suatu string, sehingga tulisan di belakang suatu spasi dianggap
sebagai string lain.
Karena suatu string pada dasarnya merupakan suatu larik karakter, elemen data suatu string dapat
diperlakukan seperti karakter bebas. Berikut ini contoh bagaimana suatu larik karakter diurutkan
menggunakan suatu metode sorting.
// nama program csorting_string.cpp

// contoh perlakuan terhadap elemen larik karakter
#include<iostream>
main()
{
char x[100],temp;
cout<<”Masukkan kalimat tanpa spasi: ? ”;
cin>>x;
int n=strlen(x);
for(int k=1;k<n-1;k++)
{
for(int m=1;m<n-1;m++)
{
if(x[m+1]>x[m])
{
temp=x[m];
x[m]=x[m+1];
x[m+1]=temp;
}
}
}
cout<<”Diurutkan menjadi : “<<x<<endl;
}
keluaran:
Masukkan kalimat tanpa spasi: ? belajar-pemrograman
Diurutkan menjadi : brrrponmmljgeeaaaa-
Pada program tersebut, masing-masing elemen string yang dianggap sebagai suatu karakter
dibandingkan satu dengan yang lain. Jika suatu karakter urutannya terbalik, maka dilakukan proses
pertukaran. Teknik ini merupakan salah satu metode sorting yang disebut bubble-sort. Hasil yang
diperoleh adalah urutan karakter sesuai urutan daftar karakter ASCII.
2. Pointer
Pointer adalah variabel yang mencatat alamat variabel lain. Variabel yang dicatat alamatnya oleh pointer
dapat berupa int, char, float, double, atau tipe data yang lain yang didukung oleh bahasa C++. Dengan
demikian pointer merupakan variabel yang menunjuk kepada variabel lain.
Seperti halnya tipe-tipe yang lain, pointer harus dideklarasikan sebelum digunakan. Cara
mendeklarasikan variabel bertipe pointer adalah sebagai berikut.
nama_tipe *pnama_pointer
pnama_pointer adalah nama variabel pointer yang dipakai, nama_tipe adalah sembarang tipe yang
didukung oleh bahasa C++ dan menunjukkan tipe variabel yang akan ditunjuk oleh pointer, sedangkan
tanda asterisk (*) merupakan tanda yang menunjukkan bahwa pnama_pointer merupakan suatu pointer
yang akan menunjuk pada suatu variabel bertipe nama_tipe (bukan variabel bertipe nama_tipe).
51
Sebelum dapat digunakan, pointer harus diciptakan terlebih dahulu. Penciptaan suatu pointer
menggunakan perintah new. Pada saat diciptakan, pointer menunjuk suatu variabel (lebih tepatnya lokasi
memori) yang menyimpan suatu data bertipe sesuai dengan nama_tipe. Nilai yang ditunjuk pointer dapat
diubah-ubah selama proses program berjalan. Lokasi yang ditunjuk pertama-kali oleh suatu pointer tidak
dapat diketahui secara pasti.
Setelah tidak diperlukan lagi, pointer dapat dilenyapkan dari memori komputer dengan perintah delete.
Dengan demikian pointer dapat diciptakan dan dapat dilenyapkan selama program berjalan. Perilaku ini
menyebabkan pointer disebut variabel dinamis.
Untuk lebih jelasnya perhatikan dua program sederhana berikut ini beserta ilustrasi yang
menggambarkan pembentukan dan inisialisasi dalam memori.
// nama program: cpointer1.cpp

// memberi contoh pointer dan inisialisasinya
#include<iostream>
main()
{
int *pdata; //pdata akan menunjuk tipe data int
pdata = new int; //cipta pdata & menunjuk var int
*pdata = 100; //beri nilai yang ditunjuk dgn 100
cout<<”alamat pdata : “<<pdata<<endl
<<”nilai yang ditunjuk pdata : “<<*pdata<<endl;
delete pdata;
}
keluaran
alamat pdata : 0x00b90fc4
nilai yang ditunjuk pdata : 100
Gambar 5. Skema Pembentukan Pointer pdata
Perhatikan skema di atas yang menggambarkan lokasi penyimpanan variabel yang digunakan pada
program cpointer1.cpp. Pada program tersebut, mula-mula dideklarasikan suatu variabel pointer yang
akan menunjuk suatu variabel int. Langkah berikutnya menciptakan suatu pointer pdata yang menunjuk
variabel bertipe int yang mana lokasi penyimpanannya tidak diketahui. Langkah selanjutnya mengubah
nilai yang ditunjuk oleh pdata menjadi 100. Sehingga pada akhir program terdapat suatu data bertipe
pointer pdata yang menunjuk pada lokasi memori yang berisi nilai 100. Alamat pdata berada pada lokasi
0x00b90fc4 di memori. Isi dari pdata adalah alamat yang menyimpan nilai 100, yang dalam kasus ini
alamat lokasi penyimpanannya tidak diketahui.
// nama program: cpointer2.cpp

// memberi contoh pointer dan inisialisasinya
52
#include<iostream>
main()
{
int *pdata;
int data=200;
pdata = new int;
*pdata = data;
cout<<"alamat pdata : "<<pdata<<endl
<<"nilai yang ditunjuk pdata : "<<*pdata<<endl
<<"nilai data : "<<data<<endl
<<"alamat data : "<<&data<<endl;
delete pdata;
}
keluaran:
alamat pdata : 0x00b90fc4
nilai yang ditunjuk pdata : 200
nilai data : 200
alamat data : 0x0065fdfc
Gambar 6. Skema Pembentukan Pointer pdata
Dengan menggunakan program cpointer2.cpp, lokasi yang ditunjuk oleh pointer pdata dapat diketahui.
Mula-mula dideklarasikan variabel pointer pdata yang akan menunjuk variabel bertipe int. Kemudian
dideklarasikan pula variabel data bertipe int dan diberi nilai 200. Langkah berikutnya adalah menciptakan
variabel pointer pdata yang menunjuk variabel bertipe int yang lokasinya tidak diketahui. Selanjutnya
pdata disuruh menunjuk lokasi yang ditempati oleh data, sehingga pdata menunjuk nilai 200 sama
dengan data. Dalam kasus ini lokasi terakhir yang ditunjuk pdata diketahui yaitu sama dengan lokasi
variabel data.
Data yang ditunjuk oleh suatu pointer dapat berupa sembarang data. Ada hubungan yang sangat menarik
jika yang ditunjuk oleh suatu pointer adalah larik. Jika data yang ditunjuk oleh suatu pointer berupa larik,
maka lokasi yang ditunjuk oleh pointer tersebut menjadi indeks-0 dari pointer tersebut. Pada dasarnya,
larik dalam bahasa C++ merupakan suatu pointer. Nama suatu larik adalah pointer yang menunjuk pada
indeks-0 larik tersebut. Untuk lebih mendalami masalah ini perhatikan program berikut ini.
// nama program: cpo_larik.cpp

// penggunaan pointer dan larik
#include<iostream>
main()
{
double y[5];
53
{
y[k]=k;
}
double *px;
px = new double;
px=y;
cout<<"k | y[k] | px[k]"<<endl;
{
cout<<k<<" | "<<y[k]<<" | "<<px[k]<<endl;
}
px = NULL;
delete px;
}
keluaran:
k | y[k] | px[k]
0 | 0 | 0
1 | 1 | 1
2 | 2 | 2
3 | 3 | 3
4 | 4 | 4
Dalam program cpo_larik.cpp, mula-mula diinisialisasi suatu larik dengan nilai sama dengan indeksnya.
Kemudian pada saat program berjalan diciptakan pointer px yang menunjuk variabel bertipe double.
Selanjutnya pointer px disuruh menunjuk lokasi yang sama dengan yang ditunjuk oleh y. Hasil yang
diperoleh adalah nilai px menjadi sama dengan y, sehingga terbentuk dua larik identik. Hasilnya
ditampilkan pada layar monitor. Mengapa y (larik) dapat disamakan dengan px (pointer)? Hal ini
disebabkan dalam bahasa C++ sebetulnya larik merupakan suatu pointer. Nama larik sebetulnya
merupakan pointer yang menunjuk pada indeks-0 larik tersebut. Untuk menjelaskan masalah ini,
perhatikan program berikut.
// nama program: clarik_po.cpp

// menerangkan data yang ditunjuk pointer pada larik
#include<iostream>
main()
{
double data[5], *pdata;
pdata = data;
{
data[k]=2*k;
}
cout<<"Larik asli :"<<endl
<<"nilai pdata = "<<*pdata<<endl
<<"nilai pdada[0] = "<<pdata[0]<<endl
<<endl;
pdata++;
cout<<"Pointer pdata digeser satu ke kanan :"<<endl
<<endl;
pdata++;
cout<<"pdata digeser satu lagi ke kanan :"<<endl
<<endl;
}
54
keluaran:
Larik asli :
nilai pdata = 0
nilai pdada[0] = 0
Pointer pdata digeser satu ke kanan :

nilai pdata = 2
nilai pdada[0] = 2
Pointer pdata digeser satu lagi ke kanan :

nilai pdata = 4
nilai pdada[0] = 4
Perhatikan hasil keluaran program di atas. Pada saat pointer pdata belum digeser, pointer data[0] masih
bernilai 0. Ketika pointer pdata digeser satu ke kanan, nilai data[0] berubah menjadi 2 (nilai data[1] larik
asli). Ketika pointer pdata digeser lagi ke kanan, nilai data[0] berubah menjadi 4 (nilai data[2] larik asli).
3. Struktur
Struktur merupakan suatu tipe data yang merupakan kumpulan dari tipe data lainnya. Struktur terdiri dari
data yang disebut suatu field. Field-field dapat berupa tipe data sederhana maupun tipe data turunan,
macam tipenya juga tidak dibatasi, bahkan di dalam struktur juga boleh terdapat tipe data struktur.
Struktur sangat erat hubungannya dengan pola penyimpanan dalam file, sehingga struktur biasanya
digunakan untuk membuat program yang berhubungan dengan file. File adalah kumpulan dari banyak
struktur, sedangkan struktur adalah kumpulan dari field-field.
Dalam bahasa C++ untuk membuat tipe struktur digunakan perintah struct. Cara menggunakan perintah
struct adalah sebagai berikut.
struct nama_struktur
{
tipe nama_field1;
tipe nama_field2;
tipe nama_field3;
. . .
};
nama_struktur nama_variabel;
atau dituliskan secara lebih singkat
struct nama_struktur
{
tipe nama_field1;
tipe nama_field2;
tipe nama_field3;
. . .
} nama_variabel;
contoh:
struct siswa
{
int nomor;
char nama[20];
55
int nilai;
};
siswa sw;
Untuk mengakses field-field yang menjadi suatu struktur digunakan tanda titik ( . ) yang mengikuti
variabel bertipe struktur. Sebagai contoh digunakan ilustrasi program berikut.
// nama program: cstruktur.cpp

// contoh penggunaan struct
#include<iostream>
main()
{
struct siswa
{
int nomor;
char nama[20];
int nilai;
};
siswa sw;
sw.nomor=100001;
strcpy(sw.nama,”Ilham”);
sw.nilai=95;
cout<<”nomor siswa : “<<sw.nomor<<endl;
cout<<”nama siswa : “<<sw.nama<<endl;
cout<<”nilai siswa : “<<sw.nilai<<endl;
}
keluaran:
nomor siswa : 100001
nama siswa : Ilham
nilai siswa : 95
Dari program tersebut terlihat bagaimana menggunakan struktur, bagaimana memberi nilai dan
bagaimana menampilkan isi suatu struktur. Dalam program tersebut pemberian nilai langsung dengan
perintah penugasan dan menyamakan nilainya dengan suatu nilai tertentu. Untuk menampilkannya dapat
langsung ditampilkan dengan perintah cout secara mudah.
Selain berisi field dengan tipe data yang berbeda, dalam struktur juga dapat berisi field yang bertipe
struktur juga. Misalkan program di atas dimodifikasi sedikit dengan memperluas nilai yang dibagi menjadi
beberapa macam nilai untuk mata pelajaran yang berbeda. Untuk jelasnya perhatikan program di bawah
ini.
// nama program: cst_struktur.cpp

// contoh penggunaan struct dalam struct
#include<iostream>
main()
{
struct nilai
{
char pelajaran[5][20];
int nilai[5];
};
struct siswa
{
int nomor;
char nama[20];
nilai nilai_pelajaran;
56
};
siswa sw;
sw.nomor=100001;
strcpy(sw.nama,”Ilham”);
strcpy(sw.nilai_pelajaran.pelajaran[0],
”matematika”);
sw.nilai_pelajaran.nilai[0]=95;
strcpy(sw.nilai_pelajaran.pelajaran[1],”fisika”);
sw.nilai_pelajaran.nilai[1]=100;
cout<<”nomor siswa : “<<sw.nomor<<endl;
cout<<”nama siswa : “<<sw.nama<<endl;
cout<<”pelajaran : “
<<sw.nilai_pelajaran.pelajaran[0]<<endl;
cout<<”nilai : “
<<sw.nilai_pelajaran.nilai[0]<<endl;
cout<<”pelajaran : “
<<sw.nilai_pelajaran.pelajaran[1]<<endl;
cout<<”nilai : “
<<sw.nilai_pelajaran.nilai[1]<<endl;
}
keluaran:
nomor siswa : 100001
nama siswa : Ilham
pelajaran : matematika
nilai : 95
pelajaran : fisika
nilai : 100
Pada program tersebut terdapat struktur tipe_siswa yang didalamnya terdapat struktur tipe_nilai. Karena
tipe_nilai terdiri dari beberapa nilai untuk pelajaran yang berbeda, dalam tipe nilai terdapat beberapa
macam nilai yang dinyatakan dengan variabel larik. Pada struktur tipe_nilai disediakan lima tempat untuk
pelajaran yang berbeda. Dalam program tersebut struktur nilai sudah digunakan dua tempat yaitu untuk
pelajaran matematika dan pelajaran fisika, masing-masing dengan indeks nol dan satu.
4. Union
Union adalah tipe data yang menggunakan ruang simpanan secara berbagi. Bentuk deklarasi union mirip
dengan deklarasi struktur, hanya saja data yang menjadi anggota suatu union akan menempati ruang
yang sama pada memori.
Cara mendeklarasikan variabel bertipe union adalah sebagai berikut.
union tipe_union
{
tipe nama_anggota1;
tipe nama_anggota2;
. . .
};
tipe_union nama_union;
Untuk mengakses data anggota pada union juga menggunakan operator titik ( . ) seperti pada struktur.
Deklarasi suatu union mirip dengan deklarasi suatu struktur, contohnya:
union long_int
57
{
char t_long;
int t_int;
};
long_int lo_i;
Pada petikan program tersebut, ada suatu union dengan nama tipe_long_int yang didalamnya terdapat
dua data anggota yaitu t_long bertipe long dan t_int bertipe int. Data anggota t_long dan t_int menempati
lokasi memori yang sama. Pengaruhnya adalah, jika t_long diubah nilainya, maka t_int akan ikut berubah
mengikuti t_long, demikian pula sebaliknya.
Untuk jelasnya perhatikan program berikut ini.
// nama program: cunion.cpp

// contoh penggunaan union
#include<iostream>
main()
{
union long_int
{
long t_long;
int t_int;
};
long_int li;
// li.t_long diberi nilai 123

li.t_long = 123;
cout<<"t_long = "<<li.t_long<<endl;
cout<<"t_int = "<<li.t_int<<endl;
// li.t_int diubah menjadi 3654

li.t_int = 3654;
cout<<"t_long = "<<li.t_long<<endl;
cout<<"t_int = "<<li.t_int<<endl;
}
keluaran:
t_long = 123
t_int = 123
t_long = 3654
t_int = 3654
Dalam program tersebut, mula-mula t_long diberi nilai 123. Ketika ditampilkan nilainya, t_long dan t_int
mempunyai nilai yang sama. Pada langkah berikutnya, nilai t_int diubah menjadi 3654, ternyata nilai
t_long dan t_int nilainya berubah mengikuti nilai 3654 tersebut. Hal ini menunjukkan bahwa t_long dan
t_int menempati lokasi yang sama dalam memori.
Selain dengan pemberian nilai, sifat dari union ini dapat ditunjukkan dengan menampilkan alamat lokasi
memori yang digunakan dua variabel t_long dan t_int dengan menambah awalan & pada masing-masing
variabel.
// nama program: calamat_union.cpp

// membuktikan alamat data anggota union
#include<iostream>
main()
{
union long_int
{
58
long t_long;
int t_int;
};
long_int li;
cout<<"alamat t_long = "<<&li.t_long<<endl;
cout<<"alamat t_int = "<<&li.t_int<<endl;
}
keluaran:
alamat t_long = 0x0065fe00
alamat t_int = 0x0065fe00
Dapat dilihat dari hasil eksekusi program tersebut, bahwa alamat dari t_long dan t_int memang sama.
1. Berikut ini ada program tentang larik, berapa yang ditampilkan
include<iostream>
main()
{
int A[5] = {10, 20, 30, 40, 50};
int *B = A;
B++;
cout<<B[0]<<endl;
cout<<B[0]<<endl;
}
2. Matriks dapat disimpan dalam bentuk larik dua dimensi. Buatlah program untuk menghitung
penjumlahan matriks A dan matriks B menjadi matriks C dengan memanfaatkan variabel larik
3. Program st_struktur.cpp hanya dapat menyimpan jumlah data untuk mata pelajaran sebanyak 5,
kembangkan program tersebut agar dapat menyimpan jumlah mata pelajaran lebih banyak lagi
4. Berikut ini ada petikan program tentang struktur
struct nilai
{
char pelajaran[25];
int nilai;
};
nilai n[5];
5. Bagaimana memberi nilai dan menampilkan data pelajaran dan nilai pada struktur nilai di atas?
6. Berilah contoh program lain yang melibatkan variabel bertipe union, yang belum terdapat pada buku
ini.
59
VI. FUNGSI
Dalam pembuatan aplikasi program yang sesungguhnya, lebih mudah memecah persoalan yang besar
menjadi persoalan yang kecil, sedemikian sehingga mudah untuk diselesaikan. Dalam kasus demikian
diperlukan untuk membuat potongan-potongan program independen yang tidak tergantung pada program
lain tetapi dibutuhkan oleh program lain. Potongan program tersebut biasa disebut subprogram atau
subroutine atau dalam bahasa C++ disebut fungsi.
A. Fungsi
Fungsi merupakan potongan program tertentu yang mengolah masalah tertentu untuk menghasilkan
suatu keluaran tertentu. Kadang-kadang suatu fungsi tidak mengeluarkan suatu hasil, fungsi semacam ini
hanya merupakan potongan program saja. Salah satu fungsi yang selalu digunakan adalah main() atau
fungsi utama. Fungsi ini dalam bahasa C++ merupakan program utama dan merupakan awal eksekusi
program.
Dalam bahasa C++ sudah disediakan fungsi-fungsi yang biasa digunakan dalam perhitungan komputer.
Fungsi ini merupakan fungsi bawaan software C++ yang beberapa diantaranya selalu dipakai dalam
contoh-contoh program. Beberapa fungsi yang sudah disediakan oleh bahasa C++ antara lain abs(),
pow(), sin(), sqrt() dan sebagainya. Prototipe fungsi standar yang sudah disediakan dalam bahasa C++
disimpan dalam file-file header yang disimpan dalam direktori include. File header tertentu harus
disertakan jika dalam program digunakan fungsi yang mana prototipenya disimpan didalamnya.
Contohnya untuk fungsi yang disebut di atas diperlukan file header yang namanya math.h yaitu file
header untuk fungsi-fungsi matematika.
Selain fungsi standar yang sudah tersedia, programmer juga diperbolehkan untuk membuat fungsi sesuai
dengan kebutuhan programnya. Deklarasi untuk membuat suatu fungsi adalah sebagai berikut.
nama_tipe nama_fungsi(daftar_parameter)
{
tubuh_fungsi;
}
nama_tipe merupakan tipe-tipe yang didukung oleh bahasa C++ yang dapat berupa char, int, float,
double atau void. Fungsi yang bertipe selain void harus mempunyai nilai balik yang diimplementasikan
dengan perintah return dalam tubuh fungsi. Jika fungsi bertipe void, maka fungsi tersebut dapat dianggap
sebagai penggalan program saja tanpa perlu nilai balik. Tipe dari nilai balik harus sesuai dengan
nama_tipe yang digunakan.
nama_fungsi merupakan identitas dari fungsi tersebut yang mana aturan pemberian nama fungsi sesuai
dengan aturan pemberian nama identifier.
daftar_parameter merupakan daftar dari semua parameter yang diperlukan beserta tipenya supaya
fungsi dapat dijalankan. Tidak semua fungsi ada parameternya, sangat mungkin suatu fungsi tidak punya
parameter. Jika suatu fungsi tanpa parameter, biasanya pada daftar_parameter ditulis void. Parameter
merupakan alat komunikasi antara fungsi dengan fungsi lain atau program utama. Parameter dapat
dianggap masukan yang diberikan pada fungsi, sedangkan keluarannya berupa nilai balik.
tubuh_fungsi merupakan isi dari fungsi. Dalam tubuh fungsi diolah masukan daftar_parameter,
sedemikian sehingga diperoleh suatu nilai balik.
Berikut ini diberikan beberapa contoh penulisan fungsi.
char besar(char karakter)

{
return(toupper(karakter));
}
int faktorial(int n)
60
{
int fak = 1;
for(int k=1; k<=n; k++)
fak *= k;
return fak;
}
int password(void)
{
randomize();
return(rand());
}
void cetak(char *nama, int nomor)

{
cout<<”Nama : “<<nama<<endl;
cout<<”Nomor : “<<namor<<endl;
}
Fungsi besar() memerlukan satu parameter bertipe char dan menghasilkan karakter kapitalnya. Fungsi
faktorial() memerlukan satu parameter bertipe int dan menghasilkan suatu nilai faktorial dari
parameternya. Fungsi password() tidak memerlukan parameter, fungsi ini jika dijalankan akan
menghasilkan password enam digit secara acak. Fungsi cetak() memerlukan dua parameter yaitu: nama
bertipe larik karakter dan nomor bertipe int. Fungsi ini tidak menghasilkan nilai balik tertentu, sehingga
diberi tipe void.
Berikut ini contoh penggunaan fungsi dalam program lengkap. Gaya penulisan program yang dipakai
pada program berikut merupakan gaya penulisan program yang dipakai dalam bahasa C++.
// nama program: cfungsi.cpp

// memberi contoh penulisan fungsi
#include<iostream> // compiler directive
int faktorial(int n); // prototipe fungsi
double pangkat3(double data); // prototipe fungsi
main()
{
cout<<”nilai 5! = “<<faktorial(5)<<endl;
cout<<”nilai 7.5 pangkat 3 = “<<pangkat3(7.5)
<<endl;
}
int faktorial(int n) // definisi fungsi faktorial

{
int fak = 1;
fak *= k;
return fak;
}
double pangkat3(double data) //def. fungsi pangkat3

{
return (data*data*data);
}
keluaran:
nilai 5! = 120
nilai 7.5 pangkat 3 = 421.875
61
Dalam program di atas terdapat dua buah fungsi yaitu faktorial() dan pangkat3() masing-masing dengan
kegunaannya masing-masing. Fungsi faktorial() didalamnya berisi algoritma untuk menghitung nilai
faktorial suatu bilangan int. Di sini digunakan teknik perkalian berulang dengan perintah for. Hasilnya
disimpan sementara dalam variabel lokal fak. Kemudian hasil perhitungan ini dikembalikan dalam bentuk
nilai balik return fak. Fungsi kedua adalah pangkat3() yang digunakan untuk mencari nilai pangkat tiga
dari suatu bilangan. Algoritma fungsi ini sangat sederhana karena hanya mengalikan sebanyak tiga kali
data bersangkutan. Hasilnya dikembalikan menggunakan return.
Kebiasaan merancang program dalam bahasa C++ dimulai dari fungsi utama kemudian dilanjutkan
dengan merancang semua fungsi yang diperlukan. Karena program utama biasanya memanggil fungsi
yang dibuat, maka kompiler C++ harus diberitahu bagaimana prototipe fungsi yang bersangkutan.
Pada saat suatu fungsi dipanggil, kompiler C++ harus memasukkan instruksi yang tepat untuk menyusun
dan melewatkan nilai parameter dalam kode fungsi dan memperoleh hasil yang dikembalikan oleh fungsi.
Oleh karena itu kompiler C++ harus mengetahui semua parameter beserta tipenya yang diperlukan
fungsi serta semua nilai balik yang dihasilkan oleh fungsi. Dalam hal ini sebelum diproses, fungsi harus
sudah didefinisikan terlebih dahulu.
Ada dua kerugian jika fungsi didefinisikan terlebih dahulu yaitu:
 Fungsi utama cenderung untuk menyampaikan lebih banyak informasi untuk memahami program
dibandingkan untuk memahami fungsi. Sehingga lebih baik fungsi utama dikerjakan lebih dahulu.
Tetapi ini artinya kompiler menjumpai pemanggilan fungsi sebelum definisi fungsi.
 Jika digunakan fungsi dari pustaka (library) fungsi, maka fungsi utama di-link menggunakan kode
fungsi pre-compiled. Dengan demikian pada saat kompilasi fungsi utama, kompilernya sendiri tidak
mengetahui definisi fungsinya.
Penyelesaian dua masalah tersebut adalah penggunaan prototipe fungsi. Prototipe fungsi menyediakan
informasi tentang tipe nilai balik fungsi serta semua tipe parameter yang diperlukan. Prototipe fungsi
diletakkan sebelum fungsi utama. Kemudian definisi lengkap fungsi diletakkan setelah fungsi utama atau
diletakkan dalam file yang terpisah yang dikompilasi secara terpisah yang nantinya di-link dengan fungsi
utama. Secara umum prototipe fungsi hanyalah salinan dari heading fungsi.
Untuk mempersingkat penulisan, fungsi-fungsi yang bertipe int, boleh tidak dituliskan tipenya. Kompiler
C++ akan menganggap fungsi yang tidak dituliskan tipenya sebagai fungsi bertipe int. Sebagai contoh
perhatikan program berikut ini.
// nama program: cluas.cpp

// contoh lebih lanjut tentang prototipe fungsi
#include<iostream>
double luas_segiempat(double P, double L);
luas_segitiga(double T, double A);
main()
{
double panjang=17.5, lebar=14.3;
double tinggi=10.5, alas=7.5;
cout<<”Luas segiempat = “
<<luas_segiempat(panjang,lebar)<<endl;
cout<<”Luas segitiga = “
<<luas_segitiga(tinggi,alas)<<endl;
}
int luas_segitiga(double T, double A)
{
return(T*A/2);
}
double luas_segiempat(double P, double L)
{
return(P*L);
}
keluaran:
62
Luas segiempat = 250.25

Luas segitiga = 39
Dalam contoh di atas, fungsi luas_segiempat() ditulis lengkap, sedangkan fungsi luas_segitiga() ditulis
tidak lengkap. Fungsi luas_segitiga() ditulis tanpa tipe, sehingga compiler C++ akan menganggap bertipe
int. Dalam kasus ini, walaupun parameter fungsi luas_segitiga() bertipe double, tetapi hasil nilai balik
fungsi tetap bertipe int.
2. Variabel Lokal dan Variabel Eksternal

Variabel lokal adalah variabel yang didefinisikan dalam suatu fungsi tertentu, sehingga hanya dikenal
dalam fungsi tersebut. Dalam hal ini artinya suatu fungsi tidak akan mengenal variabel lokal dari fungsi
lain. Suatu fungsi hanya akan mengenal variabel yang didefinisikan dalam fungsi bersangkutan.
Variabel eksternal adalah variabel yang bersifat global yang dapat dikenali oleh seluruh fungsi yang
terdapat dalam program tersebut. Seluruh fungsi akan mengenal variabel yang bersifat eksternal ini.
Variabel eksternal dideklarasikan di luar fungsi dan sejajar dengan prototipe fungsi serta pengarah
kompiler.
Sebagai contoh penggunaan variabel lokal dan eksternal perhatikan contoh berikut ini.
// nama program: clokal_eksternal.cpp

// contoh penggunaan variabel lokal dan eksternal
#include<iostream>
int data =100; //variabel eksternal
void fungsi_satu(void);
void fungsi_dua(void);
main()
{
int data = 200; //variabel lokal main
fungsi_satu();
fungsi_dua();
cout<<”Nilai data lokal main = “<<data<<endl;
}
void fungsi_satu(void)
{
int data = 300; //variabel lokal fungsi satu
cout<<”Nilai data lokal satu = “<<data<<endl;
}
void fungsi_dua(void)
{
cout<<”Nilai data eksternal = “<<data<<endl;
}
keluaran:
Nilai data lokal satu = 300
Nilai data eksternal = 100
Nilai data lokal main = 200
Dalam program tersebut terdapat variabel lokal dan variabel eksternal yang namanya sama yaitu data.
Dalam fungsi main() dan fungsi_satu() terdapat variabel lokal dengan nama sama tetapi sebetulnya
lokasi penyimpanannya dalam memori berbeda, sehingga dua variabel itu berbeda dan tidak saling
mengenal. Fungsi_satu() sebetulnya mengenal variabel eksternal data yang nilainya 100, tetapi karena
dalam fungsi tersebut terdapat variabel lokal data yang bernilai 300, maka yang diprioritaskan untuk
diproses dalam fungsi tersebut adalah variabel lokalnya. Jika dalam fungsi terdapat variabel lokal dan
variabel eksternal yang sama, maka yang diprioritaskan untuk diproses adalah variabel lokal. Dalam
fungsi_dua() tidak terdapat variabel lokal, sehingga yang diproses pada fungsi tersebut adalah variabel
63
eksternalnya.
3. Parameter
Parameter adalah sarana komunikasi antar fungsi. Pengertian antar fungsi adalah antara fungsi dengan
fungsi lain termasuk antara fungsi dengan fungsi utama. Dalam pemrograman yang melibatkan fungsi,
diusahakan agar masing-masing fungsi bersifat independen artinya tidak tergantung pada fungsi lain.
Setiap fungsi hanya mengerjakan satu tugas tertentu. Antar fungsi saling berkomunikasi menggunakan
parameter.
Terdapat dua macam bentuk parameter dalam hubungannya dengan penggunaan fungsi dalam program
yaitu:
 parameter formal: parameter yang diberi nilai. Secara kenampakan fisik, parameter formal
merupakan parameter yang terdapat dalam daftar parameter fungsi. Dalam program cluas.cpp
terdapat parameter formal P dan L yang digunakan fungsi luas_segiempat(). Juga terdapat
parameter formal T dan A yang digunakan dalam fungsi luas_segitiga().
 parameter aktual: parameter yang memberi nilai. Parameter ini digunakan dalam pemanggilan fungsi
dan digunakan untuk memberi nilai pada parameter formal. Sebagai contoh dalam program cluas.cpp
terdapat parameter aktual panjang dan lebar yang digunakan untuk memberi nilai parameter formal P
dan L. Juga terdapat parameter aktual tinggi dan alas yang digunakan untuk memberi nilai pada
parameter formal T dan A.
Selain menggunakan parameter aktual, parameter formal juga dapat diberi nilai oleh suatu argumen.
Argumen adalah parameter yang berbentuk konstanta. Untuk jelasnya perhatikan contoh program
berikut.
// nama program: csuhu.cpp

// contoh penggunaan parameter formal dan aktual
#include<iostream>
double reamur(double celsius);
double fahrenheit(double celsius);
main()
{
double suhu_celsius, suhu_reamur;
cout<<"Masukkan suhu dalam celsius = ? ";
cin>>suhu_celsius;
suhu_reamur=reamur(suhu_celsius);
cout<<"Suhu tersebut = "<<suhu_reamur
<<" reamur"<<endl;
cout<<"Suhu 100 C = "<<fahrenheit(100)
<<" Fahrenheit"<<endl;
}
double reamur(double celsius)
{
return(4.0/5.0*celsius);
}
double fahrenheit(double celsius)
{
return((9.0/5.0*celsius)+32);
}
keluaran:
Masukkan suhu dalam celsius = ? 70
Suhu tersebut = 56 reamur
Suhu 100 C = 212 Fahrenheit
Dalam program tersebut diberikan contoh pemberian nilai pada parameter formal celsius fungsi reamur()
64
menggunakan parameter aktual suhu_celsius, sedangkan pada fungsi fahrenheit() digunakan argumen
dengan nilai 100 untuk memberi nilai pada parameter formal celsius.
Dari contoh-contoh di atas dapat dilihat bahwa antara parameter formal dan parameter aktual saling
berhubungan/berkomunikasi dalam menjalankan suatu fungsi. Ada dua tipe hubungan antara parameter
formal dan parameter aktual yaitu:
 Hubungan secara nilai (by value). Dalam hubungan ini nilai parameter aktual hanya sama dengan
nilai parameter formal pada saat pemanggilan fungsi saja. Setelah pemanggilan fungsi, kemudian
dilakukan proses pada parameter formal. Perubahan nilai parameter formal selama proses yang
terjadi dalam fungsi tidak akan mempengaruhi nilai parameter aktual.
 Hubungan secara acuan (by reference): Dalam hubungan secara acuan, nilai parameter aktual selalu
sama dengan nilai parameter formal, baik pada saat pemanggilan fungsi, pelaksanaan fungsi
maupun saat sudah keluar dari fungsi. Mekanisme ini dapat terjadi karena yang diberikan parameter
aktual kepada parameter formal adalah alamat, tidak sekadar nilai, sehingga perubahan nilai
parameter formal selalu diikuti oleh parameter aktual. Dalam kasus ini parameter aktual dan
parameter formal akan menempati lokasi memori yang sama, sehingga dapat dikatakan kedua
parameter ini merupakan data yang sama.
Contoh hubungan secara nilai adalah hubungan antara parameter formal celsius dengan parameter
aktual suhu_celsius pada program csuhu.cpp di atas. Memang tidak begitu kelihatan efek yang terjadi
pada hubungan secara nilai ini. Mungkin akan lebih jelas pada contoh program berikut.
// nama program: cnilai.cpp

// memberi contoh hubungan secara nilai
#include<iostream>
void fungsi_nilai(double X);
main()
{
double Y = 200;
cout<<”Nilai Y semula = “<<Y<<endl;
fungsi_nilai(Y);
cout<<”Nilai Y sekarang = “<<Y<<endl;
}
void fungsi_nilai(double X)
{
cout<<”Dalam fungsi_nilai :”<<endl;
cout<<”Nilai X semula = “<<X<<endl;
X += 150;
cout<<”Nilai X diubah menjadi = “<<X<<endl;
}
keluaran:
Nilai Y semula = 200
Dalam fungsi_nilai :
Nilai X semula = 200
Nilai X diubah menjadi = 350
Nilai Y sekarang = 200
Perhatikan dalam program tersebut, semula nilai parameter aktual Y adalah 200. Kemudian nilai
parameter formal X disamakan dengan nilai parameter aktual Y pada saat pemanggilan fungsi, sehingga
pada tampilan semula nilai X bernilai 200 sama dengan Y. Setelah itu nilai parameter formal X dinaikkan
sebesar 150, sehingga pada tampilan berikutnya nilai X berubah menjadi 350. Setelah keluar dari fungsi,
nilai parameter aktual Y ditampilkan ulang. Ternyata nilai Y tetap sebesar 200, yang berarti nilai tidak
terpengaruh oleh perubahan nilai parameter formal X.
Contoh penggunaan hubungan secara acuan dapat dilihat pada program berikut ini. Perhatikan
perbedaan sintaksis hubungan secara acuan dan hubungan secara nilai.
65
// nama program: cacuancpp

// memberi contoh hubungan secara acuan
#include<iostream>
void fungsi_acuan(double &X);
main()
{
double Y = 200;
cout<<”Nilai Y semula = “<<Y<<endl;
fungsi_acuan(Y);
cout<<”Nilai Y sekarang = “<<Y<<endl;
}
void fungsi_acuan(double &X)
{
cout<<”Dalam fungsi_nilai :”<<endl;
cout<<”Nilai X semula = “<<X<<endl;
X += 150;
cout<<”Nilai X diubah menjadi = “<<X<<endl;
}
keluaran:
Nilai Y semula = 200
Dalam fungsi_nilai :
Nilai X semula = 200
Nilai X diubah menjadi = 350
Nilai Y sekarang = 350
Perbedaan penggunaan hubungan secara acuan adalah terletak pada tanda & yang terletak di depan
parameter X pada fungsi_acuan(). Tanda & menunjukkan bahwa pelewatan parameter dilakukan secara
alamat.
Dapat dilihat dari hasil tampilan program, semula nilai parameter aktual Y adalah 200. Pada saat
pemanggilan fungsi, parameter formal X disamakan nilainya dengan parameter aktual Y. Pada saat
pengerjaan fungsi, nilai X dinaikkan sebesar 150 menjadi 350, kemudian ditampilkan hasilnya.
Selanjutnya setelah keluar dari fungsi, nilai parameter aktual Y ditampilkan ulang, ternyata hasilnya
berubah menjadi 350. Hal ini menunjukkan bahwa perubahan nilai parameter formal X akan
mempengaruhi nilai parameter aktual Y.
Contoh berikutnya adalah penggunaan hubungan secara acuan yang digunakan dalam metode
pengurutan data (sorting). Dalam pengurutan data, biasanya yang menjadi objek pemrosesan berupa
larik. Larik tersebut dilewatkan pada suatu fungsi pengurutan kemudian hasilnya berupa larik yang sama
tetapi sudah urut. Metode yang akan digunakan dalam pengurutan ini disebut metode bubble-sort yang
intinya hanya menukarkan elemen larik yang urutannya terbalik.
// nama program: cbubble.cpp

// contoh penggunaan hubungan secara acuan
#include<iostream>
void bubble(int y[], int n);
void tukar(int &A, int &B);
main()
{
int n, x[100];
cout<<"masukkan jumalah data n = ? ";
cin>>n;
for(int k=0; k<n; k++)
{
cout<<"x["<<k<<"] = ? ";
cin>>x[k];
}
bubble(x,n);
66
cout<<"Hasil pengurutan :"<<endl;

for(int k=0; k<n-1; k++)
{
cout<<"x["<<k<<"] = "<<x[k]<<endl;
}
}
void bubble(int y[], int N)
{
for(int k=0; k<N-1; k++)
{
for(int m=0; m<N-1; m++)
{
if(y[m]>y[m+1]) tukar(y[m],y[m+1]);
}
}
}
void tukar(int &A, int &B)
{
int temp = A;
A = B;
B = temp;
}
keluaran:
masukkan jumlah data n = ? 5
x[0] = ? 4
x[1] = ? 3
x[2] = ? 2
x[3] = ? 1
x[4] = ? 0
Hasil pengurutan :
x[0] = 0
x[1] = 1
x[2] = 2
x[3] = 3
x[4] = 4
Dalam program di atas dicontohkan juga, bagaimana melewatkan suatu larik dalam suatu fungsi. Satu-
satunya jalan melewatkan suatu larik dalam suatu fungsi adalah dengan hubungan secara acuan. Dalam
program tersebut, hubungan antara parameter formal y dan parameter aktual x adalah secara acuan,
sedangkan hubungan parameter aktual n dan parameter formal N merupakan hubungan secara nilai.
4. Rekursi
Rekursi adalah kemampuan suatu fungsi untuk memanggil dirinya sendiri. Dalam contoh-contoh
sebelumnya, fungsi dipanggil dari luar fungsi oleh fungsi lain. Dalam teknik rekursi dimungkinkan suatu
fungsi untuk memanggil dirinya sendiri.
Fungsi rekursi ini biasanya digunakan untuk mengubah teknik perulangan. Secara mudah atau sulit
semua teknik perulangan dapat ditulis ulang menggunakan teknik rekursi ini. Sebagai contoh misalnya
teknik untuk mencari pangkat bilangan yang dilakukan dengan teknik perkalian berulang. Misalkan
diinginkan untuk membuat program pangkat = a N dengan perkalian berulang, maka fungsinya adalah
sebagai berikut.
double pangkat(double a, int n)

{
pangkat = 1;
67
for(int k=0; k<n; k++)

{
pangkat *= a;
}
return(pangkat);
}
Secara algoritma dapat dianalisis sebagai berikut:

n=0 --> pangkat(a,0) = 1;
n=1 --> pangkat(a,1) = a * 1 = a * pangkat(a,0)
n=2 --> pangkat(a,2) = a * a * 1 = a * pangkat(a,1)
n=3 --> pangkat(a,3) = a * a * a * 1 = a * pangkat(a,2)
dst
n=x --> pangkat(a,x) = a * pangkat(a,x-1)
Dengan demikian dapat dibuat rumusan

jika n = 0 --> pangkat(a,0) = 1
jika n > 0 --> pangkat(a,x) = a * pangkat(a,x-1)
sehingga dapat dibuat fungsi menurut aturan tersebut sebagai berikut.

{
if(n==0)
return(1);
else
return(a*pangkat(a,n-1));
}
Contoh yang lain adalah fungsi faktorial() yang pernah dibahas sebelumnya yang berbentuk sebagai
berikut.
{
int fak = 1;
fak *= k;
return fak;
}
Jika fungsi tersebut dianalisis akan menghasilkan sebagai berikut.

n=0 --> faktorial(0) = 1;
n=1 --> faktorial(1) = 1 * 1 = 1 * faktorial(0)
n=2 --> faktorial(2) = 2 * 1 * 1 = 2 * faktorial(1)
n=3 --> faktorial(2) = 3 * 2 * 1 * 1 = 3 * faktorial(2)
dst
n=x --> faktorial(x) = x * faktorial(x-1)
68
Sehingga kalau dibuat suatu fungsi yang bersifat rekursif akan menghasilkan bentuk sebagai berikut.
{
if(n==0)
return(1);
else
return(n*faktorial(n-1);
}
Berikut ini contoh program lengkap yang melibatkan fungsi-fungsi yang bersifat rekursif baik pangkat
maupun faktorial.
// nama program: crekursif.cpp

// contoh tentang penggunaan fungsi rekursif
#include<iostream>
double pangkat(double a, int n);
int faktorial(int n);
main()
{
double a;
int n;
cout<<"Masukkan bilangan dan pangkat a n : ? ";
cin>>a>>n;
cout<<"nilai "<<a<<" pangkat "<<n<<" = "
<<pangkat(a,n)<<endl;
cout<<"nilai "<<n<<"! = "<<faktorial(n)<<endl;
}
{
if(n==0)
return(1);
else
return(a*pangkat(a,n-1));
}
{
if(n==0)
return(1);
else
return(n*faktorial(n-1));
}
keluaran:
Masukkan bilangan dan pangkat a n : ? 4.5 5
nilai 4.5 pangkat 5 = 1845.28
nilai 5! = 120
Pada contoh program tersebut, fungsi pangkat() diberi masukan 4.5 dan 5, artinya 4.5 pangkat 5,
hasilnya adalah 1845.28. Fungsi faktorial() diberi masukan pangkatnya, sehingga dihitung 5! hasilnya
120. Secara algoritma akan lebih sederhana.
69
1. Buatlah fungsi untuk menampilkan bilangan fibonaci

1, 1, 2, 3, 5, 8, 13, 21, . . .
Bilangan fibonaci adalah bilangan yang merupakan hasil penjumlahan dua bilangan sebelumnya
2. Buatlah fungsi yang dibuat tersebut menggunakan fungsi rekursif
3. Fungsi berikut untuk keperluan apa?
int contoh(int n)
{
int temp=1;
for(int k=1; k<n+1; k++)
temp *= k;
return(temp);
}
4. Terangkan maksud fungsi berikut ini
void bebas(int *a, int *b)

{
int temp = *a;
*a = *b;
*b = temp;
}
5. Tulislah void bebas() di atas dengan cara lain
70
VII. KELAS
Kelas (class) merupakan tipe data baru yang digunakan dalam pemrograman berorientasi objek. Tipe ini
hanya dikenal dalam bahasa C++ dan tidak dikenal dalam bahasa C. Kelas digunakan untuk
menggambarkan semua objek yang berbagi tanggungjawab dan struktur internal yang sama. Kelas pada
dasarnya merupakan nama kumpulan suatu grup.
Pemrograman berorientasi objek secara umum membahas tentang tiga hal sebagai berikut.
 enkapsulasi (encapsulation)
 pewarisan (inheritance)
 polimorfisme (polymorphism)
Sebelum dibahas lebih lanjut tentang kelas, akan dibahas terlebih dahulu beberapa hal yang dapat
mempermudah pemahaman tentang kelas.
A. Lebih Lanjut Tentang Struktur

Sebelum membahas tentang kelas, akan dibahas lebih mendalam tentang tipe data struktur yang pernah
dibahas pada bab sebelumnya. Seperti disebutkan pada bahasan sebelumnya, struktur merupakan suatu
tipe data yang merupakan kumpulan dari tipe data lainnya. Struktur terdiri dari data yang disebut sebagai
field. Field-field dapat berupa tipe data sederhana maupun tipe data turunan, macam tipenya juga tidak
dibatasi, bahkan di dalam struktur boleh juga terdapat tipe data struktur.
Contoh penggunaan struktur yang pernah digunakan adalah membentuk struktur siswa untuk mencatat
data siswa.
struct siswa
{
int nomor;
char nama[20];
int nilai;
};
siswa sw;
Dengan menggunakan tipe struktur, data nomor, nama dan nilai dapat diakses dengan cara berikut.
sw.nomor = 10001;
strcpy(sw.nama, “Ilham”);
sw.nilai = 95;
Selain cara di atas, data anggota suatu struktur dapat juga diberi nilai menggunakan suatu fungsi. Fungsi
ini menjadi anggota dari suatu struktur. Dalam hal ini selain mempunyai data anggota, struktur juga dapat
mempunyai fungsi anggota atau metode. Fungsi ini digunakan untuk mengakses data anggota dari
struktur bersangkutan.
Sebagai contoh dalam struktur siswa dapat didefinisikan suatu fungsi yang digunakan untuk memberi
nilai data anggota struktur.
struct siswa
{
int nomor;
char nama[20];
int nilai;
void setsiswa(int nmr, char nm[], int nl);
};
71
siswa sw;
Sekarang untuk memberi nilai data anggota, cukup memanggil fungsi setsiswa() sebagai berikut.
sw.setsiswa(10001, ”Ilham”, 95);
Selain itu, dapat juga dibuat beberapa fungsi yang digunakan untuk menampilkan nilai-nilai data anggota.
Dalam hal ini data anggota tidak diakses langsung, tetapi diakses melalui fungsi khusus yang dibuat oleh
pemrogram. Misalkan struktur siswa dilengkapi menjadi sebagai berikut.
struct siswa
{
int nomor;
char nama[20];
int nilai;
int getnomor();
char *getnama();
int getnilai();
};
siswa sw;
Dalam struktur tersebut sekarang terdapat prototipe fungsi anggota, oleh sebab itu deklarasi struktur
harus diletakkan sebagai variabel global dan diletakkan sejajar dengan prototipe fungsi. Program berikut
memberikan contoh penggunaan struktur yang didalamnya terdapat fungsi anggota.
// nama program: csiswa.cpp

// contoh lebih lanjut tentang struktur
#include<iostream>
struct siswa
{
int nomor;
char nama[20];
int nilai;
int getnomor();
char *getnama();
int getnilai();
};
main()
{
siswa sw;
sw.setsiswa(10001,"Ilham Hanif",95);
cout<<"Data Siswa :"<<endl
<<"nomor = "<<sw.getnomor()<<endl
<<"nama = "<<sw.getnama()<<endl
<<"nilai = "<<sw.getnilai()<<endl;
}
void siswa::setsiswa(int nmr, char nm[], int nl)
{
nomor=nmr;
strcpy(nama, nm);
nilai=nl;
}
int siswa::getnomor()
{
72
return(nomor);
}
char *siswa::getnama()
{
return(nama);
}
int siswa::getnilai()
{
return(nilai);
}
keluaran:
Data Siswa :
nomor = 10001
nama = Ilham Hanif
nilai = 95
Dalam program tersebut, struktur siswa dideklarasikan sejajar dengan prototipe fungsi karena dalam
struktur tersebut terdapat prototipe beberapa fungsi anggota. Jika struktur siswa diletakkan dalam fungsi
main(), maka akan memunculkan suatu error. Dalam struktur tersebut terdapat empat fungsi anggota
yaitu: setsiswa(), getnomor(), getnama() dan get nilai().
Perhatikan cara mendefinisikan fungsi anggota. Secara umum cara mendefinisikan fungsi anggota suatu
struktur adalah dengan menyebutkan nama struktur diikuti operator skop :: dan diikuti nama fungsi
anggota.
tipe_fungsi nama_struktur::nama_fungsi(parameter)
{
tubuh fungsi;
}
Fungsi anggota setsiswa() digunakan untuk memberi nilai data anggota struktur siswa. Fungsi
getnomor() digunakan untuk mengambil nilai nomor, sehingga didalamnya hanya berisi perintah memberi
nilai balik data anggota nomor. Fungsi ini mirip dengan fungsi getnilai() yang memberi nilai balik data
nilai. Fungsi anggota getnama() digunakan untuk mengambil data anggota nama. Karena data anggota
nama berupa larik char, maka nilai balik fungsi getnama() juga harus berupa larik char. Tipe fungsi ini
juga berupa larik char. Perhatikan cara mendeklarasikan fungsi yang bertipe larik.
Struktur siswa merupakan tipe data yang mengumpulkan beberapa data dan fungsi yang mempunyai
topik pembicaraan yang sama, yaitu tentang siswa. Prinsip ini merupakan dasar proses pengkapsulan
(encapsulation) dalam pemrograman berorientasi objek.
Untuk lebih memperjelas, pemahaman tentang struktur ini, diberikan contoh lain. Misalkan diinginkan
membentuk struktur segitiga yang berisi data anggota dan fungsi anggota yang berhubungan dengan
suatu segitiga. Pada segitiga terdapat data tentang panjang alas dan tinggi segitiga tersebut. Dari data
panjang alas dan tinggi, dapat dimunculkan nilai luas segitiga tersebut. Tentu saja nilai luas harus
dihitung dengan rumusan tertentu. Dengan analisis sederhana ini, dapat disusun rancangan struktur
tentang segitiga sebagai berikut.
struct segitiga
{
double alas;
double tinggi;
void setsegitiga(double al, double tg);
double luas();
double getalas();
double gettinggi();
};
73
Dalam struktur segitiga terdapat data anggota alas dan tinggi yang bertipe double. Selain itu juga
terdapat fungsi anggota setsegitiga() untuk memberi nilai data alas dan tinggi, fungsi anggota getalas()
untuk mengambil nilai alas dan fungsi anggota gettinggi() untuk mengambil nilai tinggi. Secara lengkap
struktur segitiga diimplementasikan dalam program menjadi sebagai berikut.
// nama program: csegitiga.cpp

// contoh tentang struktur
#include<iostream>
struct segitiga
{
double alas;
double tinggi;
void setsegitiga(double al, double tg);
double luas();
double getalas();
double gettinggi();
};
main()
{
segitiga sgtg;
sgtg.setsegitiga(25.25, 12.72);
cout<<"Data Segitiga :"<<endl
<<"alas = "<<sgtg.getalas()<<endl
<<"tinggi = "<<sgtg.gettinggi()<<endl
<<"luas = "<<sgtg.luas()<<endl;
}
void segitiga::setsegitiga(double al, double tg)
{
alas=al;
tinggi=tg;
}
double segitiga::luas()
{
return(alas*tinggi/2);
}
double segitiga::getalas()
{
return(alas);
}
double segitiga::gettinggi()
{
return(tinggi);
}
keluaran:
Data Segitiga :
alas = 25.25
tinggi = 12.72
luas = 160.59
Fungsi anggota setsegitiga() digunakan untuk memberi ukuran segitiga, sehingga tubuh fungsi tersebut
berisi perintah untuk memberi nilai data anggota alas dan tinggi. Fungsi anggota luas() digunakan untuk
menghitung berapa nilai luas yang mempunyai ukuran alas dan tinggi tersebut, sedangkan fungsi
anggota getalas() dan gettinggi() masing-masing digunakan untuk mengambil nilai data anggota alas dan
tinggi. Semua data anggota dan fungsi anggota struktur segitiga membicarakan tentang topik yang sama
yaitu segitiga.
Program-program yang sudah dituliskan di atas merupakan contoh program yang menggunakan cara
berpikir berorientasi benda atau objek. Program tersebut sudah membicarakan tentang benda. Misalnya
74
program tentang siswa, bukan lagi program menghitung nilai siswa. Program tentang segitiga, bukan lagi
program menghitung luas segitiga. Program tersebut sudah berorientasi objek tetapi masih
menggunakan teknik pemrograman terstruktur. Program yang berorientasi objek cakupannya lebih luas.
Jika dibuat program tentang segitiga, maka pemrogram harus berpikir juga tentang luas segitiga, tentang
keliling segitiga, tentang sudut segitiga, tentang warna segitiga dan lain-lain.
2. Kelas
Selain tipe-tipe yang sudah dipelajari sebelumnya, bahasa C++ mempunyai tipe data kelas. Tipe data ini
merupakan dasar pembentukan kelas untuk pemrograman yang berorientasi objek. Kelas (class) adalah
kumpulan dari data dan fungsi yang dikemas dalam suatu tipe tertentu dalam hal ini class. Data yang
menjadi anggota suatu kelas disebut dengan data anggota, sedangkan fungsi yang menjadi anggota
suatu kelas disebut fungsi anggota atau metode. Untuk selanjutnya akan digunakan istilah metode untuk
fungsi. Cara mendeklarasikan suatu kelas secara umum adalah sebagai berikut.
class nama_kelas
{
tipe data_anggota1;
tipe data_anggota2;
. . .
tipe nama_metode1();
tipe nama_metode2();
. . .
};
Tipe struktur secara mudah dapat diubah menjadi suatu kelas dengan mengganti kata struct menjadi
class dan memberi sifat public pada seluruh anggotanya. Contoh penggunaan untuk kelas siswa adalah
sebagai berikut.
class siswa
{
public:
int nomor;
char nama[20];
int nilai;
int getnomor();
char *getnama();
int getnilai();
};
Contoh yang lain adalah mengubah struktur segitiga menjadi kelas segitiga.
class segitiga
{
public:
double alas;
double tinggi;
void sesegitiga(double al, double tg);
double luas();
double getalas();
double gettinggi();
};
Pada dua contoh kelas tersebut terdapat kata public. Kata public menandakan bahwa data anggota dan
75
metode yang dideklarasikan dibawahnya mempunyai kelas akses public. Akses public artinya dapat
diakses dari luar kelas. Suatu kelas yang seluruh anggotanya mempunyai akses public, maka kelas
tersebut sebetulnya sama dengan struktur.
Contoh-contoh di atas merupakan prinsip dasar pertama pembentukan kelas yang disebut pengkapsulan
(encapsulation). Pengkapsulan adalah pengemasan data dan fungsi dalam suatu tipe data class. Dalam
pembentukan kelas, biasanya data anggota dibuat sedemikian sehingga tidak dapat diakses dari luar
kelas. Supaya tidak dapat diakses dari luar kelas, data anggota diberi kelas akses private. Prinsip ini
merupakan prinsip kedua pembentukan kelas yang disebut penyembunyian informasi (information
hiding). Prinsip penyembunyian informasi adalah membuat satu atau beberapa data anggota atau
metode menjadi tidak dapat diakses dari luar kelas.
Dalam contoh kelas siswa dan segitiga, jika diinginkan data anggota tidak boleh diakses dari luar kelas,
sedangkan metode dapat diakses dari luar kelas, maka data anggota diberi akses private sedangkan
metode diberi akses public, sehingga untuk dua contoh di atas menjadi sebagai berikut.
class siswa
{
private:
int nomor;
char nama[20];
int nilai;
public:
int getnomor();
char *getnama();
int getnilai();
};
class segitiga
{
private:
double alas;
double tinggi;
public:
double luas();
double getalas();
double gettinggi();
};
Kata private boleh tidak dituliskan, artinya secara default jika tidak ada penanda kelas akses, maka data
anggota atau metode tersebut mempunyai akses private. Sehingga dua kelas di atas ditulis dengan cara
sebagai berikut.
class siswa
{
int nomor;
char nama[20];
int nilai;
public:
int getnomor();
char *getnama();
int getnilai();
};
76
class segitiga
{
double alas;
double tinggi;
public:
double luas();
double getalas();
double gettinggi();
};
Data anggota semua diberi akses private yang artinya tidak dapat diakses dari luar kelas. Jika diinginkan
data private akan ditampilkan, maka pemrogram harus menyediakan metode untuk menampilkan data
anggota private. Dalam kelas siswa terdapat tiga metode yang dapat digunakan untuk menampilkan data
anggota private yaitu: getnomor(), getnama() dan getnilai(). Pada kelas segitiga terdapat dua metode
yang dapat digunakan untuk menampilkan data private yaitu: getalas() dan gettinggi().
Sekarang, bagaimana mengimplementasikan kelas dalam program lengkap? Berikut ini diberikan contoh
implementasi program lengkap untuk kelas siswa.
// nama program: ckelas_siswa.cpp

// contoh tentang pembentukan kelas
#include<iostream>
class siswa
{
int nomor;
char nama[20];
int nilai;
public:
int getnomor();
char *getnama();
int getnilai();
};
main()
{
siswa sw;
sw.setsiswa(10002,"Ismah Hanifi",95);
}
{
nomor=nmr;
strcpy(nama, nm);
nilai=nl;
}
{
return(nomor);
}
{
return(nama);
77
}
{
return(nilai);
}
keluaran:
Data Siswa :
nomor = 10002
nama = Ismah Hanifi
nilai = 95
Ternyata mudah sekali mengubah program yang menggunakan struktur menjadi kelas. Program di atas
adalah program yang cara berpikirnya berorientasi objek dan menggunakan teknik pemrograman
berorientasi objek. Cermati betul-betul perintah-perintah yang digunakan, cara mendeklarasikan suatu
kelas dan cara mendefinisikan suatu metode.
Pendefinisian metode dapat juga dilakukan langsung dalam kelas atau menyatu dengan kelas. Jika
diinginkan pendefinisian fungsi langsung dalam kelas, maka program di atas menjadi bentuk sebagai
berikut.
// nama program: ckelas_siswa2.cpp

// contoh tentang pembentukan kelas
#include<iostream>
class siswa
{
int nomor;
char nama[20];
int nilai;
public:
{
nomor=nmr;
strcpy(nama, nm);
nilai=nl;
}
{
return(nomor);
}
{
return(nama);
}
{
return(nilai);
}
};
main()
{
siswa sw;
siswa.setsiswa(10002,"Ismah Hanifi",95);
}
78
Keluaran yang dihasilkan program di atas sama dengan program sebelumnya.

Dalam program tersebut terdapat objek yang bernama siswa. Apa yang dimaksud dengan objek? Objek
adalah instan individu suatu kelas atau secara singkat dikatakan instan kelas. Dengan demikian untuk
suatu kelas tertentu dapat diciptakan objek yang bermacam-macam. Dalam contoh program tersebut dari
kelas siswa dibuat objek siswa, dapat juga dibuat objek murid, objek mahasiswa dan sebagainya.
Sehingga objek sebetulnya adalah gambaran fisik suatu kelas, sebaliknya kelas adalah suatu konsep
abstrak.
Contoh lain adalah program tentang segitiga yaitu csegitiga.cpp. Program tentang segitiga tersebut juga
dapat diubah menjadi program yang menggunakan kelas. Hasilnya adalah sebagai berikut.
// nama program: ckelas_segitiga.cpp

// contoh tentang kelas segitiga
#include<iostream>
class segitiga
{
double alas;
double tinggi;
public:
double luas();
double getalas();
double gettinggi();
};
main()
{
segitiga sgtg;
sgtg.sesegitiga(32.71, 5.84);
cout<<"Data Sgtg :"<<endl
<<"alas = "<<sgtg.getalas()<<endl
<<"tinggi = "<<sgtg.gettinggi()<<endl
<<"luas = "<<sgtg.luas()<<endl;
}
void segitiga::sesegitiga(double al, double tg)
{
alas=al;
tinggi=tg;
}
{
}
{
return(alas);
}
{
return(tinggi);
}
keluaran:
Data Segitiga :
alas = 32.71
tinggi = 5.84
luas = 95.5132
79
Dalam program tersebut data anggota kelas segitiga diberi akses private semua, sedangkan semua
metodenya diberi akses public. Hal demikian dimaksudkan agar pengguna kelas tidak perlu tahu tentang
nama data anggota dari kelas segitiga. Untuk mengakses data anggota disediakan metode-metode.
Untuk memperoleh data tinggi digunakan metode gettinggi(), untuk memperoleh data alas digunakan
metode getalas(), untuk memperoleh data luas digunakan metode luas(), dan untuk memberi nilai data
anggota digunakan metode setsegitiga().
Di atas sudah dicontohkan beberapa penggunaan kelas dalam pemrograman. Untuk mengakses data
anggota atau metode yang berakses public dengan cara menyebutkan objek diikuti operator titik
kemudian menyebutkan data anggota atau metodenya. Objek yang diciptakan semuanya berbentuk
objek statis. Dalam pemrograman dimungkinkan untuk menciptakan objek dinamis yang mana objek
yang diciptakan berbentuk objek dinamis yaitu pointer.
Sudah merupakan ketentuan umum jika suatu variabel dideklarasikan secara dinamis, maka sebelum
digunakan variabel tersebut harus diciptakan. Demikian juga dengan objek dinamis, penciptaan objek
dinamis meliputi dua tahapan yaitu pendeklarasian objek dan penciptaan objek.
nama_kelas *objek; // mendeklarasikan objek dinamis

objek = new nama_kelas; // menciptakan objek dinamis
Jika suatu objek diciptakan dalam bentuk pointer, maka untuk mengakses data anggota ataupun metode
yang berakses public digunakan operator -> (tanda minus diikuti tanda lebih besar).
objek->data_public;
objek->metode_public;
Supaya lebih jelas penggunaan ketentuan di atas, berikut ini diberikan contoh program yang mana objek
dideklarasikan secara dinamis.
// nama program: ckelas_suhu.cpp

// contoh penggunaan objek secara dinamis
#include<iostream>
class suhu
{
double suhu_celsius;
public:
void setsuhu(double T);
double celsius();
double reamur();
double fahrenheit();
};
main()
{
suhu *sh; //deklarasi objek suhu
sh = new suhu; //menciptakan objek suhu
sh->setsuhu(100.0);
cout<<"Data suhu :"<<endl
<<"Dalam Celsius = "<<sh->celsius()<<endl
<<"Dalam Reamur = "<<sh->reamur()<<endl
<<"Dalam Fahrenheit = "<<sh->fahrenheit()
<<endl;
delete sh; //melenyapkan objek suhu
}
void suhu::setsuhu(double T)
{
80
suhu_celsius = T;
}
double suhu::celsius()
{
return(suhu_celsius);
}
double suhu::reamur()
{
return(4.0/5.0*suhu_celsius);
}
double suhu::fahrenheit()
{
return(9.0/5.0*suhu_celsius+32);
}
keluaran:
Data suhu :
Dalam Celsius = 100
Dalam Reamur = 80
Dalam Fahrenheit = 212
Program di atas merupakan program untuk mengkonversi suhu dalam satuan Celsius menjadi suhu
dalam satuan Reamur dan Fahrenheit. Pada fungsi main objek suhu dideklarasikan sebagai variabel
objek dinamis dengan perintah berikut
suhu *sh;
Karena objek suhu dideklarasikan secara dinamis, objek harus diciptakan. Penciptaan objek dilakukan
dengan perintah berikut
sh = new suhu;
Pemanggilan metode tidak berbeda dengan objek statis, hanya mengganti operator titik menjadi operator
-> dengan hasil yang sama. Setelah objek dioperasikan, langkah terakhir objek harus dilenyapkan
dengan perintah berikut
delete sh;
Hasil yang ditampilkan tidak berbeda meskipun tidak digunakan variabel dinamis. Perbedaan antara
variabel dinamis dan statis adalah lokasi penyimpanan dalam memori. Variabel statis disimpan dalam
lokasi memori yang disebut stack. Ukuran stack terbatas sebesar 1 MB. Walaupun demikian ukuran
tersebut sudah cukup besar.
Variabel dinamis disimpan dalam lokasi memori yang disebut heap. Heap adalah lokasi memori di atas 1
MB dan ukurannya tergantung dari memori yang tersedia. Dengan demikian heap dapat mempunyai
ukuran yang jauh lebih besar.
3. Konstruktor dan Destruktor

Metode setsiswa() pada kelas siswa dan metode setsegitiga() pada kelas segitiga digunakan untuk
memberi nilai pada data anggota kelas masing-masing. Metode ini juga berfungsi untuk memberi nilai
awal atau inisialisasi pada data anggota.
Dalam pemrograman berorientasi objek, untuk pemberian nilai awal pada suatu kelas digunakan
konstruktor (constructor). Konstruktor merupakan metode khusus pada suatu kelas. Mengapa
81
konstruktor disebut metode khusus, ada beberapa alasan yaitu: konstruktor adalah metode yang
namanya sama dengan nama kelasnya, konstruktor secara automatis akan dijalankan pada saat objek
kelas diciptakan dan konstruktor bukan bertipe void tetapi tidak mempunyai nilai balik.
Dengan sifat konstruktor tersebut, konstruktor biasanya digunakan untuk memberi nilai awal suatu kelas.
Perlu diperhatikan, bahwa dalam suatu kelas tidak diperbolehkan untuk memberi nilai awal pada data
anggota langsung pada data anggotanya. Contoh berikut adalah salah.
class salah
{
int data_anggota = 100; // baris ini tidak diperbolehkan
. . .
dst.
}
Dalam kelas di atas dilakukan pemberian nilai awal pada data_anggota. Pernyataan ini tidak
diperbolehkan dalam deklarasi suatu kelas. Untuk memberi nilai awal suatu data anggota digunakan
konstruktor. Untuk maksud yang sama, yaitu memberi nilai awal pada data anggota digunakan deklarasi
kelas sebagai berikut.
class betul
{
int data_anggota;
public:
betul();
}
betul::betul() // konstruktor
{
data_anggota = 100;
}
Ada beberapa macam konstruktor yang dapat digunakan. Secara umum konstruktor mempunyai tiga
bentuk yaitu:
1. konstruktor default (default constructor) : konstruktor yang memberi nilai awal data anggota dengan
nilai konstan tertentu. Konstruktor ini tidak menggunakan parameter dalam deklarasi fungsinya. Data
anggota tidak diberi nilai awal melalui suatu parameter.
class contoh
{
. . .
public:
contoh(); // ini konstruktor default
. . .
}
2. konstruktor penyalinan (copy constructor) : konstruktor yang memberi nilai awal data anggota
menggunakan parameter. Oleh karena itu konstruktor ini mempunyai parameter pada deklarasi
fungsinya. Parameter yang digunakan dalam konstruktor penyalinan berupa tipe-tipe selain tipe
kelas.
class contoh
{
. . .
public:
// ini konstruktor penyalinan
contoh(double par1, int par2);
82
. . .
}
3. konstruktor penyalinan objek (object copy constructor) : konstruktor yang memberi nilai awal data
anggotanya berdasarkan nilai data anggota objek lain. Parameter dalam konstruktor ini berupa objek
dari kelas yang sama. Data anggota diberi nilai awal berdasarkan objek yang menjadi parameter
fungsinya.
class contoh
{
. . .
public:
// ini konstruktor penyalinan objek
contoh(contoh &ct);
. . .
}
Kebalikan dari konstruktor adalah destruktor (destructor). Destruktor secara automatis akan dijalankan
pada saat objek kelas dilenyapkan. Destruktor adalah metode yang namanya sama dengan nama kelas
tetapi ditambah tanda tilde ~ di depan nama fungsi.
class contoh
{
. . .
public:
contoh();
// ini destruktor
~contoh();
. . .
}
Karena destruktor dijalankan pada saat kelas dilenyapkan, biasanya destruktor digunakan untuk
menjalankan perintah-perintah untuk membersihkan memori. Untuk program yang banyak menciptakan
variabel dinamis, biasanya destruktor digunakan untuk melenyapkan variabel dinamis ini dari memori
komputer.
Untuk memberi gambaran tentang bagaimana konstruktor dan destruktor dijalankan, perhatikan contoh
program berikut ini yang merupakan modifikasi program tentang segitiga.
// nama program: ckonstruktor.cpp

// contoh tentang konstruktor pada kelas segitiga
#include<iostream>
class segitiga
{
double alas;
double tinggi;
public:
segitiga(); //default constructor
segitiga(double al, double tg); //copy constructor
segitiga(segitiga &sgtg); //object copy constructor
double luas();
double getalas();
double gettinggi();
~segitiga();
};
main()
83
{
segitiga sgtg1;
cout<<"Data Segitiga pertama:"<<endl
<<"alas = "<<sgtg1.getalas()<<endl
<<"tinggi = "<<sgtg1.gettinggi()<<endl
<<"luas = "<<sgtg1.luas()<<endl<<endl;
segitiga sgtg2(23.17, 8.45);

cout<<"Data Segitiga kedua:"<<endl
segitiga sgtg3(sgtg2);
cout<<"Data Segitiga ketiga:"<<endl
}
segitiga::segitiga()
{
alas=0.00;
tinggi=0.00;
}
segitiga::segitiga(double al, double tg)
{
alas=al;
tinggi=tg;
}
segitiga::segitiga(segitiga &sgtg)
{
alas=sgtg.alas;
tinggi=sgtg.tinggi;
}
{
}
{
return(alas);
}
{
return(tinggi);
}
segitiga::~segitiga()
{
cout<<"segitiga dengan tinggi="<<tinggi
<<" dan alas="<<alas<<" dilenyapkan"<<endl;
}
keluaran:
Data Segitiga pertama:
alas = 0
tinggi = 0
luas = 0
Data Segitiga kedua:
84
alas = 23.17
tinggi = 8.45
luas = 97.8932
Data Segitiga ketiga:

alas = 23.17
tinggi = 8.45
luas = 97.8932
segitiga dengan tinggi=8.45 dan alas=23.17 dilenyapkan

segitiga dengan tinggi=8.45 dan alas=23.17 dilenyapkan
segitiga dengan tinggi=0 dan alas=0 dilenyapkan
Pada program tersebut terdapat tiga konstruktor dan satu destruktor. Konstruktor dijalankan pada saat
objek diciptakan. Dari tiga konstruktor, akan dijalankan konstruktor yang sesuai. Pada saat perintah
segitiga sgtg1;
dijalankan, objek sgtg1 diciptakan dan secara automatis konstruktor default akan dijalankan, sehingga
data anggota tinggi dan alas diberi nilai 0.00. Dapat dilihat hasil nilai luas yang ditampilkan bernilai nol.
Setelah semua data ditampilkan, selanjutnya perintah yang dijalankan adalah
Pada saat perintah tersebut dijalankan, akan diciptakan objek sgtg2 dan pada saat tersebut konstruktor
penyalinan secara automatis dijalankan. Dengan demikian data anggota alas akan diberi nilai 23.17 dan
data anggota tinggi akan diberi nilai 8.45. Nilai luas yang ditampilkan adalah 97.8932. Nilai ini sesuai
dengan perhitungan nilai luas segitiga.
Berikutnya akan dijalankan perintah
yang menyebabkan objek sgtg3 diciptakan. Perintah ini akan menjalankan konstruktor penyalinan objek.
Dengan konstruktor ini, data anggota diberi nilai sesuai dengan data anggota objek yang menjadi
parameternya. Dalam kasus ini parameter objek sgtg diberi nilai dengan objek sgtg2, sehingga objek
sgtg3 merupakan hasil salinan dari objek sgtg2. Dengan kata lain objek sgtg3 akan sama dengan objek
sgtg2. Pada saat ditampilkan datanya, terlihat hasilnya sama dengan objek sgtg2.
Pada program di atas juga terdapat destruktor. Destruktor ini akan dijalankan pada saat objek
dilenyapkan. Dalam program tersebut, destruktor akan dijalankan pada saat keluar dari program. Dalam
kaitan ini, mungkin hasil perintah yang dikerjakan destruktor tidak terlihat. Destruktor dalam program di
atas digunakan untuk menampilkan pesan bahwa objek segitiga dengan alas tertentu dan tinggi tertentu
telah dilenyapkan. Di sini ditampilkan juga nilai alas dan tinggi supaya dapat diketahui objek mana yang
baru dilenyapkan.
Dapat dilihat dari hasil tampilan keluaran program, ternyata urutan pelenyapan objek adalah terbalik dari
urutan penciptaan objek. Objek yang diciptakan belakangan, akan dilenyapkan pertama kali. Dapat dilihat
bahwa segitiga dengan alas nol dan tinggi nol dilenyapkan paling akhir, sedangkan segitiga dengan alas
= 23.17 dan tinggi = 8.45 dilenyapkan pertama kali.
Jika suatu konstruktor hanya berisi perintah untuk memberi nilai pada data anggota tanpa ada perintah
lain, maka penulisan konstruktor dapat lebih disederhanakan. Sebagai contoh konstruktor kelas segitiga
di atas dapat ditulis lebih singkat menjadi sebagai berikut.
segitiga():alas(0.00),tinggi(0.00)
{
85
}
segitiga(double al, double tg):alas(al), tinggi(tg)
{
}
segitiga(segitiga &sgtg)
:alas(sgtg.alas), tinggi(sgtg.tinggi)
{
}
Penyederhanaan di atas sebaiknya dituliskan pada deklarasi dalam kelas karena tubuh konstruktor
menjadi tidak ada isinya. Dengan demikian program di atas dapat lebih disederhanakan menjadi bentuk
sebagai berikut.
// nama program: ckonstruktor2.cpp

// contoh tentang konstruktor pada kelas segitiga
#include<iostream>
class segitiga
{
double alas;
double tinggi;
public:
segitiga():alas(0.00),tinggi(0.00)
{
}
segitiga(double al, double tg)
:alas(al), tinggi(tg)
{
}
segitiga(segitiga &sgtg)
:alas(sgtg.alas), tinggi(sgtg.tinggi)
{
}
double luas();
double getalas();
double gettinggi();
~segitiga();
};
main()
{
segitiga sgtg1;
cout<<"Data Segitiga pertama:"<<endl

cout<<"Data Segitiga kedua:"<<endl
cout<<"Data Segitiga ketiga:"<<endl
}
86
{
}
{
return(alas);
}
{
return(tinggi);
}
segitiga::~segitiga()
{
cout<<"segitiga dengan tinggi="<<tinggi
<<" dan alas="<<alas<<" dilenyapkan"<<endl;
}
Keluaran yang dihasilkan program tersebut sama dengan yang dihasilkan oleh program sebelumnya.
4. Data Anggota Kelas

Dalam bahasan sebelumnya sudah disebutkan bahwa anggota suatu kelas dapat berupa data anggota
dan fungsi anggota atau metode. Data anggota suatu kelas dapat berupa tipe-tipe yang sudah
didefinisikan seperti int, char, float atau double. Selain itu dapat juga berupa suatu larik seperti pada
program ckelas_siswa.cpp yang mana data anggota nama berupa larik karakter.
Selain data anggota seperti tersebut di atas, ada dua hal lain yang perlu menjadi perhatian, bahwa data
anggota suatu kelas dapat juga berupa kelas dan dapat juga berupa pointer. Pada bahasan pertama
akan diuraikan tentang data anggota berupa kelas.
Data anggota suatu kelas dimungkinkan berupa kelas lain, dalam hal ini suatu kelas digunakan oleh
kelas lain. Mekanisme ini merupakan penyertaan suatu kelas pada kelas lain. Untuk memberi gambaran
tentang masalah ini, diberikan contoh program tentang titik dan garis berikut ini.
// nama program: ctitik_garis.cpp

// contoh tentang kelas yang menjadi anggota kelas
#include<iostream>
#include<math.h>
class titik
{
double absis;
double ordinat;
public:
titik();
titik(double x, double y);
double getx();
double gety();
};
class garis
{
// data anggota titik1 bertipe kelas titik
titik titik1;
// data anggota titik1 bertipe kelas titik
titik titik2;
public:
87
garis(titik &k1, titik &k2);

titik gettitik1();
titik gettitik2();
double panjang();
};
main()
{
titik ttk1, ttk2(3,4);
garis grs(ttk1, ttk2);
cout<<"Data tentang garis :"<<endl
<<"Titik 1 = ("<<grs.gettitik1().getx()
<<","<<grs.gettitik1().gety()<<")"<<endl
<<"Panjang = "<<grs.panjang()<<endl;
}
titik::titik()
{
absis = 0;
ordinat = 0;
}
titik::titik(double x, double y)
{
absis = x;
ordinat = y;
}
double titik::getx()
{
return(absis);
}
double titik::gety()
{
return(ordinat);
}
garis::garis(titik &k1, titik &k2)
{
titik1 = k1;
titik2 = k2;
}
titik garis::gettitik1()
{
return(titik1);
}
{
return(titik2);
}
double garis::panjang()
{
double px=titik1.getx()-titik2.getx();
double py=titik1.gety()-titik2.gety();
double pj=sqrt(px*px + py*py);
return(pj);
}
keluaran:
Data tentang garis :
Titik 1 = (0,0)
Titik 2 = (3,4)
88
Panjang = 5
Posisi suatu titik ditentukan oleh koordinat (x,y) tertentu, sedangkan posisi suatu garis ditentukan oleh
dua titik. Nilai x disebut absis sedangkan nilai y disebut dengan ordinat. Dalam class titik dideklarasikan
data anggota absis dan ordinat yang keduanya bertipe double dan mempunyai akses private. Data
anggota ini dapat diberi nilai melalui dua konstruktor yaitu konstruktor default yang memberi nilai nol pada
keduanya dan konstruktor penyalinan yang memberi nilai sesuai dengan parameternya. Karena data
anggota absis dan ordinat berakses private, perlu dibuat metode yang dapat mengaksesnya yaitu
metode getx() dan gety(), kedua metode punya akses public.
Dalam kelas garis dideklarasikan dua data anggota berupa objek kelas titik yaitu titik1 dan titik2. data
anggota titik1 dan titik2 merupakan titik-titik yang menentukan posisi garis. Data anggota ini punya akses
private, sehingga harus dibuat metode untuk mengakses data tersebut. Dua metode yang dimaksud
adalah gettitik1() dan gettitik2() yang keduanya mempunyai akses public. Selain itu dalam kelas garis
terdapat pula metode panjang() yang digunakan untuk menghitung nilai panjang objek garis yang
dimaksud.
Pada fungsi main(), pertama kali diciptakan objek titik yang diberi nama ttk1 dan ttk2. Kemudian
diciptakan juga objek garis yang parameternya berupa objek titik yaitu ttk1 dan ttk2. Selanjutnya
ditampilkan data tentang garis yaitu dua titik yang menjadi batas serta panjang garis tersebut.
Pada penghitungan nilai panjang garis diperlukan fungsi sqrt() (square root atau akar kuadrat). Prototipe
fungsi sqrt() disimpan dalam file header math.h, sehingga file ini harus disertakan dalam program ini.
Dalam kasus ini, kelas garis mempunyai data anggota dan metode berupa objek kelas titik. Mekanisme
ini merupakan penyertaan suatu kelas pada kelas lain. Ada mekanisme lain untuk menggunakan suatu
kelas pada kelas lain yang akan dibahas pada bahasan pewarisan.
Selain data anggota berupa kelas, akan dibahas pula data anggota berupa variabel dinamis. Dalam
bahasan sebelumnya pernah dibahas tentang objek kelas yang berupa objek dinamis. Jika objek berupa
variabel dinamis, maka cara mengakses data anggota dan metode digunakan operator -> untuk
menggantikan operator titik. Hal ini juga berlaku jika objek dideklarasikan di dalam kelas. Yang perlu
diperhatikan, jika suatu objek berupa objek dinamis, maka selain dideklarasikan objek tersebut harus
diciptakan. Kemudian pada akhirnya objek harus dilenyapkan. Untuk menciptakan suatu objek, paling
mudah perintah penciptaan objek ditempatkan pada konstruktor, sedangkan untuk melenyapkan objek
perintahnya ditempatkan pada destruktor.
Jika program ctitik_garis.cpp diubah seluruhnya, sedemikian sehingga digunakan objek dinamis, maka
akan dihasilkan program berikut.
// nama program: cpointertitik_garis.cpp

// contoh tentang pointer yang menjadi anggota kelas
#include<iostream>
#include<math.h>
class titik
{
double absis;
double ordinat;
public:
titik();
titik(double x, double y);
double getx();
double gety();
};
class garis
{
// titik1 bertipe kelas titik secara dinamis
titik *titik1;
// titik2 bertipe kelas titik secara dinamis
titik *titik2;
89
public:
garis(titik &k1, titik &k2);
~garis();
titik gettitik1();
titik gettitik2();
double panjang();
};
main()
{
titik ttk1, ttk2(6,8);
garis grs(ttk1, ttk2);
cout<<"Data tentang garis :"<<endl
<<"Panjang = "<<grs.panjang()<<endl;
}
titik::titik()
{
absis = 0;
ordinat = 0;
}
titik::titik(double x, double y)
{
absis = x;
ordinat = y;
}
double titik::getx()
{
return(absis);
}
double titik::gety()
{
return(ordinat);
}
garis::garis(titik &k1, titik &k2)
{
titik1 = new titik; // penciptaan objek titik1
titik2 = new titik; // penciptaan objek titik2
*titik1 = k1;
*titik2 = k2;
}
garis::~garis()
{
delete titik1;
delete titik2;
}
{
return(*titik1);
}
{
return(*titik2);
}
double garis::panjang()
{
double px=titik1->getx()-titik2->getx();
90
double py=titik1->gety()-titik2->gety();
double pj=sqrt(px*px + py*py);
return(pj);
}
keluaran:
Data tentang garis :
Titik 1 = (0,0)
Titik 2 = (6,8)
Panjang = 10
Perhatikan perubahan-perubahan yang terjadi pada program di atas. Pada kelas titik tidak terdapat
perubahan sama sekali. Pada kelas garis terdapat perubahan pada deklarasi data anggota, definisi
konstruktor, definisi metode panjang() dan penambahan destruktor. Data anggota titik1 dan titik2
dideklarasikan sebagai variabel dinamis, akibatnya pada konstruktor ada perintah untuk menciptakan
kedua data anggota. Karena parameter konstruktor k1 dan k2 bukan variabel alamat, sehingga untuk k1
disamakan dengan nilai yang ditunjuk titik1 yaitu *titik1, sedangkan k2 disamakan dengan nilai yang
ditunjuk titik2 yaitu *titik2.
Selanjutnya pada metode panjang(), cara mengakses metode getx() dan gety() menggunakan operator
->. Hal ini juga disebabkan karena objek titik1 dan titik2 dideklarasikan sebagai objek dinamis.
Karena objek yang diciptakan berupa objek dinamis, diperlukan adanya destruktor untuk melenyapkan
objek-objek tersebut. Pada destruktor kelas garis terdapat perintah untuk melenyapkan (delete) objek
titik1 dan titik2.
1. Sebutkan objek-objek yang anda ketahui

2. Buatlah rancangan kelas tentang buku, yang mencakup data anggota, konstruktor dan metode.
Implementasikan dalam fungsi main()
3. Ada deklarasi kelas sebagai berikut.
class lingkaran
{
double jari2;
public:
lingkaran();
lingkaran(double r);
double keliling();
double luas();
}
4. Buatlah definisi metode-metode dari kelas lingkaran

5. Terapkan penggunaan kelas lingkaran dalam fungsi main()
91
VIII. FUNGSI LANJUTAN

Dalam bahasan sebelumnya sudah diuraikan panjang lebar tentang fungsi. Fungsi yang dibahas tersebut
adalah bentuk dasar fungsi yang merupakan kemampuan umum bahasa pemrograman. Dalam bahasan
ini akan diuraikan lebih lanjut tentang fungsi dalam hubungannya dengan pemrograman berorientasi
objek. Fungsi yang akan dibahas erat kaitannya dengan kedudukannya sebagai fungsi anggota atau
metode dalam suatu kelas. Ada beberapa kemampuan bahasa C++ dalam kaitannya dengan metode
suatu kelas yaitu fungsi teman (friend function), fungsi overload (overloading function) dan operator
overload (overloading operator). Pada fungsi teman, dimungkinkan untuk mengakses anggota kelas yang
berakses private dari luar kelas. Dalam fungsi overload dimungkinkan untuk membuat fungsi dengan
nama yang sama tetapi parameternya berbeda. Dalam operator overload dimungkinkan untuk membuat
operator yang sama dengan operator dalam bahasa C++ tetapi punya aturan yang berbeda sesuai
keinginan pemrogram.
A. Teman
Ada beberapa kelas akses terhadap anggota suatu kelas yaitu private, protected dan public. Anggota
public dapat diakses dari luar kelas, anggota protected hanya dapat diakses dari kelas turunan dan
anggota private tidak dapat diakses dari luar kelas. Pada dasarnya anggota kelas yang mempunyai
akses private tidak dapat diakses dari luar kelas.
Ada mekanisme dalam pemrograman berorientasi objek yang memungkinkan suatu anggota kelas
berakses private dapat diakses dari luar kelas. Mekanisme yang dimaksud adalah teman (friend).
Dengan mekanisme teman, prinsip penyembunyian data (data hiding) pada pembentukan kelas mejadi
dilanggar. Jika suatu kelas dijadikan teman oleh kelas lain, maka kelas tersebut dapat mengakses
anggota yang mempunyai kelas akses private. Kadang-kadang mekanisme teman ini dibutuhkan dalam
pemrograman berorientasi objek. Ada dua macam cara untuk menjadikan teman suatu kelas lain yaitu:
 Seluruh anggota kelas: yang mana suatu anggota kelas dijadikan teman oleh kelas lain, sehingga
seluruh anggota kelas dapat mengakses anggota private kelas yang menjadikan teman.
 Hanya metode kelas tertentu: yang mana yang dijadikan teman oleh suatu kelas hanya metode
tertentu, sehingga hanya metode tersebut yang dapat mengakses anggota private kelas yang
menjadikan teman.
Untuk menjelaskan tentang mekanisme teman ini, perhatikan skema program berikut ini.
class kelas_A
{ . . .
tipe fungsi_A1();
tipe fungsi_A2();
. . .
};
class kelas_B
{ anggota_B
. . .
public:
friend class kelas_A;
. . .
}
class kelas_C
{ anggota_C
. . .
public:
friend kelas_A::fungsi_A1();
. . .
};
92
Terdapat tiga kelas yaitu kelas_A, kelas_B dan kelas_C. kelas_A mempunyai dua metode yaitu
fungsi_A1() dan fungsi_A1(). kelas_B mempunyai anggota berakses private yang diberi nama
anggota_B, sedangkan kelas_C mempunyai anggota berakses private yaitu anggota_C. Pada dasarnya
kelas_A tidak dapat mengakses anggota_B maupun anggota_C, tetapi dengan mekanisme teman
anggota_B dan anggota_C dapat diakses dari kelas_A.
Dalam kelas_B terdapat pernyataan
friend class kelas_A;
Pernyataan ini mempunyai arti bahwa kelas_A dijadikan teman oleh kelas_B, sehingga seluruh anggota
kelas_A dapat mengakses anggota_B yang berakses private baik dari metode fungsi_A1() maupun dari
metode fungsi_A2(). Bahkan metode-metode yang lain yang menjadi anggota kelas_A.
Dalam kelas_C terdapat pernyataan
friend kelas_A::fungsi_A1();
Dengan pernyataan ini, yang dijadikan teman oleh kelas_C hanya metode fungsi_A1() dari kelas_A,
sehingga hanya metode fungsi_A1() saja yang dapat mengakses anggota_C yang mempunyai akses
private. Metode selain fungsi_A1() tetap tidak dapat mengakses anggota_C.
Program berikut memberi contoh tentang mekanisme teman.
// nama program: ctitik_garis1.cpp

// contoh penggunaan teman suatu kelas
#include<iostream>
#include<math.h>
class garis
{
double panjang_x;
double panjang_y;
public:
double gradien(class titik ttk1, class titik ttk2);
double panjang(class titik ttk1, class titik ttk2);
};
class titik
{
double absis;
double ordinat;
public:
titik(double x,double y);
friend class garis;
};
main()
{
titik t1(0,0);
titik t2(3,4);
garis grs;
cout<<"panjang="<<grs.panjang(t1,t2)<<endl;
cout<<"gradien="<<grs.gradien(t1,t2)<<endl;
}
titik::titik(double x,double y)
{
absis=x;
ordinat=y;
93
}
double garis::gradien(titik ttk1, titik ttk2)
{
panjang_x=ttk1.absis-ttk2.absis;
panjang_y=ttk1.ordinat-ttk2.ordinat;
return(panjang_y/panjang_x);
}
double garis::panjang(titik ttk1, titik ttk2)
{
return(sqrt(panjang_x*panjang_x +
panjang_y*panjang_y));
}
keluaran:
panjang=5
gradien=1.33333
Pada program di atas terdapat dua kelas yaitu kelas titik dan kelas garis. Pada kelas titik terdapat data
anggota absis dan ordinat yang mempunyai akses private. Seharusnya dua data anggota ini tidak dapat
diakses dari luar kelas. Pada kelas garis terdapat dua data anggota berakses private yaitu panjang_x dan
panjang_y serta dua metode yaitu gradien() dan panjang(). Pada kelas titik terdapat pernyataan berikut
friend class garis;
Pernyataan ini menyebabkan seluruh anggota kelas garis dapat mengakses anggota private dari kelas
titik. Sehingga data anggota absis dan ordinat dari kelas titik diakses langsung pada metode gradien()
dan panjang() dari kelas garis.
Program selanjutnya memberi contoh bagaimana mekanisme teman dibatasi untuk metode tertentu saja.
// nama program: ctitik_garis2.cpp

// contoh penggunaan teman fungsi anggota kelas
#include<iostream>
#include<math.h>
class garis
{
double panjang_x;
double panjang_y;
public:
double panjang(class titik ttk1, class titik ttk2);
};
class titik
{
double absis;
double ordinat;
public:
titik(double x,double y);
friend double garis::panjang(titik ttk1, titik ttk2);
};
main()
{
titik t1(0,0);
titik t2(3,4);
garis grs;
cout<<"panjang="<<grs.panjang(t1,t2)<<endl;
94
}
titik::titik(double x,double y)
{
absis=x;
ordinat=y;
}
double garis::panjang(titik ttk1, titik ttk2)
{
return(sqrt(panjang_x*panjang_x +
panjang_y*panjang_y));
}
keluaran:
panjang=5
Program di atas mirip dengan program sebelumnya yaitu tentang titik dan garis. Pada kelas titik terdapat
dua data anggota yaitu absis dan ordinat yang berakses private. Pada kelas garis terdapat dua data
anggota kelas yaitu panjang_x dan panjang_y serta metode panjang(). Pada kelas titik terdapat
pernyataan berikut
friend class garis panjang(titik ttk1, titik ttk2);
Pernyataan ini menyebabkan metode panjang() dari kelas garis dijadikan teman oleh kelas titik, sehingga
metode panjang() dapat mengakses data anggota absis dan ordinat dari kelas titik yang mempunyai
akses private. Jika pada kelas garis terdapat metode-metode lain selain panjang(), maka metode-metode
tersebut tidak dapat mengakses anggota private dari kelas titik.
Deklarasi friend yang dipakai di atas adalah untuk kelas atau untuk anggota suatu kelas, sehingga
anggota private suatu kelas dapat diakses dari luar kelas. Mekanisme teman dapat juga digunakan untuk
menjadikan suatu fungsi global sebagai teman dari suatu kelas yang mana suatu fungsi bebas yang
bukan anggota kelas, dijadikan teman oleh suatu kelas. Dengan mekanisme ini, suatu fungsi global dapat
mengakses anggota private kelas yang menjadikannya sebagai teman. Keuntungan mekanisme ini
adalah bahwa fungsi global dapat dipanggil dari manapun tanpa menyebutkan objeknya. Program berikut
memberikan contoh penggunaan mekanisme teman untuk fungsi global.
// nama program: ckompleks.cpp

// contoh penggunaan teman fungsi global
#include<iostream>
#include<math.h>
class kompleks
{
double re;
double im;
public:
kompleks(double real, double imaginer);
friend void cetak(kompleks k);
friend double real(kompleks k);
friend double imaginer(kompleks k);
};
main()
{
kompleks z(2,3);
cout<<"bilangan kompleks z=";
cetak(z);
cout<<"Bagian real="<<real(z)<<endl
95
<<"Bagian imaginer="<<imaginer(z)<<endl;
}
kompleks::kompleks(double real, double imaginer)
{
re=real;
im=imaginer;
}
void cetak(kompleks k)
{
cout<<k.re<<"+"<<k.im<<"i"<<endl;
}
double real(kompleks k)
{
return(k.re);
}
double imaginer(kompleks k)
{
return(k.im);
}
keluaran:
bilangan kompleks z=2+3i
Bagian real=2
Bagian imaginer=3
Pada program ckompleks.cpp terdapat suatu kelas kompleks yang mendefinisikan suatu bilangan
kompleks. Pada kelas tersebut terdapat dua data anggota yaitu re dan im yang masing-masing
menggambarkan bagian real dan bagian imaginer suatu bilangan kompleks. Kelas kompleks menjadikan
tiga fungsi sebagai teman yaitu fungsi cetak(), real() dan imaginer() dengan pernyataan berikut
friend void cetak(kompleks k);

friend double real(kompleks k);
friend double imaginer(kompleks k);
Ketiga fungsi tersebut merupakan fungsi global yang bukan anggota suatu kelas apapun. Akibatnya
ketiga fungsi tersebut dapat mengakses anggota privat dari kelas kompleks yaitu re dan im.
Bagaimana kejadiannya jika fungsi cetak(), real() dan imaginer() tidak dijadikan teman oleh kelas
kompleks? Atau tiga pernyataan tersebut dihilangkan. Tentu saja ketiga fungsi tidak dapat mengakses
data anggota private kelas kompleks.
Perhatikan dalam fungsi main(), untuk memanggil fungsi cetak(), real() dan imaginer() tidak perlu
menyebutkan objeknya. Ketiga fungsi sebetulnya merupakan fungsi biasa yang oleh kelas kompleks
dijadikan sebagai teman.
2. Fungsi Overload
Fungsi overload adalah kemampuan untuk membentuk suatu fungsi dengan nama yang sama dengan
fungsi lain tetapi parameter yang digunakan berbeda. Fungsi overload sudah diterapkan ketika
mempelajari tentang konstruktor. Konstruktor default, konstruktor penyalinan dan konstruktor penyalinan
objek sebetulnya adalah kasus tentang fungsi overload. Ketiga jenis konstruktor punya nama yang sama
dengan nama kelasnya tetapi berbeda pada parameter yang digunakan.
Kemampuan fungsi overload sebetulnya sudah dimiliki oleh bahasa pendahulu C++ yaitu bahasa C.
Fungsi yang dioverload tidak terbatas pada fungsi yang dibuat pemrogram saja, fungsi-fungsi bawaan
juga dapat dioverload sesuai dengan keinginan pemrogram. Yang perlu diperhatikan adalah bahwa
parameter yang digunakan harus berbeda.
96
Berikut ini diberikan contoh program tentang lingkaran. Program ini selain berbicara tentang lingkaran,
juga memunculkan gagasan baru tentang bagaimana dua lingkaran dijumlahkan atau lingkaran
dijumlahkan dengan bilangan konstan. Misalkan, jika dua lingkaran dijumlahkan, maka luasnya menjadi
jumlahan luas antara dua lingkaran. Jika lingkaran dijumlahkan dengan suatu konstan hasilnya berupa
lingkaran yang luasnya sama dengan luas lingkaran semula ditambah besarnya konstan. Tentu saja jari-
jari lingkaran akan menyesuaikan dengan luas lingkaran yang baru. Implementasi programnya adalah
sebagai berikut.
// nama program: clingkaran.cpp

// contoh fungsi overload
#include<iostream>
#include<math.h>
class lingkaran
{
double jari2;
public:
lingkaran(double r);
double luas();
lingkaran tambah(lingkaran lk1, lingkaran lk2);
lingkaran tambah(lingkaran lk1, double konstan);
double jari_jari();
};
main()
{
lingkaran lk1(10);
lingkaran lk2(20);
lingkaran lk3(0);
lingkaran lk4(0);
cout<<"luas lingkaran pertama = "<<lk1.luas()
<<endl;
cout<<"luas lingkaran kedua = "<<lk2.luas()<<endl;
lk3=lk3.tambah(lk1,lk2);
cout<<"luas lingkaran ketiga = "<<lk3.luas()<<endl;
cout<<"jari-jari lingkaran ketiga = "
<<lk3.jari_jari()<<endl;
lk4=lk4.tambah(lk1,100);
cout<<"luas lingkaran keempat = "
<<lk4.luas()<<endl;
cout<<"jari-jari lingkaran keempat = "
<<lk4.jari_jari()<<endl;
}
lingkaran::lingkaran(double r)
{
jari2=r;
}
double lingkaran::luas()
{
return(3.14*jari2*jari2);
}
lingkaran lingkaran::tambah(lingkaran lk1,
lingkaran lk2)
{
double r=sqrt((lk1.luas()+lk2.luas())/3.14);
return(lingkaran(r));
}
lingkaran lingkaran::tambah(lingkaran lk1,
double konstan)
{
97
double r=sqrt((lk1.luas()+konstan)/3.14);
return(lingkaran(r));
}
double lingkaran::jari_jari()
{
return(jari2);
}
keluaran:
luas lingkaran pertama = 314
luas lingkaran kedua = 1256
luas lingkaran ketiga = 1570
jari-jari lingkaran ketiga = 22.3607
luas lingkaran keempat = 413
jari-jari lingkaran keempat = 11.4825
Pada program tersebut terdapat dua metode tambah() yang namanya sama tetapi parameter serta
definisinya berbeda. Pada program di atas, metode tambah() adalah fungsi yang dioverload. Dua metode
tersebut dipanggil dengan cara yang berbeda dari fungsi main(). Yang pertama adalah dengan cara
memberi dua parameternya berupa objek lingkaran.
lk3=lk3.tambah(lk1,lk2);
Parameter aktual lk1 dan lk2 keduanya berupa objek lingkaran, sehingga metode tambah() yang
dipanggil adalah metode tambah() yang pertama. Sedangkan pada pemanggilan kedua, metode
tambah() dipanggil dengan cara sebagai berikut.
lk4=lk4.tambah(lk1,100);
Parameter yang digunakan berupa satu objek lingkaran dan satu argumen konstan. Fungsi yang
dipanggil menyesuaikan dengan parameter yang digunakan, sehingga metode tambah() yang dipanggil
adalah metode tambah() yang kedua.
Contoh lain tentang fungsi overload adalah diterapkan pada bilangan kompleks. Bilangan kompleks
adalah bilangan yang terdiri dari bagian real dan bagian imaginer. Jika dua bilangan kompleks
dijumlahkan, maka bagian real ditambah bagian real, bagian imaginer ditambah bagian imaginer.
Contohnya sebagai berikut
z1 = 32 + 57i
z2 = 24 + 38i
------------- +
z3 = 56 + 95i
Jika suatu bilangan kompleks ditambah suatu real, maka bagian real ditambah konstan, bagian imaginer
ditambah nol. Contohnya sebagai berikut.
z1 = 24 + 42i
z2 = 15
------------- +
z3 = 39 + 42i
Dengan demikian paling tidak, ada dua aturan penambahan bilangan kompleks. Kasus bilangan
kompleks ini akan diimplementasikan dalam bentuk program yang mana ada metode tambah() yang
dioverload. Contoh programnya adalah sebagai berikut.
98
// nama program: ckompleks1.cpp

// contoh fungsi overload pada bilangan kompleks
#include<iostream>
#include<math.h>
class kompleks
{
double re;
double im;
public:
kompleks tambah(kompleks k1, kompleks k2);
kompleks tambah(kompleks k1, double konstan);
double real();
double imaginer();
};
main()
{
kompleks z1(6,8);
kompleks z2(3,4);
kompleks z3(0,0);
cout<<"hasil fungsi overload :"<<endl;
z3=z3.tambah(z1,z2);
cout<<"z1 = "<<z1.real()<<"+"
<<z1.imaginer()<<"i"<<endl
<<"z2 = "<<z2.real()<<"+"
<<"z3 = z1+z2 = "<<z3.real()<<"+"
<<z3.imaginer()<<"i"<<endl;
z3=z3.tambah(z1,5.0);
cout<<"z1 = "<<z1.real()<<"+"
<<"z3 = z1+5.0 = "<<z3.real()<<"+"
}
{
re=real;
im=imaginer;
}
kompleks kompleks::tambah(kompleks k1, kompleks k2)
{
return(kompleks(k1.re+k2.re, k1.im+k2.im));
}
kompleks kompleks::tambah(kompleks k1, double konstan)
{
return(kompleks(k1.re+konstan, k1.im));
}
double kompleks::real()
{
return(re);
}
double kompleks::imaginer()
{
return(im);
}
keluaran:
z1 = 6 + 8i
99
z2 = 3 + 4i
z3 = z1 + z2 = 9 + 12i
z1 = 6 + 8i
z3 = z1 + 5.0 = 11 + 8i
Pada program ckompleks.cpp di atas, terdapat satu metode yang dioverload yaitu metode tambah().
Metode tambah() dipanggil dua kali dengan parameter yang berbeda. Pemanggilan pertama berbentuk
z3=z3.tambah(z1,z2);
yang mana bilangan kompleks z3 merupakan hasil penjumlahan bilangan kompleks z1 dan bilangan
kompleks z2. Kedua parameter berbentuk objek kompleks. Pemanggilan kedua berbentuk
z3=z3.tambah(z1,5.0);
yang mana bilangan kompleks z3 merupakan penjumlahan dari bilangan kompleks z1 dan suatu konstan.
Parameter pertama berbentuk objek kompleks sedangkan parameter kedua berbentuk konstan.
Untuk menampilkan hasil bilangan kompleks dibuat dua metode yang digunakan untuk menampilkan
bagian real dan bagian imaginer bilangan kompleks. Hal ini perlu dilakukan karena data anggota re dan
im mempunyai akses private.
3. Operator Overload
Bahasa C++ tidak hanya punya kemampuan untuk mengoverload suatu fungsi, operator yang ada dalam
bahasa C++ juga dapat dioverload. Dalam hal ini pemrogram membuat aturan sendiri untuk operator
yang dioverload. Kemampuan operator overload ini menjadikan pemrograman lebih menarik. Walaupun
hampir semua operator dapat dioverload tetapi ada beberapa keterbatasan yang perlu diperhatikan
dalam mengoverload suatu operator sebagai berikut.
 Tidak diperbolehkan mengoverload kombinasi operator yang tidak punya arti dalam bahasa C++.
Misalnya saja mengkombinasikan operator * menjadi ** untuk membuat operasi perpangkatan.
Operator ** tidak punya arti dalam bahasa C++, sehingga tidak dapat dioverload.
 Tidak diperbolehkan mengubah presedens perhitungan operator. Misalnya diinginkan operator +
dioverload. sedemikian sehingga mempunyai presedens yang lebih tinggi dibanding operator *. Hal
ini tidak diperbolehkan karena presedens operator * lebih tinggi dibanding +.
 Tidak diperbolehkan mengubah jumlah operan yang diperlukan operator. Dalam bahasa C++ dikenal
operator uner (unary) yang memerlukan satu operan dan operator biner (binary) yang memerlukan
dua operan. Jika secara bawaan operatornya uner, tidak diperbolehkan untuk mengoverload operator
tersebut menjadi operator biner. Misalnya operator ! (not) yang bersifat uner, tidak boleh dioverload
menjadi operator ! yang bersifat biner.
Dengan kemampuan operator overload, dapat dibuat overload untuk operator + ( plus), sedemikian
sehingga untuk menambahkan dua bilangan kompleks dapat langsung menggunakan perintah
z3 = z1 + z2; tidak dengan z3 = z3.tambah(z1,z2);

z3 = z1 + 5.0; tidak dengan z3 = z3.tambah(z1,5.0);
Supaya program yang dibuat mempunyai kemampuan tersebut, pemrogram harus mengoverload
operator + sesuai aturan yang berlaku pada bilangan kompleks. Berikut ini contoh programnya.

// contoh operator overload pada bilangan kompleks
#include<iostream>
100
#include<math.h>
class kompleks
{
double re;
double im;
public:
kompleks operator+(kompleks k);
kompleks operator+(double konstan);
kompleks operator++();
double real();
double imaginer();
};
main()
{
kompleks z1(6,8);
kompleks z2(3,4);
kompleks z3(0,0);
cout<<"hasil operator overload :"<<endl;
z3 = z1 + z2;
cout<<"z1 = "<<z1.real()<<"+"
<<"z2 = "<<z2.real()<<"+"
<<"z3 = z1+z2 = "<<z3.real()<<"+"
z3 = z1 + 5.0;
cout<<"z1 = "<<z1.real()<<"+"
<<"z3 = z1+5.0 = "<<z3.real()<<"+"
++z3;
cout<<"z3++ = "<<z3.real()<<"+"
}
{
re=real;
im=imaginer;
}
kompleks kompleks::operator+(kompleks k)
{
double re1 = re+k.re;
double im1 = im+k.im;
return(kompleks(re1, im1));
}
kompleks kompleks::operator+(double konstan)
{
double re1 = re+konstan;
double im1 = im;
}
kompleks kompleks::operator++()
{
return(kompleks(re++,im++));
}
double kompleks::real()
{
101
return(re);
}
double kompleks::imaginer()
{
return(im);
}
keluaran:
hasil operator overload :
z1 = 6+8i
z2 = 3+4i
z3 = z1+z2 = 9+12i
z1 = 6+8i
z3 = z1+5.0 = 11+8i
z3++ = 12+9i
Pada program ckompleks2.cpp di atas, operator yang dioverload ada dua macam yaitu operator + yang
bersifat biner dan operator ++ yang bersifat uner. Perhatikan bagaimana cara mengoverload kedua
operator.
Operator + merupakan operator biner yang mana untuk menjalankan operator tersebut menggunakan
dua operan. Prototipe fungsi overload operator + yang pertama, berbentuk sebagai berikut
kompleks operator+(kompleks k);
Maksud dari pernyataan tersebut adalah bahwa operan pertama dari operator + yang dioverload adalah
bilangan kompleks dirinya sendiri, sedangkan operan kedua diwujudkan dalam bentuk parameter dalam
fungsi tersebut, dalam kasus ini adalah k yang bertipe kompleks. Sehingga dalam definisi fungsi dapat
dilihat untuk bagian real bernilai bagian real bilangan kompleks dirinya sendiri ditambah bagian real
bilangan kompleks k. Demikian juga bagian imaginer bernilai bagian imaginer dirinya sendiri ditambah
bagian imaginer bilangan kompleks k yang merupakan parameternya.
Prototipe fungsi overload operator + yang kedua berbentuk sebagai berikut.
Dalam fungsi overload + ini, parameternya berbentuk suatu konstan. Pada definisi fungsi dapat dilihat
untuk bagian real bernilai bagian real bilangan kompleks dirinya sendiri ditambah nilai konstan dari
parameternya. Demikian juga bagian imaginer bernilai bagian imaginer dirinya sendiri ditambah nol
sesuai rumusan bilangan kompleks.
Pada program di atas, untuk menampilkan hasil bilangan kompleks masih diperlukan metode real() dan
imaginer(). Apakah dimungkinkan untuk menampilkan bilangan kompleks langsung dengan perintah
cout? Diinginkan untuk menampilkan bilangan kompleks dengan perintah berikut
cout<<z1<<endl;
Jawabnya dapat. Program harus mengoverload operator insersi << yang digunakan untuk menampilkan
suatu stream. Selain itu dapat juga dibuat agar bilangan kompleks dapat dimasukkan dari papan ketik
dengan perintah cin, sehingga pada papan ketik tinggal diketikkan perintah
52.23+23.12i
seperti memasukkan bilangan bertipe sederhana int, float atau double. Dalam hal ini operator ekstraksi
>> harus dioverload. Jika operator << dan >> dioverload, maka tidak diperlukan lagi fungsi real() dan
imaginer(). Operator << dan >> merupakan operator global, yang mana untuk menggunakan operator
102
tersebut tidak perlu menyebutkan objeknya. Dalam kasus ini harus dibuat overload untuk dua operator
tersebut dan bukan menjadi anggota suatu kelas supaya penggunaannya tanpa menyebutkan objeknya.
Kedua operator harus dapat mengakses data anggota re dan im yang mempunyai akses private pada
kelas kompleks, padahal kedua operator bukan menjadi anggota kelas kompleks. Oleh karena itu, kelas
kompleks harus menyatakan bahwa operator << dan >> menjadi teman dari kelas kompleks. Dalam hal
ini digunakan mekanisme teman dengan operator global.
Berikut ini adalah contoh program lengkap tentang yang dibahas di atas.

// contoh operator overload pada bilangan kompleks
#include<iostream>
#include<math.h>
class kompleks
{
double re;
double im;
public:
kompleks operator+(kompleks z);
kompleks operator++();
friend istream &operator>>(istream &k_in,
kompleks &k);
friend ostream &operator<<(ostream &k_out,
kompleks &k);
};
main()
{
kompleks z1(0,0);
kompleks z2(0,0);
kompleks z3(0,0);
cout<<"masukkan z1 = ? ";
cin>>z1;
cout<<"masukkan z2 = ? ";
cin>>z2;
cout<<endl<<"hasil perhitungan :"<<endl;
z3 = z1 + z2;
cout<<"z1 = "<<z1<<endl
<<"z2 = "<<z2<<endl
<<"z3 = z1+z2 = "<<z3<<endl;
z3 = z1 + 5.0;
cout<<"z1 = "<<z1<<endl
<<"z3 = z1+5.0 = "<<z3<<endl;
++z3;
cout<<"z3++ = "<<z3<<endl;
}
{
re=real;
im=imaginer;
}
kompleks kompleks::operator+(kompleks k)
{
double re1 = re+k.re;
double im1 = im+k.im;
}
103
kompleks kompleks::operator+(double konstan)

{
double re1 = re+konstan;
double im1 = im;
}
kompleks kompleks::operator++()
{
re++;
im++;
return *this;
}
istream &operator>>(istream &k_in, kompleks &k)
{
char c;
k_in>>k.re>>k.im>>c;
return(k_in);
}
ostream &operator<<(ostream &k_out, kompleks &k)
{
k_out<<k.re<<"+"<<k.im<<"i";
return(k_out);
}
keluaran:
masukkan z1 = ? 5.25+7.88i
masukkan z2 = ? 7.12+1.43i
hasil perhitungan :
z1 = 5.25+7.88i
z2 = 7.12+1.43i
z3 = z1+z2 = 12.37+9.31i
z1 = 5.25+7.88i
z3 = z1+5.0 = 10.25+7.88i
z3++ = 11.25+8.88i
Perhatikan program ckompleks3.cpp di atas. Beberapa operator penting dioverload yaitu +, ++, >> dan
<<. Untuk operator + dan operator ++ tidak berbeda dengan program sebelumnya. Yang membuat
program ini berbeda adalah overload operator << dan >>. Kedua operator ini dideklarasikan secara
global dan bukan menjadi anggota suatu kelas.
Operator >> dideklarasikan sebagai fungsi teman oleh kelas kompleks. Operator ini melewatkan
parameter bertipe istream secara referensi dan parameter k bertipe kompleks secara referensi pula.
Operator ini menghasilkan nilai balik berupa istream secara referensi.
Operator << juga dideklarasikan sebagai fungsi teman oleh kelas kompleks. Perbedaannya adalah
bahwa operator ini melewatkan parameter bertipe ostream secara referensi dan parameter k bertipe
kompleks secara referensi pula. Operator ini menghasilkan nilai balik berupa ostream secara referensi.
ostream dan istream adalah kelas yang berhubungan dengan input output suatu stream yang mana
deklarasi kelasnya disimpan dalam file header iostream.h. Mengenai bahasan tentang stream akan
diuraikan pada materi tentang stream.
1. Bagaimana modifikasi program ctitik_garis1.cpp agar metode gradien() dan panjang() pada kelas
garis menjadi teman kelas titik
2. Dapatkah dibuat rancangan kelas, sedemikian sehingga jumlah konstruktornya lebih dari tiga
104
3. Ada rancangan kelas berikut ini
class angka
{
int bil;
public:
angka(int b)
{
bil = b;
}
angka operator+(angka k)
{
return(angka(bil-k.bil));
}
angka operator/(angka k)
{
return(angka(bil*k.bil));
}
};
Ceritakan tentang program rancangan kelas di atas, terutama overload untuk operator + (plus) dan /
(bagi).
4. Ada deklarasi kelas jam sebagai berikut. Lengkapi seluruh metode dan operator overload yang
diperlukan sesuai operasi jam
class jam
{
int angka;
public:
jam(int a);
jam operator++();
jam operator--();
int getjam();
};
5. Dapatkah dibuat suatu overload operator + (plus), tetapi hasilnya operator – (minus) untuk bilangan
int. Apakah alasannya.
6. Sempurnakan program ckompleks3.cpp dengan menambah overload untuk operator – (minus), *
(kali), -- (min min)
105
IX. PEWARISAN
Pewarisan (inheritance) adalah penurunan sifat yang ada pada suatu kelas kepada kelas baru yang
menjadi turunannya. Sifat-sifat suatu kelas ditentukan oleh data anggota dan metode, sehingga yang
dimaksud penurunan sifat adalah penurunan data anggota atau metode. Kelas yang menurunkan sifat
disebut kelas dasar (base class), sedangkan yang kelas baru yang mewarisi sifat kelas dasar disebut
kelas turunan (derived class).
Anggota kelas yang dapat diwariskan pada kelas turunan adalah anggota yang mempunyai akses public
dan protected. Anggota kelas yang mempunyai akses private tetap tidak dapat diwariskan pada kelas
turunan. Jika suatu anggota mempunyai akses protected, maka anggota tersebut hanya dapat diakses
dari kelas turunan.
Dengan pewarisan dapat diciptakan suatu kelas baru yang mana kelas tersebut mewarisi seluruh sifat
kelas dasar yang mempunyai akses public atau protected ditambah sifat khusus dari kelas yang
bersangkutan. Ketentuan ini tidak berlaku sebaliknya, artinya sifat yang ada pada kelas turunan tidak
diwariskan pada kelas dasar. Adanya mekanisme pewarisan menyebabkan beberapa kelas membentuk
hirarki kelas. Sebagai gambaran diberikan contoh hirarki kelas makhluk.
Gambar 7. Hirarki Kelas
Gambaran hirarki di atas tidak sepenuhnya benar dan hanya dipergunakan untuk menerangkan
mekanisme pewarisan pada pemrograman berorientasi objek. Hirarki kelas tersebut tentang makhluk
hidup, kelas makhluk sebagai kelas dasar. Kelas makhluk menurunkan tiga kelas turunan yaitu kelas
manusia, hewan dan tumbuhan. Kelas hewan merupakan kelas dasar bagi dua kelas turunan yaitu kelas
kuda dan burung.
Masing-masing kelas mempunyai sifat tersendiri sebagai sifat khusus dari kelas bersangkutan. Karena
kelas-kelas tersebut membentuk hirarki, kelas-kelas tersebut akan mempunyai sifat sesuai dengan kelas
dasar ditambah sifat khusus kelas bersangkutan. Sifat yang ada pada kelas makhluk akan diwariskan
pada kelas manusia, hewan dan tumbuhan, tetapi sifat khusus kelas manusia tidak diwariskan kepada
kelas makhluk. Demikian juga sifat khusus pada kelas hewan dan tumbuhan, tidak diwariskan pada kelas
makhluk.
Sifat yang ada pada kelas hewan diwariskan kepada kelas turunan kuda dan burung. Karena kelas
hewan mewarisi sifat yang ada pada kelas makhluk, kelas kuda dan burung juga mewarisi sifat yang ada
pada makhluk. Hal demikian tidak terjadi sebaliknya, sifat yang ada pada kelas kuda dan burung tidak
diwariskan pada kelas hewan dan makhluk.
Dari mekanisme pewarisan yang diuraikan di atas, dapat disimpulkan bahwa pewarisan sifat adalah dari
kelas dasar kepada kelas turunan dan tidak berlaku sebaliknya. Perlu menjadi catatan juga bahwa sifat
yang dapat diwariskan pada kelas turunan adalah yang mempunyai akses public dan protected.
Mekanisme pewarisan pada pemrograman berorientasi objek dapat dikelompokkan menjadi tiga yaitu:
 pewarisan tunggal (single inheritance),
 pewarisan jamak (multiple inheritance), dan
106
 pewarisan jamak maya (virtual multiple inheritance).

Masing-masing pewarisan mempunyai hirarki kelas yang berbeda-beda.
A. Pewarisan Tunggal
Pewarisan tunggal adalah pewarisan yang mana jumlah kelas dasarnya tunggal. Pada pewarisan
tunggal, kelas turunan dapat berjumlah lebih dari satu. Pewarisan tunggal dapat digambarkan dengan
sintaksis program berikut.
class A
{
. . .
};
class B: public A
{
. . .
}
Sintaksis di atas adalah mekanisme pewarisan secara public. Dengan implementasi di atas, kelas B
merupakan kelas turunan dari kelas A. Selain pewarisan public, pewarisan juga dilakukan secara
protected maupun private. Pada pembahasan berikutnya akan difokuskan pada pewarisan secara public.
Untuk memberi gambaran tentang pewarisan tunggal, perhatikan hirarki kelas berikut yang merupakan
potongan hirarki kelas sebelumnya.
Gambar 8. Hirarki Kelas Pewarisan Tunggal
Kelas makhluk merupakan kelas dasar bagi kelas turunan hewan, sedangkan kelas hewan merupakan
kelas dasar bagi kelas turunan kuda. Dimisalkan masing-masing kelas punya sifat-sifat sebagai berikut.
Kelas makhluk mempunyai sifat khusus berkembang artinya seluruh makhluk hidup berkembang biak
Kelas hewan mempunyai sifat bergerak artinya seluruh hewan dapat bergerak atau berpindah tempat
Kelas kuda mempunyai sifat berlari artinya seluruh kuda dapat bergerak dengan cara berlari. Karena
adanya mekanisme pewarisan, sifat berkembang pada makhluk diwariskan pada kelas hewan dan kuda.
Dalam pengertian ini, kelas hewan dan kuda mewarisi sifat berkembang dari kelas makhluk. Sifat
bergerak pada hewan diwariskan pada kelas turunan kuda, tetapi tidak diturunkan kepada kelas makhluk.
Pengertiannya seluruh hewan dapat bergerak termasuk kuda, tetapi kelas makhluk belum tentu dapat
bergerak. Sifat berlari pada kuda merupakan sifat khas kuda. Karena kuda tidak punya kelas turunan,
sifat berlari tidak diwariskan pada kelas apapun.
Dengan demikian kelas makhluk mempunyai satu sifat yaitu berkembang, kelas hewan mempunyai dua
sifat yaitu berkembang dan bergerak, sedangkan kelas kuda mempunyai tiga sifat yaitu berkembang,
bergerak dan berlari.
Hirarki kelas di atas dapat diimplementasikan dalam bentuk program sebagai berikut.
107
// nama program: cwaris_tunggal.cpp

// contoh pewarisan tunggal
#include<iostream>
class makhluk
{
public:
void berkembang();
};
class hewan: public makhluk
{
public:
void bergerak();
};
class kuda: public hewan
{
public:
void berlari();
};
main()
{
makhluk mk;
hewan hw;
kuda kd;
cout<<endl<<"Sifat-sifat makhluk :"<<endl;
mk.berkembang();
cout<<endl<<"Sifat-sifat hewan :"<<endl;
hw.berkembang();
hw.bergerak();
cout<<endl<<"Sifat-sifat kuda :"<<endl;
kd.berkembang();
kd.bergerak();
kd.berlari();
}
void makhluk::berkembang()
{
cout<<"berkembang biak"<<endl;
}
void hewan::bergerak()
{
cout<<"bergerak berpindah tempat"<<endl;
}
void kuda::berlari()
{
cout<<"berlari kencang"<<endl;
}
keluaran:
Sifat-sifat makhluk :
berkembang biak
Sifat-sifat hewan :
berkembang biak
bergerak berpindah tempat
Sifat-sifat kuda :
berkembang biak
berlari kencang
108
Perhatikan cara membentuk hirarki kelas dengan mekanisme pewarisan. Pewarisan sifat pada kelas
turunan ditandai dengan diperbolehkannya kelas turunan mengakses metode dari kelas dasar yang
mempunyai akses public atau protected. Kelas kuda dapat mengakses metode berlari() dari kelas hewan
dan metode berkembang() dari kelas makhluk. Kelas hewan dapat mengakses metode berkembang()
dari kelas makhluk tetapi tidak dapat mengakses metode berlari() dari kelas kuda. Dengan demikian
pernyataan berikut salah.
mh.bergerak(); //salah
mh.berlari(); //salah
hw.berlari(); //salah
Pernyataan yang salah tidak dimasukkan pada program karena menyebabkan program tidak dapat
menampilkan hasil.
2. Kostruktor Pada Pewarisan

Pada contoh di atas, kelas turunan mewarisi sifat kelas dasar untuk metode selain konstruktor.
Bagaimana dengan pewarisan suatu konstruktor? Dalam pewarisan suatu konstruktor, perlu diperhatikan
terutama untuk konstruktor penyalinan. Dalam kelas turunan harus diperhatikan pemberian nilai untuk
parameter pada konstruktor kelas dasar. Jika kelas dasar mempunyai default konstruktor, maka
pewarisan konstruktor tidak terlalu menjadi masalah. Tentu saja jika yang dijalankan konstruktor default,
kelas turunan tidak dapat mengatur nilai data anggota pada kelas dasar. Permasalahan akan timbul jika
diinginkan menjalankan konstruktor penyalinan kelas dasar dari kelas turunan. Dalam kasus ini
pemrogram harus menyiapkan konstruktor penyalinan pada kelas turunan, sedemikian sehingga
konstruktor penyalinan pada kelas dasar dapat dijalankan pada saat objek diciptakan.
Jika konstruktor pada kelas dasar hanya berisi pernyataan memberi nilai data anggota private, maka
akses private dapat diganti dengan akses protected agar data anggota pada kelas dasar dapat diakses
dari kelas turunan. Cara ini hanya menyelesaikan masalah pemberian nilai pada kelas dasar dari kelas
turunan. Jika konstruktor pada kelas dasar berisi pernyataan yang tidak hanya berisi pemberian nilai awal
data anggota private kelas dasar, maka konstruktor harus dijalankan. Pada kasus ini memang diinginkan
menjalankan konstruktor dari kelas turunan.
Untuk menjalankan konstruktor penyalinan dari kelas turunan digunakan sintaksis sebagai berikut.
kon_turunan(parameter)
{
kon_dasar(argumen);
tubuh konuktor turunan;
}
atau dapat juga digunakan bentuk sintaksis berikut.
kon_turunan(parameter):kon_dasar(argumen)
{
tubuh konstruktor turunan;
}
Untuk memberi gambaran bagaimana suatu konstruktor diwariskan kepada kelas turunan, diberikan
contoh program tentang kelas kendaraan. Kelas kendaraan mempunyai kelas turunan pesawat. Hirarki
kelasnya adalah sebagai berikut.
109
Gambar 9. Hirarki Kelas Kendaraan dan Pesawat
Misalkan dalam kelas kendaraan terdapat data anggota berat yang berakses private serta konstruktor
untuk memberi nilai pada berat. Selain itu juga terdapat metode bobot() untuk menampilkan nilai berat.
Pada kelas pesawat terdapat data anggota laju yang berakses private dan konstruktor untuk memberi
nilai pada data anggota laju. Selain itu juga terdapat metode kecepatan() untuk menampilkan nilai laju.
Implementasi programnya adalah sebagai berikut.
// nama program: ckendaraan.cpp

// contoh penggunaan konstruktor pewarisan tunggal
#include<iostream>
class kendaraan
{
double berat;
char bbm[20];
public:
kendaraan()
{
berat=0.00;
strcpy(bbm,"minyak");
}
kendaraan(double br, char *bahan)
{
berat=br;
strcpy(bbm,bahan);
}
double bobot()
{
return(berat);
}
char *bahanbakar()
{
return(bbm);
}
};
class pesawat: public kendaraan
{
double laju;
public:
pesawat(): laju(0){}
pesawat(double lj, double br, char *bahan)
:kendaraan(br, bahan)
{
laju = lj;
}
double kecepatan()
{
return(laju);
110
}
};
main()
{
pesawat ps1;
cout<<"Data Pesawat Pertama"<<endl
<<"kecepatan : " <<ps1.kecepatan()
<<" km/jam"<<endl
<<"bobot : "<<ps1.bobot()<<" kg"<<endl
<<"bahan bakar : "<<ps1.bahanbakar()
<<endl<<endl;
pesawat ps2(1000,100,"aftur");
cout<<"Data Pesawat kedua"<<endl
<<"kecepatan : "<<ps2.kecepatan()
<<" km/jam"<<endl
<<"bobot : "<<ps2.bobot()<<" kg"<<endl
<<"bahan bakar : "<<ps2.bahanbakar()<<endl;
}
keluaran:
Data Pesawat Pertama
kecepatan : 0 km/jam
bobot : 0 kg
bahan bakar : minyak
Data Pesawat kedua

kecepatan : 1000 km/jam
bobot : 100 kg
bahan bakar : aftur
Berikut ini diberikan contoh lain tentang pewarisan sifat dari kelas segiempat pada kelas bujursangkar.
Segiempat mempunyai data anggota berupa panjang dan lebar. Luas segiempat dapat dicari dengan
perkalian antara panjang dan lebar. Bujursangkar merupakan segiempat juga yang mana panjang dan
lebarnya sama, sehingga luasnya dapat dicari dengan perkalian panjang dan lebar juga. Hirarki kelas
yang terjadi antara segiempat dan bujursangkar adalah sebagai berikut.
Gambar 10.Hirarki Kelas Segiempat dan Bujursangkar
Implementasi program untuk hirarki kelas di atas adalah sebagai berikut.
// nama program: csegiempat.cpp

// contoh pewarisan tunggal
#include<iostream>
class segiempat
{
double panjang;
double lebar;
111
public:
segiempat(double pj, double lb)
: panjang(pj), lebar(lb){}
double luas()
{
return(panjang*lebar);
}
};
class bujursangkar: public segiempat
{
double sisi;
public:
bujursangkar(double sisi): segiempat(sisi, sisi){}
};
main()
{
bujursangkar bs(5.00);
cout<<”Luas Bujursangkar = “<<bs.luas()<<endl;
}
keluaran:
Luas Bujursangkar = 25
Pada kelas segiempat terdapat konstruktor untuk memberi nilai data anggota panjang dan lebar serta
metode luas() untuk menampilkan nilai luas segiempat. Pada kelas bujursangkar terdapat satu
konstruktor yang digunakan untuk memberi nilai pada data anggota sisi sekaligus memberi nilai argumen
untuk konstruktor segiempat. Rumusan metode luas() untuk kelas segiempat berlaku juga untuk kelas
bujursangkar, sehingga untuk menampilkan luas, bujursangkar cukup mewarisi rumusan luas untuk kelas
segiempat.
3. Pewarisan Jamak
Pewarisan yang sudah dibahas di atas adalah jenis pewarisan tunggal. Dalam pemrograman berorientasi
objek juga dikenal pewarisan jamak yang mana satu kelas diturunkan lebih dari satu kelas yang berbeda.
Jadi dalam pewarisan jamak, jumlah kelas dasarnya lebih dari satu. Dalam hal ini perlu dicatat bahwa
kelas dasarnya bukan merupakan turunan dari satu kelas.
Dalam pewarisan jamak, kelas turunan mewarisi seluruh sifat dari kelas dasarnya, sehingga kelas
turunan mempunyai sifat dari beberapa kelas dasar dan sifat khas dirinya. Untuk menjelaskan pewarisan
jamak perhatikan sintaksis pewarisan berikut.
class A
{
. . .
};
class B
{
. . .
}
class C: public A, public B
{
. . .
}
Pada bentuk tersebut terdapat dua kelas dasar yaitu kelas A dan kelas B yang menurunkan kelas C.
112
Kelas C akan mewarisi sifat dari kelas A maupun sifat dari kelas B, tetapi tidak berlaku sebaliknya.
Supaya pemahaman tentang pewarisan jamak lebih jelas, perhatikan hirarki kelas berikut ini.
Gambar 11.Hirarki Kelas Pegasus
Pada gambar hirarki kelas di atas terdapat tiga kelas yaitu kuda, burung dan pegasus. Kelas kuda dan
burung merupakan kelas dasar dari kelas pegasus. Pegasus adalah hewan dalam dongeng yang
berbentuk kuda tetapi punya sayap, sehingga dapat dinaiki seperti kuda dan terbang seperti burung.
Misalkan kuda mempunyai sifat berlari, burung mempunyai sifat terbang dan pegasus mempunyai sifat
khas lariterbang. Implementasi programnya dapat ditulis sebagai berikut.
// nama program: cpegasus.cpp

// contoh pewarisan jamak
#include<iostream>
class kuda
{
public:
void berlari()
{
cout<<"berlari cepat"<<endl;
}
};
class burung
{
public:
void terbang()
{
cout<<"terbang tinggi"<<endl;
}
};
class pegasus: public kuda, public burung
{
public:
void lariterbang()
{
cout<<"lari sambil terbang"<<endl;
}
};
main()
{
pegasus pg;
cout<<"Sifat-sifat pegasus :"<<endl;
pg.berlari();
pg.terbang();
pg.lariterbang();
}
keluaran:
Sifat-sifat pegasus :
113
berlari cepat
terbang tinggi
lari sambil terbang
Dapat dilihat dari hasil keluaran program, sifat kelas pegasus merupakan gabungan dari sifat kelas kuda
dan burung. Dalam hal ini sifat suatu kelas diwujudkan dalam bentuk metode.
Contoh lain yang lebih rumit adalah program tentang kelas fan. Misalnya kelas fan merupakan kelas
turunan dari dua kelas dasar yaitu dinamo dan baling-baling (disingkat baling). Hirarki kelas digambarkan
sebagai berikut.
Gambar 12.Hirarki Kelas Fan
Terdapat tiga kelas yaitu dinamo, baling dan fan. Misalnya masing-masing kelas mempunyai sifat seperti
uraian berikut ini.
Kelas dasar dinamo mempunyai data anggota ampere yang menunjukkan nilai arus listrik yang
digunakan untuk menggerakkan dinamo. Untuk memberi nilai ampere digunakan konstruktor dinamo().
Pada kelas dinamo juga terdapat metode arus() yang digunakan untuk menampilkan nilai data anggota
ampere.
Pada kelas baling terdapat data anggota meter yang digunakan untuk menyimpan data radius baling.
Untuk memberi nilai data anggota meter digunakan konstruktor baling(), sedangkan untuk menampilkan
data anggota meter digunakan metode radius().
Kelas fan yang merupakan kelas turunan dari kelas dinamo dan baling mempunyai data anggota laju
yang digunakan untuk menyimpan nilai laju angin yang dihasilkan fan. Untuk memberi nilai data anggota
laju digunakan konstruktor fan(), sedangkan untuk menampilkan data anggota laju digunakan metode
lajuangin().
Implementasi program dapat dituliskan sebagai berikut.
// nama program: cfan.cpp

// contoh pewarisan jamak virtual
#include<iostream>
class dinamo
{
double ampere;
public:
dinamo(double a): ampere(a){}
double arus()
{
return(ampere);
}
};
class baling
{
double meter;
public:
114
baling(double m): meter(m){}

double radius()
{
return(meter);
}
};
class fan: public dinamo, public baling
{
double laju;
public:
fan(double j, double a, double m)
: laju(j), dinamo(a), baling(m){}
double lajuangin()
{
return(laju);
}
};
main()
{
fan fn(10.4, 3.25, 0.15);
cout<<"Data tentang fan :"<<endl
<<"arus = "<<fn.arus()<<" ampere"<<endl
<<"radius = "<<fn.radius()<<" meter"<<endl
<<"laju angin = "<<fn.lajuangin()
<<" m/s"<<endl;
}
keluaran:
Data tentang fan :
arus = 3.25 ampere
radius = 0.15 meter
laju angin = 10 m/s
Kelas fan merupakan kelas turunan dari dua kelas dasar dinamo dan baling. Metode arus() dari kelas
dinamo dapat diakses dari kelas fan. Demikian juga metode radius() dari kelas baling dapat diakses dari
kelas fan.
Permasalahan yang menarik adalah tentang keberadaan konstruktor. Karena adanya pewarisan, kelas
fan harus menyediakan konstruktor yang disesuaikan konstruktor-konstruktor pada kelas dinamo dan
baling. Jika kelas salah dalam menyediakan konstruktor yang sesuai, maka program akan tidak jalan.
Perhatikan bagaimana menyusun konstruktor pada kelas fan. Kelas dinamo menggunakan konstruktor
untuk memberi nilai pada data anggota ampere, sedangkan kelas baling menggunakan konstruktor untuk
memberi nilai pada data anggota meter. Oleh karena itu konstruktor pada kelas fan harus dapat memberi
nilai pada ampere, meter dan data anggotanya sendiri yaitu laju.
4. Pewarisan Jamak Virtual

Pewarisan jamak virtual adalah pewarisan yang mana kelas dasarnya lebih dari satu dan beberapa di
antara kelas dasar tersebut merupakan kelas turunan dari kelas dasar yang sama. Mekanisme pewarisan
sifat suatu kelas dasar kepada kelas turunan sama dengan pewarisan yang lain.
Bentuk pewarisan jamak virtual dapat dituliskan dengan sintaksis sebagai berikut.
class A
{
. . .
};
115
class B: virtual public A

{
. . .
};
class C: virtual public A
{
. . .
};
class D: public B, public C
{
. . .
};
Kelas D merupakan turunan dari kelas B dan C, sedangkan kelas B dan C merupakan kelas turunan dari
kelas dasar yang sama yaitu kelas A. Supaya mekanisme pewarisan dapat berjalan, pewarisan dari kelas
A kepada kelas B maupun C harus secara virtual. Dalam hal ini, dianggap seperti ada dua kelas A yang
virtual (maya atau semu) yang berbeda dan mewariskan sifat pada kelas yang berbeda. Kelas virtual A
pertama menurunkan kelas B, sedangkan kelas virtual A kedua menurunkan kelas C.
Supaya lebih jelas perhatikan hirarki kelas di bawah ini. Kelas pegasus merupakan kelas turunan dari
kelas kuda dan burung, sedangkan kelas kuda dan burung merupakan kelas turunan dari kelas dasar
hewan.
Gambar 13.Hirarki Kelas Hewan Sampai Pegasus
Untuk membuat implementasi program, perlu disusun pemikiran, sedemikian sehingga terbentuk hirarki
kelas seperti gambar di bawah ini.
Gambar 14.Hirarki Kelas Virtual Hewan Sampai Pegasus
Dianggap ada dua kelas virtual hewan yang berbeda yang menurunkan kelas sifat pada kelas kuda dan
burung. Kelas kuda merupakan kelas turunan dari kelas virtual hewan yang pertama, sedangkan kelas
116
burung merupakan kelas turunan dari kelas virtual hewan yang kedua. Selanjutnya kelas kuda dan
burung menurunkan kelas pegasus secara biasa.
Misalkan kelas hewan mempunyai sifat bergerak, kelas kuda mempunyai metode berlari(), kelas burung
mempunyai metode terbang() dan kelas pegasus mempunyai metode lariterbang(). Implementasi
program yang terjadi adalah sebagai berikut.
// nama program: cvirtual_pegasus.cpp

// contoh pewarisan jamak virtual
#include<iostream>
class hewan
{
public:
void bergerak()
{
cout<<"bergerak berpindah tempat"<<endl;
}
};
class kuda: virtual public hewan
{
public:
void berlari()
{
cout<<"berlari kencang"<<endl;
}
};
class burung: virtual public hewan
{
public:
void terbang()
{
cout<<"terbang tinggi"<<endl;
}
};
{
public:
void lariterbang()
{
cout<<"lari sambil terbang"<<endl;
}
};
main()
{
pegasus pg;
cout<<"Sifat-sifat pegasus :"<<endl;
pg.bergerak();
pg.berlari();
pg.terbang();
pg.lariterbang();
}
keluaran:
berlari kencang
terbang tinggi
lari sambil terbang
117
Perhatikan cara mewariskan sifat pada kelas turunan dari kelas dasar hewan yang virtual. Penulisan kata
public dan virtual dapat dibalik, sehingga dapat dituliskan dalam dua bentuk.
atau menggunakan bentuk berikut
class kuda: public virtual hewan
Perhatikan bahwa hasil tampilan program menunjukkan bahwa kelas pegasus akan mewarisi seluruh
sifat dari kelas dasar kuda dan burung. Bagaimana jika kata virtual dihilangkan? Akibat yang muncul
adalah program tidak dapat jalan dengan pesan kesalahan kira-kira sebagai berikut.
Member is Ambiguous:
‘hewan::bergerak()’ and ‘hewan::bergerak()’
Oleh kompiler C++ sifat bergerak kelas hewan dianggap punya dua makna yang tidak diperbolehkan.
Contoh lain tentang pewarisan jamak adalah program tentang alat. Dalam program ini terdapat empat
kelas yang membentuk suatu hirarki seperti di bawah ini.
Gambar 15.Hirarki Kelas Alat Sampai Fan
Kelas fan merupakan kelas turunan dari kelas dinamo dan baling, sedangkan kelas dinamo dan baling
merupakan kelas turunan dari satu kelas yaitu alat. Untuk menyelesaikan kasus ini, harus diambil cara
berpikir, sedemikian sehingga membentuk hirarki kelas seperti pada gambar berikut ini.
Gambar 16.Hirarki Kelas Virtual Alat Sampai Fan
Dianggap ada dua kelas virtual alat. Kelas virtual alat pertama menurunkan kelas dinamo, sedangkan
kelas virtual alat kedua menurunkan kelas baling. Kemudian kelas dinamo dan baling menurunkan kelas
118
fan.
Misalkan, seluruh alat mempunyai harga tertentu, dinamo mempunyai arus ampere tertentu, kelas baling
mempunyai radius meter tertentu dan kelas fan juga mempunyai laju angin tertentu.
Untuk memberi nilai pada data anggota, masing-masing kelas menggunakan konstruktor penyalinan.
Karena mekanisme pewarisan, kelas turunan harus memiliki konstruktor, sedemikian sehingga dapat
menjalankan konstruktor kelas dasar secara benar. Masing-masing kelas mempunyai metode yang
digunakan untuk menampilkan data anggota masing-masing. Implementasinya dapat dilihat pada
program berikut ini.
// nama program: cfan.cpp

// contoh pewarisan jamak vitual
#include<iostream>
class alat
{
int rupiah;
public:
alat(int r): rupiah(r){}
int harga()
{
return(rupiah);
}
};
class dinamo: virtual public alat
{
double ampere;
public:
dinamo(double a, int h): ampere(a), alat(h){}
double arus()
{
return(ampere);
}
};
class baling: virtual public alat
{
double meter;
public:
baling(double m, int h): meter(m), alat(h){}
double radius()
{
return(meter);
}
};
class fan: public dinamo, public baling
{
double laju;
public:
fan(double j, double a, double m, int h)
: laju(j), dinamo(a,h), baling(m,h), alat(h){}
double laju_angin()
{
return(laju);
}
};
main()
119
{
dinamo dn(20.25, 10000);
cout<<"Data tentang dinamo :"<<endl
<<"harga = Rp. "<<dn.harga()<<",00"<<endl
<<"arus = "<<dn.arus()<<" ampere"<<endl<<endl;
baling bg(0.24, 5000);
cout<<"Data tentang baling-baling :"<<endl
<<"harga = Rp. "<<bg.harga()<<",00"<<endl
<<"radius = "<<bg.radius()
<<" ampere"<<endl<<endl;
fan fn(10.4, 3.25, 0.31, 40000);
cout<<"Data tentang fan :"<<endl
<<"harga = Rp. "<<fn.harga()<<",00"<<endl
<<"arus = "<<fn.arus()<<" ampere"<<endl
<<"radius = "<<fn.radius()<<" meter"<<endl
<<"laju angin = "<<fn.laju_angin()
<<" m/s"<<endl;
}
keluaran:
Data tentang dinamo :
harga = Rp. 10000,00
arus = 20.25 ampere
Data tentang baling-baling :

harga = Rp. 5000,00
radius = 0.24 ampere
Data tentang fan :

harga = Rp. 40000,00
arus = 3.25 ampere
radius = 0.31 meter
laju angin = 10 m/s
Perhatikan hasil keluaran program di atas. Masing-masing kelas mempunyai metode yang berbeda untuk
menampilkan data anggotanya. Metode harga() untuk menampilkan data anggota rupiah dari kelas alat,
metode arus() untuk menampilkan data anggota ampere dari kelas dinamo, metode radius() untuk
menampilkan data anggota meter dari kelas baling dan metode laju_angin() untuk menampilkan data
anggota laju.
Yang perlu diperhatikan adalah mekanisme pewarisan konstruktor. Konstruktor alat() digunakan untuk
memberi nilai data anggota rupiah, konstruktor dinamo() untuk memberi nilai pada data anggota ampere
dan harga, konstruktor radius() digunakan untuk memberi nilai pada data anggota meter dan harga.
Konstruktor yang paling banyak tugasnya adalah pada kelas pegasus yang mana konstruktor pegasus()
digunakan untuk memberi nilai pada data anggota laju, meter, ampere dan rupiah.
Tugas konstruktor semakin ke arah kelas turunan semakin rumit. Jika pada kelas terdapat bermacam-
macam konstruktor, maka rancangan konstruktor harus dapat memberi nilai pada semua data anggota
suatu kelas. Bagaimana jika pada kelas terdapat beberapa jenis konstruktor?
1. Bagaimana bentuk hirarki kelas dari petikan program berikut
class a
{public: int fungsi(){return(1);}};
class a1: public virtual a
{};
120
class a2: public virtual a

{};
class a11: public a1
{};
class a12: public a2
{};
class av: public a1, public a2
{};
2. Buatlah suatu kelas tentang alat rumah tangga, kemudian buatlah kelas turunannya. Selanjutnya
buatlah hirarki kelasnya.
3. Dari hirarki kelas no.1 buatlah definisi tentang kelas tersebut dan sertakan juga metode-metode dan
data anggota yang diperlukan.
4. Buatlah rancangan kelas dasar alat transportasi, kemudian buatlah kelas turunan tentang
transportasi darat, laut dan udara. Buatlah hirarki kelasnya.
5. Dari hirarki kelas no. 3 buatlah definisi tentang kelas tersebut.
6. Bagaimana implementasi penggunaan kelas alat rumah tangga (no.1) dan alat transportasi (no.3)
dalam fungsi main().
121
X. POLIMORFISME
Polimorfisme (polymorphism) erat kaitannya dengan pewarisan. Polimorfisme adalah pemikiran bahwa
objek dinamis suatu kelas dasar dapat berperilaku seperti kelas turunan. Ketika objek tersebut menunjuk
kelas dasar, objek tersebut berperilaku seperti kelas dasar, tetapi ketika objek tersebut menunjuk kelas
turunan, objek berperilaku seperti kelas turunan. Dalam hal ini objek dapat memiliki beberapa bentuk,
tergantung pada saat itu kelas mana yang ditunjuk. Yang perlu menjadi catatan, bahwa perubahan
perilaku ini dari kelas dasar kepada kelas turunan, tidak dapat objek kelas turunan menunjuk kelas dasar.
Polimorfisme dimungkinkan karena adanya mekanisme ikatan dinamis (dynamic binding). Ikatan dinamis
adalah ikatan yang terjadi pada saat program dijalankan (run-time). Ikatan yang terjadi pada saat
kompilasi disebut ikatan statis. Ikatan dinamis hanya dapat terjadi antara suatu objek dinamis dengan
metode yang dinamis juga, dalam hal ini metode virtual (maya).
A. Polimorfisme Pada Pewarisan Tunggal

Suatu metode dapat dideklarasikan secara virtual dengan cara menambah kata virtual pada deklarasi
fungsi. Jika suatu metode dideklarasikan secara virtual dalam kelas dasar, maka keadaan virtual tetap
akan berlaku untuk fungsi yang sama di seluruh kelas turunan meskipun kata virtual tidak disebutkan.
Untuk menjelaskan tentang ikatan dinamis dalam hubungannya dengan polimorfisme, perhatikan
rancangan kelas berikut ini.
class A
{
public:
tipe fungsi_statis();
tipe virtual fungsi_virtual();
. . .
};
class B: public A
{
public:
tipe fungsi_virtual();
. . .
};
class C: public B
{
public:
tipe fungsi_virtual();
. . .
};
Hirarki kelas yang digambarkan oleh rancangan kelas di atas berupa pewarisan tunggal. Jika diciptakan
objek dinamis kelas A, maka objek ini dapat diubah bentuknya menjadi (menunjuk) objek kelas B dan
objek kelas C. Jika diciptakan objek dinamis kelas B, maka objek ini dapat diubah bentuknya menjadi
objek kelas C tetapi tidak dapat diubah menjadi objek kelas A. Sehingga perubahan bentuk hanya
berlaku dari kelas dasar menjadi kelas turunan. Pada masing-masing kelas terdapat metode
fungsi_statis() dan fungsi_virtual(). Meskipun secara eksplisit fungsi_virtual hanya dideklarasikan secara
virtual pada kelas A, secara automatis fungsi_virtual() pada kelas B dan kelas C juga berupa fungsi
virtual.
Jika diciptakan objek dinamis kelas A, maka objek ini dapat diubah bentuknya menjadi objek kelas B dan
kelas C, sehingga ikatan dinamis hanya dapat terjadi antara objek tersebut dengan fungsi_virtual() dari
kelas A, fungsi_virtual() dari kelas B dan fungsi_virtual() dari kelas C. Ikatan dinamis tidak mungkin terjadi
dengan fungsi_statis dari kelas B maupun kelas C.
122
Jika yang diciptakan objek dinamis kelas B, maka objek ini hanya dapat mengadakan ikatan dinamis
dengan fungsi_virtual() dari kelas C saja. Hal ini sesuai aturan bahwa perubahan bentuk objek hanya
dapat dari objek dinamis kelas dasar menjadi objek dinamis kelas turunan.
Supaya lebih jelas pengertian tentang polimorfisme perhatikan program sederhana berikut.
// nama program: cpolimorfisme.cpp

// contoh polimorfisme dalam pewarisan tunggal
#include<iostream>
class A
{
public:
char *fungsi_statis()
{
return("fungsi statis kelas A");
}
char virtual *fungsi_virtual()
{
return("fungsi virtual kelas A");
}
};
class B: public A
{
public:
{
return("fungsi statis kelas B");
}
char *fungsi_virtual()
{
return("fungsi virtual kelas B");
}
};
class C: public B
{
public:
{
return("fungsi statis kelas C");
}
char *fungsi_virtual()
{
return("fungsi virtual kelas C");
}
};
main()
{
A *pa;
pa = new A;
cout<<"objek pa berbentuk objek kelas A"<<endl
<<pa->fungsi_statis()<<endl
<<pa->fungsi_virtual()<<endl<<endl;
delete pa;
pa = new B;
cout<<"objek pa berbentuk objek kelas B"<<endl
delete pa;
123
pa = new C;
cout<<"objek pa berbentuk objek kelas C"<<endl
delete pa;
}
keluaran:
objek pa berbentuk objek A
fungsi statis kelas A
fungsi virtual kelas A
objek pa berbentuk objek B

fungsi virtual kelas B
objek pa berbentuk objek C

fungsi virtual kelas C
Perhatikan fungsi main() pada program di atas. Mula-mula objek dinamis pa dideklarasikan sebagai kelas
A, selanjutnya diciptakan objek pa berbentuk kelas A (menunjuk kelas A). Selanjutnya dijalankan
fungsi_statis() dan fungsi_virtual(). Yang dijalankan adalah metode dari kelas A (sesuatu yang wajar
karena objeknya berbentuk kelas A).
Langkah berikutnya melenyapkan objek dinamis pa. Selanjutnya diciptakan kembali objek dinamis pa,
tetapi berbentuk kelas B. fungsi_statis() dan fungsi_virtual() dijalankan kembali. Hasilnya adalah,
fungsi_statis() yang dijalankan adalah yang merupakan metode kelas A, sedangkan fungsi_virtual() yang
dijalankan adalah metode kelas B. Ini menunjukkan bahwa ikatan objek dinamis pa dengan
fungsi_statis() tidak dapat dilakukan sehingga objek dinamis pa tetap mengikat fungsi_statis() kelas A.
Ikatan ini merupakan ikatan statis. Sedangkan ikatan objek dinamis pa dengan fungsi_virtual() kelas B
merupakan ikatan dinamis.
Langkah selanjutnya melenyapkan objek dinamis pa dan dilanjutkan menciptakan objek dinamis pa yang
berbentuk kelas C. Kemudian menjalankan fungsi_statis() dan fungsi_virtual(). Hasilnya adalah
fungsi_statis yang dijalankan berasal dari kelas A, sedangkan fungsi_virtual() yang dijalankan berasal dari
kelas C. Keteranganya analogi dengan paragraf sebelumnya.
2. Polimorfisme Pada Pewarisan Jamak

Bagaimana polimorfisme diterapkan pada pewarisan jamak?. Polimorfisme juga dapat diterapkan pada
pewarisan jamak termasuk pewarisan jamak virtual. Pada pewarisan jamak, tidak ada bedanya dengan
pada pewarisan tunggal, hanya saja kata virtual harus disebutkan pada semua metode pada kelas dasar
yang dirancang dapat mengadakan ikatan dinamis.
Misalnya polimorfisme diterapkan pada kelas pegasus, yang mana pegasus dianggap sebagai kelas
turunan dari kelas kuda dan burung. Jika diterapkan polimorfisme, maka harus diambil pengertian bahwa
berlarinya kuda berbeda dengan berlarinya pegasus. Demikian juga terbangnya burung berbeda dengan
terbangnya pegasus. Dalam implementasi program, definisi fungsinya berbeda. Implementasi program
untuk kelas pegasus dengan penerapan pewarisan jamak dan polimorfisme dapat dituliskan sebagai
berikut.
// nama program: cpoli_pegasus.cpp

// contoh polimorfisme pada pewarisan jamak
#include<iostream>
class kuda
{
public:
124
void virtual berlari()

{
cout<<"berlari cepatnya kuda"<<endl;
}
};
class burung
{
public:
void virtual terbang()
{
cout<<"terbang tingginya burung"<<endl;
}
};
{
public:
void berlari()
{
cout<<"berlari cepatnya pegasus"<<endl;
}
void terbang()
{
cout<<"terbang tingginya pegasus"<<endl;
}
};
main()
{
kuda *pkd;
pkd = new kuda;
pkd->berlari();
delete pkd;
pkd = new pegasus;
cout<<endl<<"Sifat-sifat pegasus :"<<endl;
pkd->berlari();
burung *pbr;
pbr = new burung;
pbr->terbang();
delete pbr;
pbr = new pegasus;
cout<<endl<<"Sifat-sifat pegasus :"<<endl;
pbr->terbang();
}
keluaran:
Sifat-sifat kuda :
berlari cepatnya kuda
berlari cepatnya pegasus
Sifat-sifat kuda :
terbang tingginya burung
terbang tingginya pegasus
Program di atas menunjukkan bahwa objek dinamis pkd dari kelas dasar kuda dapat berbentuk kelas
125
pegasus. Demikian juga objek dinamis pbr dari kelas dasar burung dapat berbentuk kelas pegasus.
Tetapi objek dinamis pkd tidak dapat berbentuk kelas burung, begitu juga sebaliknya, objek dinamis pbr
dari kelas burung tidak dapat berubah bentuk menjadi kelas kuda. Sehingga pernyataan di bawah ini
akan menyebabkan kesalahan
pkd = new burung; // salah

pbr = new kuda; // salah
Dapat dilihat, ketika objek pkd berbentuk kuda, maka metode berlari() yang dijalankan adalah metode
dari kelas kuda. Ketika objek pkd diubah menjadi berbentuk kelas pegasus, metode berlari() yang
dijalankan adalah metode dari kelas pegasus.
Demikian juga untuk objek dinamis pbr, ketika berbentuk kelas burung, metode terbang() yang dijalankan
adalah metode dari kelas burung. Ketika objek pbr diubah bentuk menjadi kelas pegasus, metode
terbang() yang dijalankan adalah metode dari kelas pegasus.
3. Polimorfisme Pada Pewarisan Jamak Virtual

Selanjutnya, bagaimana polimorfisme pada pewarisan jamak virtual? Polimorfisme pada pewarisan
jamak virtual juga tidak banyak berbeda. Berikut ini diberikan contoh polimorfisme pada kelas hewan
sampai pegasus. Untuk menyederhanakan program, hanya diperhatikan metode bergerak() pada kelas
hewan. Metode bergerak() pada kelas hewan berbeda dengan metode bergerak() pada kelas kuda,
burung atau pegasus. Kelas kuda memberi pengertian bergerak secara umum yaitu berpindah tempat.
Kelas kuda memberi pengertian bergerak dengan cara berlari, kelas burung memberi pengertian
bergerak dengan cara terbang, sedangkan pegasus memberi pengertian bergerak dengan cara terbang
atau berlari.
Perhatikan implementasi program berikut, serta perhatikan definisi metode pada masing-masing kelas.
Kata virtual hanya dipakai pada metode bergerak pada kelas hewan sebagai tanda bahwa metode
tersebut bersifat dinamis. Karena kelas-kelas lain merupakan turunan dari kelas hewan, metode
bergerak() pada kelas-kelas tersebut juga bersifat dinamis.
// nama program: cpolivirtual_pegasus.cpp

// contoh polimorfisme pada pewarisan jamak virtual
#include<iostream>
class hewan
{
public:
void virtual bergerak()
{
cout<<"bergeraknya hewan secara umum"<<endl;
}
};
{
public:
void bergerak()
{
cout<<"bergeraknya kuda dengan berlari"<<endl;
}
};
class burung: virtual public hewan
{
public:
void bergerak()
{
cout<<"bergeraknya burung dengan terbang"<<endl;
126
}
};
{
public:
void bergerak()
{
cout<<"bergeraknya pegasus dengan”
<<”terbang dan berlari"<<endl;
}
};
main()
{
hewan *phw;
phw = new hewan;
cout<<endl<<"objek phw berbentuk hewan :"<<endl;
phw->bergerak();
px = NULL;
phw = new kuda;
cout<<endl<<"objek phw berbentuk kuda :"<<endl;
phw->bergerak();
px = NULL;
phw = new burung;
cout<<endl<<"objek phw berbentuk burung :"<<endl;
phw->bergerak();
px = NULL;
phw = new pegasus;
cout<<endl<<"objek phw berbentuk pegasus :"<<endl;
phw->bergerak();
px = NULL;
delete px;
}
keluaran:
objek phw berbentuk hewan :
bergeraknya hewan secara umum
objek phw berbentuk kuda :

bergeraknya kuda dengan berlari
objek phw berbentuk burung :

bergeraknya burung dengan terbang
objek phw berbentuk pegasus :

bergeraknya pegasus dengan terbang dan berlari
Pada program tersebut dideklarasikan phw berupa objek dinamis kelas hewan. Ketika objek phw
berbentuk (menunjuk) kelas hewan, metode bergerak() yang dijalankan adalah metode dari kelas hewan.
Ketika objek phw berbentuk kelas kuda, metode bergerak() yang dijalankan adalah metode dari kelas
kuda. Ketika objek phw berbentuk kelas burung, metode bergerak() yang dijalankan adalah metode dari
kelas burung. Ketika objek phw berbentuk kelas pegasus, metode bergerak() yang dijalankan adalah
metode dari kelas pegasus.
1. Buatlah hirarki kelas tentang alat trasportasi, tentukan juga kelas turunannya, sedemikian sehingga
membentuk kelas pesawat amfibi yang dapat bergerak di laut dan udara. Kelas pesawat amfibi
merupakan turunan dari kelas pesawat dan kapal, sedangkan pesawat dan kapal masing-masing
127
merupakan turunan dari kelas angkutan udara dan laut. Kelas angkutan udara dan laut merupakan
turunan dari kelas dasar alat transportasi.
2. Perhatikan deklarasi kelas berikut. Bagaimana penggunaan metode fungsi() di seluruh kelas pada
program utama?
class a
{ int da;
public:
char virtual fungsi(){return('a');}
};
class b: public virtual a
{ public:
char fungsi(){return('b');}
};
class c: public virtual a
{ public:
char fungsi(){return('c');}
};
class d: public b
{ public:
char fungsi(){return('d');}
};
class e: public c
{ public:
char fungsi(){return('e');}
};
class f: public b, public c
{ public:
char fungsi(){return('f');}
};
3. Bagaimana definisi konstruktor penyalinan di masing-masing kelas, jika konstruktor tersebut

digunakan untuk memberi nilai pada data anggota pada kelas?
4. Jika masing-masing kelas mempunyai data anggota da, db, dc, dd, de dan df sesuai urutan kelas
dan akan diberi nilai dengan konstruktor penyalinan, maka bagaimana bentuk konstruktor di masing-
masing kelas?
128
XI. STREAM
Dalam bahasa C++, data ditulis atau dibaca dari suatu stream. Stream sebetulnya merupakan aliran data
yang dapat berupa beberapa bentuk yaitu:
 stream dapat berupa deretan karakter
 stream dapat berupa hubungan ke device atau disk
 stream dapat berupa sesuatu yang mengarah pada suatu nama
Stream yang sudah banyak dibahas adalah cin dan cout. Untuk memperoleh masukan data dari papan
ketik digunakan stream cin sedangkan untuk menampilkan data pada monitor digunakan stream cout.
Untuk dapat menggunakan dua stream tersebut diperlukan penyertaan file header iostream.h. Fasilitas
pemasukan data dari papan ketik sangat memudahkan bagi pemrogram untuk merancang programnya,
sedemikian sehingga masukan dapat diinputkan secara lebih bebas. Program menjadi tidak statis karena
masukannya dapat lebih variatif sesuai kehendak yang menjalankan program.
Berikut ini adalah gambar hirarki kelas dalam iostream.h
Gambar 17.Hirarki Kelas iostream.h
Dapat dilihat bahwa kelas ios menurunkan dua kelas yaitu kelas istream dan kelas ostream. Kelas
istream berhubungan dengan stream masukan, sedangkan kelas ostream berhubungan dengan stream
keluaran. Kedua kelas menurunkan kelas yang sama yaitu kelas iostream yang berhubungan dengan
stream masukan-keluaran. Kelas istream mempunyai kelas turunan kelas istream_withassign, kelas
ostream mempunyai kelas turunan kelas ostream_withassign, sedangkan kelas iostream mempunyai
kelas turunan kelas iostream_withassign.
A. Lebih Lanjut Tentang cin

cin merupakan objek stream global bertipe istream_withassign, stream ini mempunyai operator ekstraksi
>> yang digunakan untuk mengambil data dari papan ketik. Untuk tipe-tipe data dasar bahasa C++
semacam int, float, double dan char, operator >> berhasil mengambil data secara baik dari papan ketik.
Untuk data yang tidak sederhana semacam larik karakter (string), operator ini menimbulkan
permasalahan. Perhatikan contoh program berikut ini.
// nama program: ccin.cpp

// contoh lebih lanjut tentang cin
#include<iostream>
main()
{
int intA;
float floatB;
double doubleC;
129
char charD;
char stringE[100];
cout<<"Masukkan data int : ? ";
cin>>intA;
cout<<"Masukkan data float : ? ";
cin>>floatB;
cout<<"Masukkan data double : ? ";
cin>>doubleC;
cout<<"Masukkan data char : ? ";
cin>>charD;
cout<<"Masukkan data string : ? ";
cin>>stringE;
cout<<"Data yang dimasukkan :"<<endl
<<"intA = "<<intA<<endl
<<"floatB = "<<floatB<<endl
<<"doubleC = "<<doubleC<<endl
<<"charD = "<<charD<<endl
<<"stringE = "<<stringE<<endl;
}
keluaran:
Masukkan data int : ? 212
Masukkan data float : ? 500.425
Masukkan data double : ? 12E+10
Masukkan data char : ? p
Masukkan data string : ? Belajar Pemrograman Objek
intA = 212
floatB = 500.425
doubleC = 1.2e+11
charD = p
stringE = Belajar
Bandingkan antara data yang dimasukkan dengan hasil keluaran yang ditampilkan. Untuk data int, float,
double maupun char, program menghasilkan keluaran yang benar. Untuk data bertipe larik char, ternyata
program salah dalam mengambil nilai stringE. Secara umum operator ekstraksi >> akan menganggap
spasi sebagai akhir dari suatu larik karakter, sehingga operator >> hanya akan mengambil bagian
pertama sebelum spasi pada larik yang dimasukkan.
Stream cin mempunyai beberapa metode yang dapat digunakan untuk mengatasi permasalahan di atas,
diantaranya adalah get dan getline. Kedua metode dapat digunakan untuk mengambil data berbentuk
char atau larik char. Cara menggunakan metode get() dan getline() adalah sebagai berikut.
cin.get(nama_larik, jumlah);
cin.getline(nama_larik, jumlah);
nama_larik menunjukkan nama larik karakter yang akan diambil datanya dari papan ketik, sedangkan
jumlah menyatakan jumlah karakter yang diambil dari papan ketik.
Untuk lebih jelasnya penggunaan perintah metode get() untuk mengambil suatu larik char, perhatikan
contoh program berikut ini.
// nama program: cget.cpp

// contoh mengambil data larik char dengan cin
#include<iostream>
main()
{
char stringE[100];
130
cout<<"Masukkan data stringE : ? ";

cin.get(stringE,100);
<<"stringE = "<<stringE<<endl;
}
keluaran:
Masukkan data stringE : ? Belajar Bahasa C++
stringE = Belajar Bahasa C++
Selain menggunakan metode get(), dapat juga digunakan metode getline() untuk mengambil larik char
dari papan ketik. Berikut ini contoh programnya.
// nama program: cgetline.cpp

// contoh lain mengambil data larik char dengan cin
#include<iostream>
main()
{
char stringF[100];
cout<<"Masukkan data stringF : ? ";
cin.getline(stringF,100);
<<"stringF = "<<stringF<<endl;
}
keluaran:
Masukkan data stringF : ? Pemrograman Berorientasi Objek
stringF = Pemrograman Berorientasi Objek
Baik metode get() maupun getline() dapat digunakan untuk mengambil larik char. Kedua metode pada
dasarnya sama, perbedaannya adalah metode getline() akan membuang karakter yang dimasukkan
terakhir dalam hal ini enter. Pengaruh ini tidak akan terlihat jika kedua metode digunakan secara terpisah
dalam program berbeda. Jika kedua metode digunakan bersama dalam satu program, maka akan terlihat
perbedaannya. Perhatikan program berikut ini.
// nama program: cget_line.cpp

// mengambil data dengan cin.get() dan cin.getline()
#include<iostream>
main()
{
char stringE[100], stringF[100];
cout<<"Masukkan data stringE dan stringF: ?"<<endl;
cin.getline(stringE,100);
cin.get(stringF,100);
<<"stringE = "<<stringE<<endl
<<"stringF = "<<stringF<<endl;
}
keluaran:
Masukkan data stringE dan stringF: ?
ini adalah stringE
ini adalah stringF
stringE = ini adalah stringE
131
stringF = ini adalah stringF
Perhatikan bahwa metode getline() akan mengambil larik char yang dimasukkan dari papan ketik,
kemudian mengabaikan masukan enter. Coba sekarang metode getline() dan get() dibalik urutannya.
Keluaran yang dihasilkan adalah sebagai berikut.
Masukkan data stringE dan stringF: ?

ini adalah stringE
stringE = ini adalah stringE
stringF =
Pada saat dimasukkan larik karakter dari papan ketik, larik tersebut akan masuk dalam variabel stringE.
Tetapi perlu diingat, bahwa terakhir diketikkan enter, sehingga karakter terakhir enter yang dimasukkan
tidak akan dibuang oleh metode get(). Karakter terakhir ini secara automatis akan diambil oleh getline()
dan dianggap sebagai masukan walaupun nantinya dibuang oleh metode getline(). Pengaruhnya adalah
metode getline() seperti mengambil karakter kosong.
2. Lebih Lanjut Tentang cout

cout merupakan objek stream global yang bertipe ostream_withassign. Stream ini mempunyai operator
insersi << untuk menampilkan menampilkan data berbentuk int, float, double atau char. Sebetulnya cout
dapat juga digunakan untuk mengatur format penampilan data dalam layar monitor. cout mempunyai
beberapa metode yang dapat digunakan untuk mengatur tampilan di layar monitor antara lain sebagai
berikut.
 put() : menampilkan data char
 write() : menampilkan larik char dengan panjang tertentu
 width() : menampilkan data dengan lebar medan tertentu
 fill() : mengisi sisa lebar medan dengan karakter tertentu
 setf () : menampilkan data dengan flag tertentu
Metode put() dan write() sebetulnya merupakan pelengkap dari metode get() dan getline(). Metode put()
digunakan untuk menampilkan data berbentuk char, sedangkan metode write() digunakan untuk
menampilkan data berbentuk larik char pada layar monitor dengan format tertentu.
Untuk lebih jelasnya, perhatikan contoh penggunaan put() dan write() pada program berikut.
// nama program: cput_write.cpp

// contoh penggunaan put dan write
#include<iostream>
main()
{
cout.put('k')<<endl;
cout.put('a').put('b').put('c')<<endl;
char kalimat[]="Belajar Pemrograman Objek";
cout.write(kalimat,25)<<endl;
}
keluaran:
k
abc
Belajar Pemrograman Objek
132
Belajar Pemrograman
Belajar
Perhatikan program di atas serta hasil keluaran yang ditampilkan. Perintah berikut
cout.put(‘k’)
akan menghasilkan keluaran tampilan program yang sama dengan perintah
cout<<’k’
sedangkan perintah berikut
cout.put('a').put('b').put('c')
akan menghasilkan keluaran tampilan program yang sama dengan perintah
cout<<’a’<<’b’<<’c’
sehingga mungkin lebih mudah tanpa menggunakan metode put(). Kebanyakan program dalam bahasa
C++ jarang yang menggunakan metode tersebut.
Yang lebih berguna adalah metode write() yang mana dapat menampilkan dengan format tertentu yang
dalam hal ini mengatur jumlah karakter yang akan ditampilkan pada layar monitor. Jika yang ditampilkan
seluruh larik char, maka perintah ini sama dengan cout tanpa metode write(). Jika diinginkan
menampilkan sebagian saja dari larik char, maka metode write() dapat digunakan. Seperti terlihat pada
program di atas metode char pertama kali digunakan untuk menampilkan seluruh larik char, yang kedua
ditampilkan sebanyak 19 karakter dan terakhir digunakan untuk menampilkan 7 karakter.
Berikutnya yang dibahas adalah metode width() dan metode fill(). Metode width() digunakan untuk
mengatur lebar medan yang digunakan untuk menampilkan suatu data, sedangkan metode fill()
digunakan untuk mengisi sisa medan yang tidak digunakan dengan karakter tertentu. Untuk lebih
jelasnya perhatikan contoh berikut ini.
// nama program: cwidth_fill.cpp

// contoh penggunaan metode width dan metode fill
#include<iostream>
main()
{
int data_i = 4567;
float data_f = 543.527;
cout<<"keluaran dengan medan kosong"<<endl;
cout.width(15);
cout<<data_i<<endl;
cout.width(20);
cout<<data_f<<endl;
cout<<"keluaran dengan medan kosong diisi #"<<endl;
cout.width(15);
cout.fill('#');
cout<<data_i<<endl;
cout.width(20);
cout.fill('#');
cout<<data_f<<endl;
}
133
keluaran:
keluaran dengan medan kosong
4567
543.527
keluaran dengan medan kosong diisi #
###########4567
#############543.527
Pada keluaran dapat dilihat bahwa dengan metode width() ukuran medan tampilan dapat diatur
sedemikian rupa sesuai dengan ukuran yang diinginkan. Demikian juga, medan yang kosong dapat diisi
dengan karakter yang diinginkan, dalam contoh tersebut diisi dengan tanda #.
Hasil tampilan dengan cout juga dapat diatur menggunakan metode setf() dengan parameter berupa flag
tertentu. Flag yang dapat digunakan adalah sebagai berikut.
 ios::showpoint : menampilkan angka nol dibelakang desimal.
 ios::left : menampilkan rata kiri.
 ios::right : menampilkan rata kanan.
 ios::dec : menampilkan bilangan basis 10
 ios::oct : menampilkan bilangan basis 8
 ios::hex : menampilkan bilangan basis 16
Contoh penggunaan flag-flag tersebut dapat dilihat pada contoh program berikut.
// nama program: csetf.cpp

// contoh penggunaan metode setf
#include<iostream>
main()
{
int data_i = 27985;
float data_f = 5463.00;
cout<<"Contoh keluaran data_f : "<<data_f<<endl;
cout<<"tanpa setf = "<<endl;
cout<<data_f<<endl;
cout<<"dengan ios::showpoint = "<<endl;
cout.setf(ios::showpoint);
cout<<data_f<<endl;
cout<<"dengan ios::left = "<<endl;
cout.width(20);
cout.setf(ios::left);
cout<<data_f<<endl;
cout<<"dengan ios::right = "<<endl;
cout.width(20);
cout.setf(ios::right);
cout<<data_f<<endl;
cout<<endl<<"Contoh keluaran data_i : "
<<data_i<<endl;
cout<<"dengan ios::dec = "<<endl;
cout.setf(ios::dec);
cout<<data_i<<endl;
cout<<"dengan ios::oct = "<<endl;
cout.setf(ios::oct);
cout<<data_i<<endl;
cout<<"dengan ios::hex = "<<endl;
cout.setf(ios::hex);
cout<<data_i<<endl;
}
134
keluaran:
Contoh keluaran data_f : 5463
tanpa setf =
5463
dengan ios::showpoint =
5463.00
dengan ios::left =
5463.00
dengan ios::right =
5463.00
Contoh keluaran data_i : 27985

dengan ios::dec =
27985
dengan ios::oct =
66521
dengan ios::hex =
6d51
Perhatikan hasil tampilan dari program di atas. Dengan flag ios::showpoint maka nilai angka nol
dibelakang desimal akan ditampilkan, sehingga angka 5463.00 tidak akan ditampilkan menjadi 5463.
Untuk perataan dapat diatur menggunakan flag ios::left untuk rata kiri dan ios::right untuk rata kanan.
Beberapa flag yang berhubungan dengan basis bilangan dapat ditampilkan dengan cara yang lebih
singkat, seperti bahasan pada bab terdahulu. Beberapa contohnya dapat dijelaskan di sini.
cout.setf(ios::dec);
cout<<data_i<<endl;
cout.setf(ios::oct);
cout<<data_i<<endl;
cout.setf(ios::hex);
cout<<data_i<<endl;
dapat disingkat menjadi
cout<<dec<<data_i<<endl;
cout<<oct<<data_i<<endl;
cout<<hex<<data_i<<endl;
3. Stream File
Pemasukan data dari papan ketik kadang menjadi tidak efisien untuk beberapa situasi tertentu. Beberapa
situasi yang menyebabkan pemasukan data dari papan ketik kurang efisien yaitu:
 Jika data keluaran dari program tersebut menjadi masukan dari program lain. Kadang-kadang
diinginkan keluaran dari suatu program dijadikan masukan oleh program lain. Situasi demikian akan
semakin rumit jika program sudah dalam bentuk terkompilasi, sehingga sulit menggabungkan dua
program yang berbeda padahal diinginkan hasilnya saling dikomunikasikan.
 Jika data yang akan dimasukkan sedemikian banyak. Kadang-kadang data yang diperlukan oleh
suatu program jumlahnya cukup banyak. Pada saat merancang suatu program dengan masukan
data yang sangat banyak, tentunya akan menjemukan bagi pemrogram, karena setiap saat program
diuji, selalu harus dimasukkan data yang mungkin sama tetapi jumlahnya banyak sekali.
Dalam dua situasi tersebut diperlukan file eksternal untuk mengatasinya. Untuk kasus ini diperlukan
stream file.
135
Kasus pertama yang mana diinginkan hasil program menjadi masukan program lain. Hasil keluaran
program pertama dapat disimpan dalam suatu file, kemudian program kedua membaca file tersebut
sebagai masukkan. Cukup mudah untuk mengarahkan hasil tampilan output suatu program dari monitor
ke arah file.
Kasus kedua yang mana terdapat masukan data yang jumlahnya sangat banyak. Sebelum merancang
program, pemrogram membuat beberapa file yang berisi beberapa kombinasi masukan dari program.
File-file ini dijadikan masukan program, sehingga tidak perlu dimasukkan dari papan ketik. Program
cukup membuka file, kemudian dibaca isinya dan dijadikan masukan program.
Bagaimana melibatkan file dalam operasi masukan dan keluaran suatu program? Suatu stream yang
yang digunakan untuk masukan data harus mempunyai tipe kelas ifstream, sedangkan stream yang
digunakan untuk mengeluarkan data harus bertipe kelas ofstream. Supaya dapat menggunakan ifstream
dan ofstream, harus disertakan file header fstream.h Hirarki kelas yang terdapat dalam file header
fstream.h tidak dapat lepas dari hirarki kelas dalam iostream.h. Kelas-kelas dalam fstream merupakan
turunan dari kelas-kelas dalam iostream.h. Berikut ini hirarki kelas dalam fstream.h yang digambarkan
dalam kotak.
Gambar 18.Hirarki Kelas fstream.h
Yang ada dalam kotak merupakan kelas yang berada dalam fstream.h, sedangkan yang di luar kotak
merupakan kelas-kelas yang ada dalam iostream.h. Dapat dilihat pada gambar di atas, dalam file header
fstream.h terdapat kelas fstreambase yang merupakan turunan dari kelas ios. Kelas fstreambase
bersama kelas istream menurunkan kelas ifstream yang berhubungan dengan stream masukan dari file.
Kelas fstreambase dan kelas ostream menurunkan kelas ofstream yang berhubungan dengan stream
keluaran pada file. Sedangkan kelas fstreambase dan kelas iostream menurunkan kelas fstream yang
berhubungan dengan stream masukan-keluaran pada file.
Supaya dapat menggunakan kelas istream maupun ostream, harus dideklarasikan streamnya. Berikut ini
cara mendeklarasikan stream baca untuk masukan dan stream tulis untuk keluaran.
ifstream nama_stream_masukan; // stream masukan

ofstream nama_stream_keluaran; // stream keluaran
Untuk menghubungkan stream digunakan metode open() yang merupakan fungsi anggota kelas ifstream
dan ofstream. Bentuk umum untuk menghubungkan stream dengan nama_stream pada suatu file adalah
nama_stream.open(nama_file);
nama_stream.open(nama_file,mode);
Secara default, mode akan susuai dengan kelasnya. Jika stream masukan (ifstream), maka mode akan
bernilai ios::in, sedangkan jika stream keluaran (ofstream), maka mode akan bernilai ios::out. Mode
pembukaan yang lain adalah:
 ios::app : menambah isi file pada akhir
 ios::ate : menempatkan pointer ke akhir
136
 ios::trunc : menyebabkan file terpotong

 ios::nocreate : membuka file yang sudah ada
 ios::noreplace : membuka file baru
 ios::in : membuka file masukan
 ios::out : membuka file keluaran
 ios::binary : membuka file secara biner
Mode-mode di atas dapat digunakan secara bersama-sama, atau mengkombinasikan dari beberapa
mode.
Selain dengan metode open(), membuka file dapat dilakukan menggunakan konstruktor kelas stream
yaitu:
ifstream nama_stream(nama_file);
ofstream nama_stream(nama_file);
Untuk mengetahui apakah stream berhasil dihubungkan pada file atau tidak digunakan metode fail(). Jika
stream berhasil dihubungkan pada suatu file, maka metode ini akan menghasilkan nilai benar, dan akan
bernilai salah jika sebaliknya.
Setelah file dibuka, kemudian dioperasikan, pada akhir program jangan lupa untuk menutup file dengan
metode close(). Bentuk umumnya adalah sebagai berikut
nama_stream.close();
Berikut ini contoh program yang dapat digunakan untuk menulis data pada suatu file. Data yang akan
disimpan berupa larik char.
// nama program: coutput_larik.cpp

// memberi contoh menyimpan data larik char ke file
#include<fstream>
#include<iostream>
int main()
{
ofstream tulis;
char kalimat[255];
tulis.open("file.txt");
if(tulis.fail())
{
cout<<"File gagal dibuka"<<endl;
return(1);
}
tulis<<"Pemrograman Berorientasi Objek"<<endl;
tulis<<"Belajar Bahasa C++"<<endl;
cout<<"File berhasil ditulis"<<endl;
tulis.close();
}
keluaran:
File berhasil ditulis
Jika program berhasil dijalankan secara sukses, maka akan muncul file dengan nama file.txt yang
terletak pada direktori yang sama dengan program aplikasinya. Isi dari file tersebut dapat dibaca dengan
editor text misalnya notepad dan isinya adalah sebagai berikut
137

Belajar Bahasa C++
Isi dari file.txt dapat dibaca menggunakan program yang menggunakan ofstream. Program yang
menggunakan ofstream ditujukan untuk membaca isi suatu file. Bentuk programnya dapat dilihat sebagai
berikut.
// nama program: cinput_larik.cpp

// memberi contoh menyimpan data larik char ke file
#include<fstream>
#include<iostream>
int main()
{
char kalimat[255];
ifstream baca;
baca.open("file.txt");
if(baca.fail())
{
return(1);
}
cout<<"Isi file :"<<endl;
while(!baca.eof())
{
baca.getline(kalimat,255);
cout<<kalimat<<endl;
}
baca.close();
}
keluaran:
Isi file :
Belajar Bahasa C++
Dapat dilihat pada program di atas, untuk membaca isi file yang berupa larik char digunakan metode
getline(). Metode ini sebetulnya adalah fungsi anggota kelas ostream, tetapi karena kelas ofstream
merupakan kelas turunan dari ostream, maka kelas ofstream dapat menggunakan metode getline().
Selain data berbentuk larik char, file dapat juga digunakan untuk menyimpan data yang berbentuk data
numerik seperti int, float atau double. Berikut ini adalah contoh program yang menggunakan file untuk
menyimpan data numerik.
// nama program: coutput_numerik.cpp

// memberi contoh menyimpan data ke file
#include<fstream>
#include<iostream>
int main()
{
ofstream tulis;
tulis.open("data.txt");
if(tulis.fail())
{
return(1);
}
for(int k=0; k<10; k++)
{
138
tulis<<k<<endl;
}
cout<<"File berhasil ditulis"<<endl;
tulis.close();
}
keluaran:
File berhasil ditulis
Jika tidak terdapat kesalahan dalam menjalankan program, maka dalam direktori yang sama dengan
program tersebut akan terdapat file data.txt yang berisi tulisan berikut.
0
1
2
3
4
5
6
7
8
9
Hasil di atas merupakan hasil dari stream tulis yang bertipe kelas ofstream. File data.txt isinya dapat
dibaca menggunakan stream masukan, kemudian hasilnya ditampilkan dalam monitor. Untuk membaca
isi dari file, harus dideteksi apakah pembacaan sudah sampai pada akhir file atau belum. Untuk
mendeteksi akhir file digunakan metode eof(). Metode ini akan memberi nilai benar jika pembacaan
sudah mencapai akhir file, dan memberikan nilai salah jika sebaliknya. Berikut ini contoh program untuk
membaca data dari file.
// nama program: cinput_numerik.cpp

// memberi contoh membaca data dari file
#include<fstream>
#include<iostream>
int main()
{
int x;
ifstream baca;
baca.open("data.txt");
if(baca.fail())
{
return(1);
}
baca>>x;
while(!baca.eof())
{
cout<<x<<endl;
baca>>x;
}
baca.close();
}
keluaran:
Isi file :
0
139
1
2
3
4
5
6
7
8
9
Bentuk-bentuk file yang terjadi pada saat menjalankan program tersebut adalah file teks . Ada bentuk file
lain yang dapat digunakan sebagai stream masukan ataupun keluaran yaitu file biner. Cara penyimpanan
dalam file biner berbeda dengan cara penyimpanan dalam file teks. File teks menyimpan angka int 12345
dalam lima byte, sedangkan file biner akan menyimpan angka int 12345 dalam empat byte. Pola
penyimpanan ini sesuai dengan pola penyimpanan dalam memori komputer. Secara fisik, file teks dapat
dibaca isinya dengan editor teks, sedangkan file biner tidak dapat dibaca isinya dengan editor teks.
Berikut ini contoh penggunaan stream file dalam mode biner.
// nama program: coutput_biner.cpp

// memberi contoh menyimpan data ke file secara biner
#include<fstream>
#include<iostream>
int main()
{
ofstream tulis;
tulis.open("data.bin", ios::binary);
if(tulis.fail())
{
return(1);
}
for(int k=0; k<10; k++)
{
tulis<<k<<endl;
}
cout<<"File biner berhasil ditulis"<<endl;
tulis.close();
}
keluaran:
File biner berhasil ditulis
Untuk membaca file biner, harus digunakan mode pembukaan biner juga. Program cinput_file.cpp dapat
dimodifikasi secara mudah untuk membaca file biner dengan menambahkan mode ios::binary pada
metode open. Program secara lengkap adalah sebagai berikut.
// nama program: cinput_biner.cpp

// memberi contoh membaca data dari file biner
#include<fstream>
#include<iostream>
int main()
{
int x;
ifstream baca;
baca.open("data.bin", ios::binary);
if(baca.fail())
{
140

return(1);
}
baca>>x;
while(!baca.eof())
{
cout<<x<<endl;
baca>>x;
}
baca.close();
}
keluaran:
Isi file :
0
1
2
3
4
5
6
7
8
9
Perhatikanlah ukuran file yang terjadi, dan bedakan dengan file teks. File data.txt dan file data.bin
berbeda dalam ukuran file meskipun menyimpan data yang sama. Perbedaan ini dapat dilihat dengan
perintah dir pada prompt.
1. Menurut anda cin dan cout merupakan fungsi, kelas atau objek.
2. Pada bahasan tentang stream, ada kelas yang namanya streambuf yang menurunkan kelas filebuf.
Carilah informasi tentang kedua kelas tersebut.
3. Metode apa saja yang ada dalam kelas streambuf dan filebuf?
4. Berikut ini adalah petikan program yang berhubungan dengan stream file. Apa maksud program ini?
Untuk keperluan apa program ini?
#include <fstream>
#define CTRL_Z 26;
main()
{
ofstream tulis;
tulis.open("data.txt");
char c;
while (c!=CTRL_Z)
{
cin.get(c);
if (cin.fail())
break;
tulis<<c;
}
tulis.close();
}
141
5. Bagaimana menyalin isi suatu file, kemudian dipindakan pada file lain? Buat implementasi
programnya.
142
XII. STRING
String dalam bahasa C++ merupakan suatu kelas yang berkaitan dengan larik karakter dilengkapi
dengan metode-metode yang berguna untuk mengelola dan mengoperasikannya. Jadi dalam bahasa C+
+, string merupakan suatu kelas yang didalamnya terdapat metode-metode yang berhubungan dengan
string. String dalam bahasa C++ tidak diakhiri dengan karakter NULL.
Beberapa metode dasar dalam kelas string meliputi:
 size() : menghitung ukuran string
 capacity() : menghitung kapasitas string
 reserve() : menentukan besarnya kapasitas string
Untuk menjelaskan ketiga metode tersebut perhatikan program berikut ini.
// nama program: cdasar_str.cpp

// contoh penggunaan metode dasar string
#include<iostream>
#include<string>
main()
{
string st1("Pemrograman Berorientasi Objek");
cout<<"String semula :"<<endl
<<"Ukuran string = "<<st1.size()<<endl
<<"Kapasitas string = "<<st1.capacity()<<endl;
st1.reserve(100);
cout<<"Setelah perintah reserve:"<<endl
<<"Ukuran string = "<<st1.size()<<endl
<<"Kapasitas string = "<<st1.capacity()<<endl;
}
keluaran:
String semula :
Ukuran string = 30
Kapasitas string = 30
Setelah perintah reserve:
Ukuran string = 30
Kapasitas string = 100
Hasil keluaran program dapat dilihat perbedaan metode size() dan capacity() serta penggunaan metode
reserve() untuk mengatur kapasitas string.
Operasi yang dapat dilakukan terhadap string meliputi penambahan (append), penyisipan (insert),
penggantian (replace) dan penggabungan (concat). Operasi-operasi tersebut didukung oleh tiga metode
dan satu operator overload yaitu:
 append() : penambahan pada objek string dan ditempatkan pada bagian belakang objek string.
 insert() : penyisipan pada objek string pada bagian tengah.
 replace() : penggantian pada objek string yaitu mengganti sebagian isi suatu objek string.
 + : operator overload + penggabungan antara objek string yang satu dengan yang lainnya.
Berikut ini diberikan contoh program operasi-operasi yang dapat dilakukan pada string.
// nama program: coperasi_str.cpp

// contoh operasi pada string
#include<iostream>
#include<string>
143
main()
{
string st1(" Pemrograman ");
string st2(" Objek ");
cout<<"st1 semula :"<<st1<<endl;
st1.append(st2);
cout<<"st1 menjadi = "<<st1<<endl;
st1.insert(13,"berorientasi");
cout<<"st1 setelah disisipi = "<<st1<<endl;
st1 = st1 + "Dengan Bahasa C++";
cout<<"st1 terakhir = "<<st1<<endl;
}
keluaran:
st1 semula : Pemrograman
st1 menjadi = Pemrograman Objek
st1 setelah disisipi = Pemrograman berorientasi Objek
st1 terakhir = Pemrograman berorientasi Objek Dengan Bahasa C++
Mula-mula diciptakan dua objek string yaitu st1 dan st2. Kemudian objek st2 ditambahkan pada bagian
belakang st1 dengan metode append(). Selanjutnya objek st1 disisipi suatu string pada indeks ke 13.
Dan terakhir digabung dengan string baru menggunakan operator overload +.
Setelah operasi pada string, berikut dibicarakan operasi pencarian yang dilakukan pada string. Untuk
operasi pencarian didukung oleh beberapa metode antara lain
 find() : pencarian terhadap suatu karakter dalam string. Jika ketemu, maka akan memberikan nilai
balik posisi karakter, jika tidak akan memberikan nilai balik –1 tanda pencarian gagal
 find_first_of() : pencarian posisi suatu string dalam string dan memberikan nilai balik posisi pertama
yang ditemukan.
 find_last_of() : pencarian posisi string dan memberikan nilai balik berupa posisi terakhir string.
 rfind() : pencarian posisi karakter dimulai dari akhir string.
Berikut ini diberikan contoh penggunaan metode-metode di atas.
// nama program: csearch_str.cpp

// contoh pencarian pada string
#include<iostream>
#include<string>
main()
{
string st1("Pemrograman Menggunakan Bahasa C++");
cout<<"string = "<<st1<<endl;
int pos = st1.find('g');
cout<<"posisi g = "<<pos<<endl;
pos = st1.find_first_of(“an”);
cout<<"posisi an paling depan = "<<pos<<endl;
pos = st1.find_last_of(“an”);
cout<<"posisi an paling belakang = "<<pos<<endl;
pos = st1.rfind('g');
cout<<"posisi g dari belakang = "<<pos<<endl;
}
keluaran:
string = Pemrograman Menggunakan Bahasa C++
posisi g = 5
posisi an paling depan = 7
posisi an paling belakang = 29
144
posisi g dari belakang = 16
Pada program di atas diberikan contoh operasi pencarian pada suatu string. Mula-mula dicari posisi
karakter ‘g’ dari depan, hasilnya 5. Kemudian dicari posisi string “an” yang pertama kali ditemukan,
hasilnya 7. Selanjutnya dicari posisi string “an” untuk posisi paling belakang, hasilnya 27. Perintah
terakhir mencari posisi karakter ‘g’ dengan cara merunut dari belakang dan menghasilkan nilai 16. Masih
ada beberapa metode pencarian yang lain yang berhubungan dengan kelas string.
1. Berilah contoh penggunaan metode replace() dalam program lengkap.

2. Carilah dua metode lain tentang pencarian suatu string.
3. Carilah informasi, apa guna metode resize(), reverse() dan swap();
4. Bagaimana contoh penggunaan ketiga metode tersebut.
5. Dari contoh-contoh program pada bab ini, kira-kira operator apa saja yang dioverload untuk
kebutuhan operasi string.
6. Carilah informasi, metode lain anggota kelas string.
145
XIII. TEMPLATE
Kadang-kadang dalam pemrograman, diinginkan untuk menggunakan suatu algoritma yang sudah ada
tetapi digunakan untuk tipe data yang berbeda. Suatu ketika, pemrogram sudah membuat suatu fungsi
untuk tipe data tertentu, kemudian pemrogram menginginkan algoritma yang sama untuk tipe data yang
lain. Berikut ini contoh kasus yang berhubungan dengan masalah tersebut.
Fungsi pertukaran nilai yang pernah diterapkan pada fungsi tukar() yang menukarkan nilai bertipe int,
mungkin diinginkan untuk menggunakan algoritma tersebut untuk menukarkan nilai bertipe char atau
bahkan bertipe class.
Algoritma bubble-sort yang pernah diterapkan pada fungsi bubble() untuk mengurutkan suatu larik int,
mungkin diinginkan untuk menggunakan algoritma tersebut untuk larik char, atau diterapkan untuk larik
class.
Algoritma pencarian yang semula diterapkan untuk data larik int, mungkin diinginkan juga digunakan
untuk data yang berupa larik class.
Contoh-contoh di atas menggambarkan keinginan untuk menggunakan kode program yang sama untuk
beberapa tipe yang berbeda. Untuk keperluan seperti yang diuraikan di atas, bahasa C++ menyediakan
template. Dengan template, suatu fungsi dapat digunakan untuk beberapa tipe data yang berbeda.
Template adalah cara membuat suatu fungsi supaya dapat digunakan untuk beberapa tipe data yang
berbeda. Template memungkinkan pemrogram untuk menulis satu kode program dengan menerapkan
banyak tipe. Prinsipnya template adalah kemampuan untuk menggunakan kembali suatu kode program.
Ada dua macam template yaitu: fungsi template (template function) dan kelas template (template class).
A. Fungsi Template
Fungsi template adalah template yang diterapkan untuk fungsi, yang mana kode-kode fungsi digunakan
untuk beberapa tipe data yang berbeda. Template fungsi menggambarkan sebuah kumpulan fungsi
sejenis yang hanya dibedakan oleh tipe argumen dan nilai balik. Definisi fungsi template sangat mirip
dengan definisi fungsi biasa, hanya saja tipe parameter diberi nama secara simbolik. Deklarasi fungsi
template mempunyai bentuk sebagai berikut.
template<class simbol>simbol fungsi<simbol parameter>
Untuk memberikan gambaran penggunaan deklarasi tersebut, perhatikan contoh-contoh penerapan

fungsi template berikut ini.
template <class T> void tukar(T &data1, T &data2)

{
T temp;
temp = data1;
data1 = data2;
data2 = temp;
}
template <class Tp>Tp besar(Tp data1, Tp data2)

{
if(data1>data2)
return(data1);
else
return(data2);
}
template <class TT>TT pangkat2(TT data)

{
146
return(data*data);
}
Dari ketiga macam fungsi template tersebut, tidak seluruhnya dapat diterapkan pada seluruh tipe data.
Misalnya fungsi tukar() dan besar() dapat diterapkan untuk tipe numerik (int, float, double), char atau
kelas. Fungsi pangkat2() hanya dapat digunakan untuk tipe numerik dan kelas. Tentu saja penerapan
kelas pada fungsi tersebut harus memperhitungkan kemungkinan operasi yang akan dilakukan pada
kelas.
Untuk memberi gambaran lengkap tentang penggunaan fungsi template di atas, diberikan contoh
// nama program: ctemplate_tipe.cpp

// penerapan fungsi template pada tipe sederhana
#include<iostream>
{
T temp;
temp = data1;
data1 = data2;
data2 = temp;
}
template <class Tp>Tp besar(Tp &data1, Tp &data2)
{
if(data1>data2)
return(data1);
else
return(data2);
}
template <class TT>TT pangkat2(TT data)
{
return(data*data);
}
main()
{
char k1='A', k2='S';
int int1=53, int2=25;
cout<<"mula-mula : k1 = "<<k1
<<" & k2 = "<<k2<<endl;
tukar(k1, k2);
cout<<"sekarang : k1 = "<<k1
<<" & k2 = "<<k2<<endl<<endl;
cout<<"mula-mula : int1 = "<<int1
<<" & int2 = "<<int2<<endl;
tukar(int1, int2);
cout<<"sekarang : int1 = "<<int1
<<" & int2 = "<<int2<<endl<<endl;
cout<<"Nilai terbesar dari k1 & k2 = "
<<besar(k1,k2)<<endl;
cout<<"Nilai terbesar dari int1 & int2 = "
<<besar(int1,int2)<<endl;
cout<<"nilai int1 pangkat 2 = "
<<pangkat2(int1)<<endl;
}
keluaran:
mula-mula : k1 = A & k2 = S
sekarang : k1 = S & k2 = A
147
mula-mula : int1 = 53 & int2 = 25

sekarang : int1 = 25 & int2 = 53
Nilai terbesar dari k1 & k2 = S

Nilai terbesar dari int1 & int2 = 53
nilai int1 pangkat 2 = 625
Perhatikan dalam fungsi main() program di atas, fungsi tukar() dan besar() digunakan untuk diterapkan
untuk dua macam tipe yang berbeda yaitu int dan char. Hasil yang diperoleh untuk variabel numeris
sesuai dengan hitungan. Sedangkan untuk tipe char sesuai dengan urutan pada tabel ASCII. Khusus
untuk fungsi pangkat2() hanya digunakan untuk tipe numeris karena didalamnya terdapat operasi
perkalian.
Mula-mula dideklarasikan variabel k1 dan k2 bertipe char dan variabel int1 dan int2 bertipe int. Kemudian
diberikan perintah
tukar(k1, k2);
yang maksudnya menerapkan fungsi tukar() pada tipe char. Kemudian diberikan perintah
tukar(int1, int2);
yang maksudnya menerapkan fungsi tukar() pada tipe int. Di sini diterapkan fungsi template tukar() untuk
tipe char dan int.
Selanjutnya fungsi besar() digunakan untuk menerapkan dua tipe variabel yang berbeda juga. Dengan
perintah
cout<<"Nilai terbesar dari k1 & k2 = "

<<besar(k1,k2)<<endl;
berarti fungsi besar() diterapkan untuk tipe char, sedangkan perintah
cout<<"Nilai terbesar dari int1 & int2 = "

<<besar(int1,int2)<<endl;
berarti menerapkan fungsi pangkat untuk tipe int. Pada bagian akhir fungsi pangkat hanya diterapkan
pada tipe int
cout<<"nilai int1 pangkat 2 = "

<<pangkat2(int1)<<endl;
Sebetulnya dapat dicoba juga penerapan fungsi pangkat untuk tipe numeris yang lain.
Bagaimana halnya jika tipe yang digunakan bukan tipe sederhana, misalnya kelas? Berikut ini diberikan
contoh penggunaan fungsi tukar() untuk tipe kelas. Kelas yang akan digunakan adalah kelas siswa, tetapi
sedikit dimodifikasi menggunakan tipe kelas string untuk data anggota nama.
// nama program: ctemplate_tipe2.cpp

// contoh penerapan fungsi template pada tipe kelas
#include<iostream>
#include<string>
class siswa
{
int nilai;
148
string nama;
public:
siswa()
{
nilai=0;
nama="";
}
siswa(int ni, string sw)
{
nilai=ni;
nama=sw;
}
siswa(siswa &sw)
{
nilai=sw.nilai;
nama=sw.nama;
}
friend ostream &operator<<(ostream &sw_out,
siswa &sw);
};
ostream &operator<<(ostream &sw_out, siswa &sw)
{
sw_out<<"nilai = "<<sw.nilai
<<" nama = "<<sw.nama;
return(sw_out);
}
{
T temp;
temp = data1;
data1 = data2;
data2 = temp;
}
main()
{
int int1=253, int2=625;
siswa sw1(95,"Ilham"), sw2(97,"Ismah");
cout<<"mula-mula : "<<endl
<<"int1 = "<<int1
<<" int2 = "<<int2<<endl;
tukar(int1, int2);
cout<<"sekarang : "<<endl
<<"int1 = "<<int1
<<" int2 = "<<int2<<endl<<endl;
cout<<"mula-mula : "<<endl
<<"sw1 : "<<sw1<<endl
<<"sw2 : "<<sw2<<endl;
tukar(sw1, sw2);
cout<<"sekarang : "<<endl
<<"sw1 : "<<sw1<<endl
<<"sw2 : "<<sw2<<endl<<endl;
}
keluaran:
mula-mula :
int1 = 253 int2 = 625
sekarang :
int1 = 625 int2 = 253
149
mula-mula :
sw1 : nilai = 95 nama = Ilham
sw2 : nilai = 97 nama = Ismah
sekarang :
sw1 : nilai = 97 nama = Ismah
sw2 : nilai = 95 nama = Ilham
Pada program di atas, fungsi template digunakan untuk tipe int dan class. Fungsi yang diambil sebagai
contoh adalah fungsi tukar(), sehingga fungsi ini digunakan untuk menukarkan tipe int dan tipe kelas.
Mula-mula dideklarasikan dua variabel int1 dan int2 yang bertipe int dan dua objek sw1 dan sw2 bertipe
kelas siswa. Kemudian diberikan perintah
tukar(int1, int2);
yang maksudnya menukarkan nilai int1 dan int2 yang bertipe int. Kemudian diberikan perintah yang mirip
perintah di atas yaitu
tukar(sw1, sw2);
yang maksudnya menukarkan objek sw1 dan sw2. Di sini diterapkan satu fungsi yang sama yaitu tukar()
untuk menukarkan dua tipe yang berbeda.
Untuk mempermudah tampilan dan menyederhanakan kelas siswa, didefinisikan operator overload untuk
operator << sehingga untuk menampilkan isi objek sw1 dan sw2 cukup menggunakan perintah cout.
2. Kelas Template
Kelas template adalah template yang diterapkan pada kelas yang mana menggambarkan kumpulan kelas
yang hanya dibedakan oleh tipenya seperti tipe numeris dan char, pointer atau kombinasinya. Deklarasi
kelas template adalah sebagai berikut
template <class simbol> class nama_kelas
Untuk memberi gambaran bagaimana kelas template diterapkan perhatikan contoh berikut yang masih
berbicara tentang kelas siswa yang ada pada program sebelumnya. Tentu saja beberapa bagian diubah
sesuai dengan deklarasi kelas template.
// nama program: ctemplate_kelas.cpp

// contoh penerapan kelas template
#include<iostream>
template <class T> class siswa
{
char nama[30];
T nilai;
public:
siswa()
{
nilai=0;
strcpy(nama,"");
}
siswa(T ni, char *sw)
{
150
nilai=ni;
strcpy(nama,sw);
}
siswa(siswa<T> &sw)
{
nilai=sw.nilai;
strcpy(nama,sw.nama);
}
friend ostream &operator<<(ostream &sw_out,
siswa<T> &sw);
};
template <class T>
ostream &operator<<(ostream &sw_out, siswa<T> &sw)
{
sw_out<<"nama = "<<sw.nama
<<" nilai = "<<sw.nilai;
return(sw_out);
}
main()
{
int nilai_int = 97;
double nilai_double = 97.87;
char nilai_char = 'A';
siswa<int> sw1(nilai_int,"Ilham");
siswa<double> sw2(nilai_double,"Ismah");
siswa<char> sw3(nilai_char,"Hanif");
cout<<"Data siswa : "<<endl
<<"sw1 : "<<sw1<<endl
<<"sw2 : "<<sw2<<endl
<<"sw3 : "<<sw3<<endl;
}
keluaran:
Data siswa :
Data siswa :
sw1 : nama = Ilham nilai = 97
sw2 : nama = Ismah nilai = 97.87
sw3 : nama = Hanif nilai = A
Contoh program di atas memberi gambaran bagaimana kelas template menangani tiga tipe data yang
berbeda. Dalam hal ini yang dibedakan adalah data anggota nilai, yang mana dapat diberi nilai bertipe int,
double atau char. Mula-mula dideklarasikan tiga variabel yang tipenya berbeda yaitu nilai_int, nilai_double
dan nilai_char. Kemudian diberi pernyataan-pernyataan berikut
siswa<int> sw1(nilai_int,"Ilham");
siswa<double> sw2(nilai_double,"Ismah");
siswa<char> sw3(nilai_char,"Hanif");
Pernyataan-pernyataan tersebut digunakan untuk menciptakan objek sw1, sw2 dan sw3. Objek sw1 akan
memiliki data anggota nilai bertipe int, objek sw2 akan memiliki data anggota nilai bertipe double
sedangkan objek sw3 akan memiliki data anggota nilai bertipe char.
Untuk menampilkan hasil keluaran program, digunakan operator overload untuk operator << supaya
memudahkan dalam menampilkan keluaran. Perhatikan bagaimana membuat fungsi template yang
dijadikan fungsi teman pada kelas siswa. Deklarasi teman untuk operator << program di atas hanya
dapat dijalankan pada platform Windows. Untuk platform Linux, deklarasi teman untuk operator << agak
sedikit berbeda. Supaya dapat dijalankan pada platform Linux, gantilah deklarasi operator overload untuk
operator << menjadi sebagai berikut.
151
friend ostream &operator<< <T> (ostream &sw_out,

siswa<T> &sw);
Jangan lupa tambahkan pernyataan berikut
sejajar dengan pengarah kompiler. Selanjutnya cara mendefinisikan operator overload untuk operator <<
adalah seperti mendefinisikan fungsi template yang sudah dibahas sebelumnya.
1. Buatlah program lain yang melibatkan fungsi template

2. Buatlah juga program lain yang melibatkan kelas template
3. Buatlah operator overload untuk operator >> pada program ctemplate_kelas.cpp
4. Perhatikan deklarasi kelas berikut
class pesawat
{
char nama_ pesawat [30];
int kecepatan;
public:
pesawat();
pesawat(int kecept, char *kd);
int duakali(int kecept);
};
5. Jika diinginkan kecepatan dapat dinyatakan secara numeris dan karakter, bagaimana kelas template
yang terjadi
6. Bagaimana definisi konstruktor pesawat()
7. Bagaimana definisi metode duakali() jika metode ini memberi nilai balik dua kali kecepatan.
152
XIV. KONTAINER DAN ITERATOR

Kontainer (container) adalah simpanan berupa objek yang dapat digunakan untuk menyimpan elemen.
Elemen suatu kontainer dapat berupa tipe data sederhana maupun objek lain baik berupa tipe statis
maupun tipe dinamis. Kontainer merupakan implementasi dari template yang sudah menjadi pustaka
template standar (STL = standard template library) bahasa C++. Sesuai dengan namanya, kontainer
dapat menampung isi apa saja dan dapat dikembangkan jika isinya semakin besar.
Semua kontainer mendukung operator-operator sebagai berikut.
 operator overload untuk operator penugasan.
 operator overload untuk operator kesamaan (==) dan ketidaksamaan (!=).
 operator overload untuk operator-operator logika yaitu: <, <=, >, dan >=.
Pada paragraf sebelumnya diuraikan bahwa objek dapat menjadi elemen suatu kontainer. Supaya objek
dapat menjadi elemen suatu kontainer, deklarasi kelas paling sedikit harus mendukung beberapa hal
berikut.
 konstruktor default untuk menentukan nilai default.
 operator overload untuk operator kesamaan (==).
 operator overload untuk operator lebih-kecil (<).
Kontainer yang sering digunakan dalam pemrograman, biasanya sudah didefinisikan dalam bahasa C++.
Ada beberapa macam kontainer yang dibakukan dengan STL antara lain yaitu:
 kontainer pair,
 kontainer vector ,
 kontainer list,
 kontainer queue,
 kontainer deque,
 kontainer map,
 kontainer set, dan
 kontainer stack.
Untuk mengakses elemen suatu kontainer biasanya digunakan iterator. Iterator adalah abstraksi dari
pointer yang dapat dihasilkan kontainer untuk mengakses elemen yang ada pada kontainer. Kontainer
biasanya mendefinisikan iterator dengan menggunakan metode begin() dan end(). Dalam hal ini iterator
yang dihasilkan berupa iterator urutan maju (bertipe iterator). Kontainer dapat juga mendefinisikan
iterator untuk urutan balik (bertipe reversed_iterator) menggunakan metode rbegin() dan rend().
Pembahasan tentang iterator sangat erat hubungannya dengan kontainer. Dalam buku ini belum dibahas
masalah kontainer dan iterator secara mendalam, hanya akan diberikan pengantarnya. Jika pembaca
berminat mendalami masalah kontainer dan iterator, maka dipersilakan membaca beberapa acuan yang
dipakai oleh penulis.
A. Kontainer pair
Sesuai dengan namanya, kontainer pair (pasangan) adalah kontainer yang hanya dapat menyimpan
sepasang elemen atau dua elemen. Masing-masing elemen kontainer pair disebut first (pertama) dan
second (kedua). Kontainer pair sebetulnya bukan kelas tetapi merupakan struktur. Kedua elemen pada
dasarnya merupakan data anggota struktur pair. Supaya dapat menggunakan kontainer pair, harus
disertakan pengarah kompiler
#include<utility>
153
Deklarasi kontainer pair adalah sebagai berikut.
pair<tipe_first, tipe_second> nama_pair;
Dalam kontainer pair terdapat dua tipe yaitu tipe_first untuk data anggota first dan tipe_second untuk
data anggota second. Tipe data anggota yang digunakan dapat apa saja asalkan memenuhi syarat yang
telah ditetapkan sebagai anggota kontainer. Tipe untuk tipe_first dan tipe_second dapat sama dapat juga
berbeda. Sebagai contoh perhatikan contoh program penggunaan kontainer pair di bawah ini.
// nama program: cpair.cpp

// contoh program tentang kontainer pair
#include<utility>
#include<string>
#include<iostream>
typedef pair<int, string> tpair1;
typedef pair<string, char> tpair2;
main()
{
tpair1 siswa(22105,"Ilham");
tpair2 nilai("matematika", 'A');
<<"nomor = "<<siswa.first<<endl
<<"nama = "<<siswa.second<<endl<<endl;
cout<<"Data Nilai :"<<endl
<<"pelajaran = "<<nilai.first<<endl
<<"nilai = "<<nilai.second<<endl;
}
keluaran:
Data Siswa :
nomor = 22105
nama = Ilham
Data Nilai :
pelajaran = matematika
nilai = A
Pada program di atas terdapat dua deklarasi pair yaitu untuk pair1 dan pair2 yang masing-masing untuk
menyimpan data siswa dan nilai. Tipe first dan second pada kedua pair berbeda, untuk pai1 bertipe int
dan string, sedangkan untuk pair2 bertipe string dan char. Perhatikan cara menampilkan isi dari kontainer
pair. Untuk mengakses kontainer pair, satu-satunya jalan adalah menggunakan data anggota first dan
second
2. Kontainer vector
Kontainer vector (vektor) merupakan penerapan template yang digunakan untuk membuat generalisasi
tipe data larik. Secara kebetulan vektor memang dekat dengan larik karena adanya sistem indeks, tetapi
punya kemampuan berkembang secara dinamis. Indeks vektor dimulai dari 0 sampai nilai yang
ditunjukkan dengan ukuran. Supaya dapat menggunakan vektor, pada program harus disertakan
pengarah kompiler
#include<vector>
Untuk mendeklarasi kontainer vektor digunakan sintaksis sebagai berikut.
154
vector <tipe> nama_vektor;

vector <tipe> nama_vektor(ukuran)
vector <tipe> nama_vektor(ukuran, nilai)
Tipe menunjukkan tipe elemen yang disimpan dalam vektor, ukuran merupakan jumlah elemen yang
dapat disimpan dalam vektor, sedangkan nilai adalah isi dari vektor sesuai tipe yang diberikan. Pada
deklarasi pertama tidak ditentukan ukuran vektor, pada deklarasi kedua dan ketiga ditentukan ukuran
vektor sebesar nilai ukuran, sedangkan pada deklarasi ketiga ditambah pemberian nilai awal pada
seluruh elemen vektor sebesar nilai. Untuk menjelaskan penggunaan kontainer vektor, perhatikan contoh
// nama program: cvector.cpp

// contoh penggunaan kontainer vector
#include<iostream>
#include<vector>
#include<string>
typedef vector<string> tvector;
main()
{
tvector v1(3);
tvector v2(5);
v1[0]="pertama";
v1[1]="kedua";
v1[2]="ketiga";
v2[0]="SATU";
v2[1]="DUA";
v2[2]="TIGA";
v2[3]="EMPAT";
v2[4]="LIMA";
tvector::iterator iter;
cout<<endl<<"v1 semula :";
for(iter=v1.begin();iter!=v1.end();iter++)
{
cout<<*iter<<", ";
}
cout<<endl<<"v2 semula :";
{
cout<<*iter<<", ";
}
v1.swap(v2);
cout<<endl<<endl<<"v1 sekarang :";
{
cout<<*iter<<", ";
}
cout<<endl<<"v2 sekarang :";
{
cout<<*iter<<", ";
}
cout<<endl;
}
keluaran:
v1 semula :pertama, kedua, ketiga,
155
v2 semula :SATU, DUA, TIGA, EMPAT, LIMA,
v1 sekarang :SATU, DUA, TIGA, EMPAT, LIMA,

v2 sekarang :pertama, kedua, ketiga,
Pada program di atas dideklarasikan dua vektor yaitu v1 dan v2 masing-masing berukuran 3 dan 5.
Kedua vektor berisi data yang bertipe string. Vektor v1 diberi nilai string “SATU”, “DUA”,” TIGA”,
“EMPAT”, dan “LIMA”, sedangkan vektor v2 diberi nilai string “pertama”, “kedua”, dan “ketiga”. Perhatikan
cara menampilkan isi vektor v1 dan v2 menggunakan iterator iter dan perhatikan pula cara menciptakan
iterator tersebut. Iterator tersebut digunakan untuk menampilkan isi vektor. Cara ini bukan satu-satunya
cara yang dapat digunakan.
Selanjutnya antara vektor v1 dan v2 ditukarkan menggunakan metode swap(). Setelah itu kedua vektor
ditampilkan kembali, dan hasilnya terlihat kedua vektor bertukar isinya. Dengan kontainer vektor,
penanganan data berindeks menjadi lebih mudah.
3. Kontainer list
Kontainer list (senarai) adalah aplikasi template untuk mengimplementasikan struktur data list. Pada
struktur data ada beberapa macam list. List yang diterapkan di sini adalah double-linked list. Operasi
yang dapat dilakukan pada list dapat berupa penambahan dan penghapusan data baik di depan, tengah
atau belakang. Semua fungsi untuk operasi list disediakan dalam bentuk metode pada kontainer list.
Kontainer list dapat mendukung iterator dua arah. Supaya dapat menggunakan kontainer list harus
disertakan pengarah kompiler
#include<list>
Untuk mendeklarasikan kontainer list digunakan sintaksis berikut.
list<tipe> nama_list;
Sebetulnya ada beberapa cara mendeklarasikan kontainer list, deklarasi di atas hanya salah satunya. Isi
dari list yang dideklarasikan mempunyai tipe seperti yang tercantum pada tipe.
Untuk memberi gambaran tentang kontainer list, berikut ini diberikan contoh penggunaan kontainer list.
// nama program: clist.cpp

// contoh penggunaan kontainer list
#include<iostream>
#include<list>
#include<string>
typedef list<string> tlist;
main()
{
tlist l;
tlist::iterator iter;
l.push_back("kedua");
cout<<endl<<"list semula :";
for(iter=l.begin();iter!=l.end();iter++)
{
cout<<*iter<<", ";
}
cout<<endl<<"list sekarang :";
l.push_front("pertama");
for(iter=l.begin();iter!=l.end();iter++)
156
{
cout<<*iter<<", ";
}
cout<<endl;
}
keluaran:
list semula :kedua,
list sekarang :pertama, kedua,
Pada program di atas dideklarasikan kontainer list yang berisi data bertipe string. Mula-mula kontainer list
diisi dengan string “kedua” dengan metode push_back(). Kemudian isi list ditampilkan dengan bantuan
iterator iter. Selanjutnya kontainer list diisi kembali dengan data string “pertama” pada bagian depan
dengan metode push_front(). Kemudian hasilnya ditampilkan kembali. Metode lain yang berhubungan
dengan kontainer list masih cukup banyak. Di sini hanya dicontohkan metode push_back() dan
push_front() saja.
4. Kontainer queue
Kontainer queue (antrian) merupakan implementasi template untuk struktur data queue. Pada queue,
data yang pertama kali masuk akan keluar pertama kali. Data yang masuk akan menempati bagian
paling belakang dan data tersebut baru dapat keluar jika data didepannya sudah keluar. Supaya dapat
menggunakan kontainer queue harus disertakan pengarah kompiler berikut.
#include<queue>
Untuk mendeklarasikan kontainer queue digunakan sintaksis berikut.
queue<tipe, kontainer<tipe> > nama_queue;
Kontainer queue dapat berisi tipe data apa saja, baik berupa tipe data sederhana sampai kelas.
Kontainer queue dapat menyadur kontainer lain yang mendukung metode front(), back(), push_back()
and pop_front() yang biasanya berupa kontainer list dan deque. Berikut ini diberikan contoh program
untuk mengimplementasikan kontainer queue.
// nama program: cqueue.cpp

// contoh penggunaan kontainer queue
#include<iostream>
#include<queue>
#include<list>
#include<string>
typedef queue<string, list<string> > tqueue;
main()
{
tqueue q;
q.push("APEL");
q.push("JERUK");
q.push("MANGGA");
cout<<"Isi elemen terdepan :"<<endl;
cout<<"sebelum pop = "<<q.front()<<endl;
q.pop();
cout<<"setelah pop pertama= "<<q.front()<<endl;
q.pop();
cout<<"setelah pop kedua = "<<q.front()<<endl;
157
keluaran:
Isi elemen terdepan :
sebelum pop = APEL
setelah pop pertama= JERUK
setelah pop kedua = MANGGA
Pada program di atas terdapat kontainer queue yang berisi data bertipe string. Kontainer ini menyadur
kontainer lain yaitu list. Mula-mula dilakukan operasi push pada queue sebanyak tiga kali untuk mengisi
queue dengan string “APEL”, “JERUK”, dan “MANGGA”. Setelah itu satu per satu dilakukan operasi pop
pada elemen queue yang dilanjutkan menampilkan elemen terdepan. Operasi pop pertama akan
mengambil elemen “APEL”, operasi pop kedua akan mengambil elemen “JERUK” dan seterusnya sesuai
urutan push.
5. Kontainer deque
Kontainer deque merupakan implementasi template untuk struktur data double ended deque. Pada
double ended deque, data dapat ditambahkan dari depan maupun dari belakang, demikian juga dapat
diambil dari depan dan dari belakang. Supaya dapat menggunakan kontainer deque harus disertakan
pengarah kompiler
#include<deque>
Untuk mendeklarasikan kontainer deque digunakan sintaksis berikut.
deque<tipe> nama_deque;
Maksud deklarasi tersebut adalah bahwa kontainer deque akan digunakan untuk menyimpan data bertipe
tipe. Berikut ini diberikan contoh program untuk mengimplementasikan kontainer deque.
// nama program: cdeque.cpp

// contoh penggunaan kontainer deque
#include<iostream>
#include<deque>
#include<string>
typedef deque<string> tdeque;
main()
{
tdeque d;
tdeque::iterator iter;
d.push_back("pertama");
d.push_back("kedua");
d.push_back("ketiga");
cout<<endl<<"deque semula : ";
for(iter=d.begin();iter!=d.end();iter++)
{
cout<<*iter<<", ";
}
d.push_front("NOL");
cout<<endl<<"deque sekarang : ";
for(iter=d.begin();iter!=d.end();iter++)
{
cout<<*iter<<", ";
158
}
cout<<endl;
}
keluaran:
deque semula : pertama, kedua, ketiga,
deque sekarang : NOL, pertama, kedua, ketiga,
Pada program tersebut terdapat deklarasi untuk membuat kontainer deque yang digunakan untuk
menyimpan data string. Mula-mula kontainer deque tersebut diisi dengan data string “pertama”, “kedua”
dan “ketiga” menggunakan metode push_back(). Selanjutnya isinya ditampilkan dengan bantuan iterator
iter. Perintah berikutnya adalah menambah isi dari depan dengan data string “NOL” menggunakan
metode push_front(). Langkah terakhir menampilkan kembali isi kontainer deque dengan bantuan
iterator.
6. Kontainer map
Kontainer map (peta) berisi pasangan kunci/nilai yang dapat berupa kontainer juga. Kunci digunakan
untuk menentukan lokasi informasi yang dimiliki kunci. Informasi yang dimiliki oleh kunci disebut nilai. Isi
dari kontainer map secara automatis diurutkan berdasarkan kunci. Supaya dapat menggunakan
kontainer map harus disertakan pengarah kompiler
#include<map>
Untuk mendeklarasikan kontainer map digunakan sintaksis berikut.
map<tipekunci, tipenilai, less<tipekunci> > nama_map;
Dengan deklarasi tersebut kunci akan mempunyai tipe tipekunci, sedangkan nilai akan mempunyai tipe
tipenilai. Berikut ini diberikan contoh program untuk mengimplementasikan kontainer map
// nama program: cmap.cpp

// contoh penggunaan kontainer map
#include<iostream>
#include<map>
#include<utility>
#include<string>
typedef map<string, int, less<string> > tmap;
typedef tmap::value_type vtype;
template<class First, class Second>
ostream& operator<<(ostream& out,const pair<First,Second> & p)
{
cout<<"warna : "<<p.first<<" kode : " <<p.second;
return out;
}
main()
{
tmap m;
tmap::iterator iter;
iter=m.begin();
m.insert(vtype(string("MERAH"),1));
m.insert(vtype(string("KUNING"),2));
m.insert(vtype(string("HIJAU"),3));
cout<<"map m semula : "<<endl;
159
for(iter=m.begin();iter!=m.end();iter++)
{
cout<<*iter<<endl;
}
iter=m.begin();
m.insert(vtype(string("BIRU"),0));
cout<<endl<<"map s sekarang : ";
cout<<endl;
for(iter=m.begin();iter!=m.end();iter++)
{
cout<<*iter<<endl;
}
cout<<endl;
}
keluaran:
map m semula :
warna : HIJAU kode : 3
warna : KUNING kode : 2
warna : MERAH kode : 1
map s sekarang :
warna : BIRU kode : 0
warna : HIJAU kode : 3
warna : KUNING kode : 2
warna : MERAH kode : 1
Program di atas menggambarkan penggunaan kontainer map. Pada program tersebut dideklarasikan
kontainer map dengan kunci bertipe string serta nilai bertipe int. Karena kontainer map bersifat
pasangan, isi kontainer ini tidak dapat ditampilkan menggunakan operator << bawaan. Pada program
tersebut dibuat operator overload << yang khusus menangani kontainer map tersebut. Perhatikan cara
membentuk operator overload tersebut. Untuk menampilkan isi kontainer map digunakan bantuan
kontainer pair karena isinya berupa pasangan. Isi kontainer map dilewatkan secara referensi melalui
kontainer pair. Selanjutnya ditampilkan elemen dari kontainer pair tersebut.
Pada saat ditampilkan, isi kontainer map sudah dalam keadaan urut. Urutan isi kontainer map berbeda
dibanding ketika isi dimasukkan. Urutan isi suatu kontainer map akan sesuai dengan urutan kunci.
Perhatikan urutan memasukkan data dan hasil yang ditampilkan.
7. Kontainer set
Kontainer set (himpunan) adalah implementasi template untuk himpunan terurut. Masing-masing nilai
hanya dapat disimpan satu kali dalam kontainer set. Jika ada yang sama, maka akan diambil salah satu
nilai. Dengan demikian, jika keliru memberi nilai kembar pada isi himpunan, maka akan diambil salah
satu yang berakibat jumlah data berkurang satu.
Supaya dapat menggunakan kontainer set, harus disertakan pengarah kompiler
#include<set>
Untuk mendeklarasikan kontainer set digunakan sintaksis berikut ini.
set<tipe, less<tipe> > nama_set;
Deklarasi set tersebut menunjukkan bahwa isi dari set nantinya berupa data bertipe tipe. Berikut ini
contoh program tentang penggunaan kontainer set.
160
// nama program: cset.cpp

// contoh penggunaan kontainer set
#include<set>
#include<string>
#include<iostream>
typedef set<string, less<string> > tset;
main()
{
tset s;
tset::iterator iter;
s.insert("MERAH");
s.insert("KUNING");
s.insert("HIJAU");
s.insert("ORANGE");
cout<<"set s semula: {";
for(iter=s.begin();iter!=s.end();iter++)
{
cout<<*iter<<", ";
}
cout<<"}"<<endl;
s.insert("BIRU");
cout<<"set s sekarang: {";
for(iter=s.begin();iter!=s.end();iter++)
{
cout<<*iter<<", ";
}
cout<<"}"<<endl;
}
keluaran:
set s semula: {HIJAU, KUNING, MERAH, ORANGE, }
set s sekarang: {BIRU, HIJAU, KUNING, MERAH, ORANGE, }
Kontainer set yang dideklarasikan pada program di atas digunakan untuk menyimpan data berbentuk
string. Mula-mula kontainer set diisi dengan data string “MERAH”, “KUNING”, “HIJAU” dan “ORANGE”.
Selanjutnya isi kontainer set ditampilkan dengan bantuan iterator iter. Dapat dilihat bahwa hasilnya
berupa isi yang urut abjad. Kemudian pada langkah selanjutnya disisipkan string baru yang diberi isi
“BIRU”, kemudian kontainer set ditampilkan kembali. Hasilnya kontainer set urut menurut abjad.
8. Kontainer stack
Kontainer stack (tumpukan) adalah implementasi template untuk struktur data stack. Kontainer stack
hanya dapat diisi dan diambil datanya dari satu sisi. Data yang masuk lebih dahulu akan paling belakang
keluarnya. Data paling pertama diisikan akan menempati tempat terdalam, sehingga untuk mengambil
data tersebut, data di atasnya harus dikeluarkan terlebih dahulu.
Supaya dapat menggunakan kontainer stack, harus disertakan pengarah kompiler
#include<stack>
Cara mendeklarasikan suatu stack dengan sintaksis berikut ini.
stack<tipe, kontainer<tipe> > nama_stack
161
Pada deklarasi tersebut dirancang agar stack yang bernama nama_stack dapat menyimpan data bertipe
tipe. Kontainer stack menyadur kontainer lain. Berikut ini diberikan contoh program tentang penggunaan
kontainer stack.
// nama program: cstack.cpp

// contoh penggunaan kontainer stack
#include<stack>
#include<vector>
#include<string>
#include<iostream>
typedef stack<string,vector<string> > tstack;
main()
{
tstack s;
s.push("APEL");
s.push("JERUK");
s.push("MANGGA");
cout<<"stack teratas : "<<endl;
cout<<"sebelum pop = "<< s.top() << endl;
s.pop();
cout<<"setelah pop pertama = "<< s.top() << endl;
s.pop();
cout<<"setelah pop kedua = "<< s.top() << endl;
}
keluaran:
stack teratas :
sebelum pop = MANGGA
setelah pop pertama = JERUK
setelah pop kedua = APEL
Pada program di atas dideklarasikan suatu kontainer stack yang dapat digunakan untuk menyimpan data
bertipe string. Mula-mula kontainer stack diisi dengan data string “APEL”, “JERUK”, dan “MANGGA”
sesuai urutan. Selanjutnya ditampilkan elemen teratas stack, hasilnya “MANGGA” yaitu data yang paling
akhir dimasukkan. Selanjutnya dilakukan operasi pengambilan data dengan perintah pop, kemudian
ditampilkan elemen paling atas, hasilnya adalah “JERUK”. Pengambilan data diulangi lagi, kemudian
ditampilkan elemen paling atas, hasilnya adalah “APEL”.
1. Ada lima macam iterator, carilah informasi macam-macam iterator tersebut.

2. Buatlah operator overload untuk operator << yang dapat digunakan untuk menampilkan seluruh isi
vektor yang terdapat pada program cvector.cpp
3. Bagaimana cara menyisipkan data pada kontainer list?
4. Hal yang sama, lakukan pada program clist.cpp untuk kontainer list.
5. Apa perbedaan kontainer queue dan stack. Berilah contoh kasus nyata kedua kontainer tersebut.
6. Masih ada beberapa kontainer lain yang belum dibahas dalam buku ini. Carilah informasinya.
162
DAFTAR PUSTAKA
Alavoor Vasudevan, 2002, C++ Programming HOW-TO, Linux Mandrake Documentation
ANSI, 1998, Programmning Languages C++, American National Standards Institute, first edition, New
York
Frank B. Brokken, 2001, C++ Annotations Version 5.1.1a, University of Groningen, Groningen
Ian Aitchison and Peter King, 1997, Introduction to C++ Programming, http://www.cee.hw.ac.uk/
Jesse Liberty, 1997, Teach Yourself C++ in 21 Days, Second Edition, Group SAMS, Indianapolis
163
Index
A fungsi anggota...................73, 75
alamat...............................58 Fungsi overload......................96
Ambiguous...........................118 fungsi standar.......................60
ANSI..................................9 fungsi template.....................146
ANSI C................................9 Fungsi template.....................146
antrian.............................157 G
ASCII................................51 g++..................................16
B GNU C.............................9, 15
base class..........................106 GNU C++..............................15
Bjarne Stroustrup.....................9 H
Borland C.............................9 hex..................................27
Borland C++.......................9, 13 himpunan............................160
Borland C++ Builder..................13 hirarki kelas.......................106
break................................42 Hubungan secara acuan................65
Brian Kernighan.......................9 Hubungan secara nilai................65
bubble-sort.................51, 66, 146 I
by reference.........................65 identifier...........................16
by value.............................65 if...................................28
C if bertumpuk.........................31
case sensitive.......................17 ifstream............................136
char.................................18 ikatan dinamis......................122
cin.................................129 information hidding..................76
class........................19, 71, 75 inheritance.........................106
close...............................137 insertion operator...................23
compiler directive...................11 int..................................18
constructor..........................81 int main()...........................12
container...........................153 Iterator............................153
continue.............................42 K
copy constructor.....................82 Kelas........................19, 71, 75
cout................................132 kelas dasar.........................106
D kelas template......................146
data anggota.........................75 Kelas template......................150
dec..................................27 kelas turunan.......................106
default constructor..................82 Kelas virtual.......................116
Dennis Ritchie........................9 Ken Thompson..........................9
deque...............................158 Konstanta............................20
derived class.......................106 konstruktor..........................81
destructor...........................83 konstruktor default..................82
destruktor...........................83 konstruktor penyalinan...............82
device..............................129 konstruktor penyalinan objek.........83
dinamic binding.....................122 Kontainer...........................153
do-while.............................36 kontainer deque.....................158
double...............................18 kontainer map.......................159
double ended deque..................158 kontainer pair......................153
double-linked list..................156 kontainer queue.....................157
E kontainer set.......................160
editor teks..........................15 Kontainer stack.....................161
encapsulation........................76 kontainer vektor....................154
exit.................................42 Kontaner list.......................156
extraction operator..................23 L
F laboratorium AT&T BELL................9
field................................71 larik................................18
Field................................55 Larik................................46
file biner..........................140 larik dua dimensi....................46
File header..........................60 larik satu dimensi...................46
file teks...........................140 larik tiga dimensi...................46
first...............................153 library..............................62
fixed................................25 list................................156
float................................18 M
for..................................39 main()...............................12
friend...............................92 manipulator..........................25
fungsi...............................60 map.................................159
164
menjadi GNU C++.......................9 Rekursi..............................67

metode...............................75 Reserved word........................17
metode virtual......................122 run-time............................122
Ms. C.................................9 S
Ms. C++...............................9 scientitic...........................25
multiple inheritance................106 second..............................153
N senarai.............................156
NULL.............................49, 50 set.................................160
O setiosflags..........................25
object copy constructor..............83 setprecision.........................25
object oriented programming...........9 setw.................................26
Objek................................79 showpoint............................25
objek dinamis........................80 single inheritance..................106
objek statis.........................80 sorting..........................51, 66
oct..................................27 stack...........................81, 161
ofstream............................136 STL.................................153
open................................136 strcpy...............................50
Operator.............................21 stream..............................129
operator ->..........................80 stream file.........................135
Operator aritmetika..................21 stream keluaran.....................136
operator biner......................100 stream masukan......................136
operator ekstraksi...................23 String..............................143
operator isersi......................24 struct...............................55
Operator logika......................21 struktur.............................71
operator overload...................100 Struktur.........................19, 55
Operator penaikan....................21 struktur cabang......................28
Operator penugasan...................23 struktur seleksi.....................28
Operator penugasan khusus............23 subprogram...........................60
Operator relasional..................22 subroutine...........................60
operator skope.......................73 switch...............................32
operator uner.......................100 T
P teman................................92
pair................................153 template............................146
Parameter............................64 template class......................146
parameter aktual.....................64 template function...................146
parameter formal.....................64 tipe data............................17
pasangan............................153 Tipe data terstruktur................46
pemrograman berorientasi objek....9, 71 tumpukan............................161
Pemrograman berorientasi objek........8 Turbo C...............................9
pengarah kompiler....................11 Turbo C++.........................9, 13
Pengenal.............................16 U
pengkapsulan.........................76 union................................18
penyembunyian informasi..............76 Union............................18, 57
perulangan...........................36 UNIX..................................9
peta................................159 using namespace std..................16
Pewarisan...........................106 V
pewarisan jamak.....................112 Variabel.............................19
Pewarisan jamak virtual.............115 variabel dinamis.....................89
pewarisan public....................107 Variabel eksternal...................63
Pewarisan tunggal...................107 Variabel lokal.......................63
pico.................................16 vector..............................154
Pointer..............................51 vektor..............................154
Polimorfisme........................122 virtual.............................116
polymorphism........................122 virtual multiple inheritance........107
pre-compiled.........................62 void.................................18
private..........................76, 92 void main()..........................12
protected............................92 W
public...........................76, 92 while................................38
pustaka..............................62 ‘
Q ‘\0’.............................49, 50
queue...............................157 #
R #include.............................11
165
PEMROGRAMAN BERORIENTASI OBJEK

(dengan C++ Windows dan Linux)
Pemrograman berorientasi objek bukanlah materi yang sulit untuk dipelajari. Dengan buku ini, penulis
berusaha menyajikan materi supaya dapat dipahami dan dipraktikkan secara mudah. Baik peminat yang
awam maupun yang baru tahu sedikit, diharapkan tetap dapat mengikuti uraian buku ini secara baik.
Buku ini berisi materi tentang pemrograman berorientasi objek serta penerapannya. Materi yang disajikan
meliputi: dasar pemrograman C++, enkapsulasi, penyembunyian data, pewarisan dan polimorfisme.
Selain itu dibahas materi yang sangat erat kaitannya dengan pemrograman berorientasi objek yang
meliputi string, stream serta template. Uraian lebih lanjut adalah penerapan template pada kontainer.
Kontainer merupakan penerapan beberapa konsep struktur data dalam pemrograman berorientasi objek.
Untuk membantu pemahaman pembaca tentang materi yang disajikan, diberikan banyak contoh program
beserta hasil keluarannya. Program dibuat dengan memperhatikan dua sistem operasi yang berkembang
saat ini yaitu Windows dan Linux. Program yang ada dalam buku ini sudah diuji dengan perangkat lunak
Borland C++ dan GNU C++. Baik pengguna sistem operasi Windows maupun Linux dapat menggunakan
buku ini sebagai pegangan.
166

OBJEK

Diunggah oleh

Informasi Dokumen

Deskripsi Asli:

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

OBJEK

Diunggah oleh

Hak Cipta:

Format Tersedia

Pemrograman Berorientasi Objek WAGITO

PEMROGRAMAN BERORIENTASI OBJEK

Tabel 1.Tipe Data Dasar.......................................................................................................................... 17

Gambar 1.Tampilan Awal Borland C++.................................................................................................. 13

Kuberikan buku ini

1. Pemrograman Berorientasi Objek Dengan C++

2. Perkembangan Bahasa C++

Pertanyaan dan Tugas

1. Sebutkan bahasa pemrograman yang anda ketahui

II. DASAR PEMROGRAMAN

// nama program: cpertama.cpp

yaitu menggunakan tanda kutip ganda.

Yang kedua yaitu:

Yang ketiga yaitu:

// nama program: ccontoh.cpp

2. Menuliskan Program Dalam Beberapa Versi C++

Gambar 1. Tampilan Awal Borland C++

2. Tulislah program di atas pada editor tersebut.

Borland C++ Builder

Gambar 2. Tampilan Awal C++ Builder

Gambar 3. Dialog Untuk New

Gambar 4. Editor C++ Builder

GNU C++ (Redhat 8.0, Mandrake 9.0, Slackware 9.0)

langkah program digunakan pico.

using namespace std;

// nama program: ccontoh1.cpp

2data --> tidak diijinkan

-keliling2 --> tidak diijinkan

Tabel 1. Tipe Data Dasar

1 char 1 byte -128 s/d 127 karakter

Tabel 2. Tipe Data Dengan Awalan

Tabel 3. Tipe Data Turunan

int data_nomor; //variabel data_nomor bertipe int

Program berikut memberi gambaran bagaimana menggunakan variabel.

// nama program: cvariabel.cpp

Misalkan saja untuk program di atas, pernyataan

dapat ditempatkan setelah pernyataan

tanpa mempengaruhi hasil program.

const nama_tipe nama_constanta = nilai_konstanta

Berikut ini contoh penggunaan konstanta dalam program

// nama program: ckonstanta.cpp

Tabel 4. Operator Aritmetika

Tabel 5. Operator Logika

Operator Penaikan dan Penurunan

k++ sama dengan k=k+1

pernyataan tersebut seperti menuliskan dua pernyataan

pernyataan tersebut seperti menuliskan dua pernyataan

Tabel 6. Operator Relasional

9. Operator Penugasan dan Penugasan Khusus

Tabel 7. Operator Penugasan Khusus

Khusus untuk bentuk x%=y, tipe x dan y harus int.

cout << daftar_keluaran

cout<<”belajar pemrograman C++”<<endl;

Sintaksis yang digunakan untuk perintah masukan adalah sebagai berikut.

cin >> daftar_masukan

cin>>nilai; //mengambil data nilai dari papan ketik

// nama program: csegitiga.cpp

cout<<”Masukkan nilai alas dan tinggi : ? ”;

masukkan nilai alas dan tinggi: ? 10 20

// nama program: cflags.cpp

// nama program: cpresisi.cpp

// nama program: csetw.cpp