Pembahasan Perbedaan Bahasa C & Bahasa C++
Kalau kita berbicara tentang Bahasa C++ biasanya tidak akan pernah lepas dari bahasa C, sebagai pendahulunya C adalah bahasa pemograman terstruktur yang standar sedangkan bahasa C++ adalah bahasa yang mendukung pemograman yang berorientasi obyek ( PBO / OOP/ Object Oriented Programming ) tetapi bahasa C++ hanyalah bahasa yang bersifat hybrid bukan bahasa murni yang berorientasi obyek. Perbedaan bahasa C & bahasa C++ adalah bahasa C sendiri adalah bahasa pemograman terstruktur yang mempunyai tujuan untuk mempermudah pembuatan dan pengembangan program sedangkan bahasa C++ bahasa pemograman yang berorientasi obyek ( Object Oriented Programming ) yang mempunyai tujuan untuk meningkatkan produktivitas pemogram dalam membuat aplikasi dan pada intinya C++ dapat meningkatkan produktivitas lebih dari dua kali dibandingkan dengan bahasa prosedural seperti bahasa C, Pascal, dan BASIC.
Bahasa C pertama kali diciptakan oleh Martin Richards pada tahun 1967 dan bahasa ini memberikan ide kepada Ken Thompson yang dikembangkan menjadi bahasa B pada tahun 1970 dan perkembangan selanjutnya adalah bahasa C yang dikembangkan oleh Denis Ricthie sekitar tahun 1970-an . Sedangkan bahasa C++ sendiri diciptakan satu decade setelah C, bahasa C++ diciptakan oleh Bjarne Stourstrup diLaboratorium Bell, AT&T pada tahun 1983 bahasa ini bersifat kompatibel.
Keistimewaan dari bahasa pemograman C++ adalah bahasa ini medukung pemograman yang berorientasi obyek oleh karena itu pemogram C pada tahap awal berpindah jalur ke program C++ secara bertahap.
Bab ini memperkenalkan pemograman dengan kelas dan obyek.
13.1 Analogi Struktur dan Kelas
Kelas merupakan struktur data dari obyek (obyek yang telah dibahas di awal buku ini yang merupakan elemen dasar pemograman berorientasi obyek). Untuk menjelaskan perbandingan kelas dengan struktur, mengingat:
- Struktur bermanfaat untuk mengelompokkan sejumlah data dengan tipe yang berlainan
- Struktur mempunyai persamaan dengan kelas
Contoh Program yang melibatkan struktur dapat dilihat dibawah ini:
// * kelas1.cpp *
// * *
// * contoh sebuah struktur *
// * yang akan digunakan sebagai perbandingan *
// * dengan kelas *
# include <>
# include
# include
struct buku
{
char judul [35];
char pengarang [25];
int Jumlah;
};
void main ( )
{
clrscr ( ); // hapus layer
buku novel; // pendefinisian variable
strcpy (novel.judul, “ Meriam Benteng Navarone”);
strcpy (novel.pengarang, “Alistair Maclean”);
novel.jumlah =12;
cout <<>
cout <<>
cout <<>
Hasil program :
C: \ CPP>kelas1
Meriam Benteng Navarone
Alistar Maclean
12
C: \ CPP>_
Pada contoh diatas terdapat struktur bernama buku yang didelarasikan sebagai berikut :
Struct buku
{
char judul [35];
char pengarang [25];
int Jumlah ;
};
Kelas yang menyerupai struktur diatas dapat dibuat dengan menggantikan kata struct dengan class seperti dibawah ini :
Class buku
{
char judul [35];
char pengarang [25];
int Jumlah;
};
Kelas diatas dapat dideklarasikan dan dipakai sebagai tipe data bagi penciptaan variable missal:
buku novel;
Pernyataan diatas digunakan untuk mendefinisikan variable bernama novel. Perlu diketahui pada bahasa C++ variable seperti novel biasa disebut : obyek
Class buku kata kunci class mengawali pendelarasian kelas
{
char judul [35];
char pengarang [25]; nama anggota data
int Jumlah; anggota data
}; deklarasi kelas diakhir dengan titik koma
buku novel; pendefinisian obyek
Kebanyakan pemogram C++ menggunakan nama kelas (missal buku pada contoh diatas ). Program berikut merupakan hasil modifikasi dari program.
Meskipun pada C++, struktur juga dapat digunakan seperti halnya kelas, kelas lebih umum dipakai dalam pemograman berorientasi obyek.
13. 2 Penggunaan Public
Program dapat dikompilas, kata kunci public diikuti dengan tanda titik dua ( : ) dan perlu ditambahkan diatas anggota data bernama judul.
class buku
{
public:
char judul [35];
char pengarang [25];
int Jumlah;
};
Baris yang berisi public diatas menyatakan bahwa yang ada dibawahnya bersifat public ( dapat diakses diluar kelas ). Contoh program yang telah dilengkapi public:
# include
# include
# include
class buku
{
public:
char judul [35];
char pengarang [25];
int Jumlah;
};
void main ( )
{
clrscr ( );
buku novel;
strcpy (novel.judul, “Meriam Benteng Navarone”);
strcpy (novel.pengarang, “Alistair Maclean”);
novel.jumlah =12;
cout <<>
cout <<>
cout <<>
}
Public pada kelas buku di depan biasa disebut sebagai penentu akses (access specifier).
13. 3 Penggunaan Private
Penentu akses private biasa digunakan pada kelas untuk memproteksi anggota-anggota tertentu, agar tidak dapat diakses diluar kelas secara langsung.
Penggunaan private dan public secara bersama-sama dalam sebuah kelas akan ditunjukkan belakangan .
Kata kunci private pada bentuk berikut:
Class buku
{
private:
char judul [35];
char pengarang [25];
int Jumlah;
};
dapat diganti menjadi:
class buku
{
char judul [35];
char pengarang [25];
int Jumlah;
};
default dari kelas adalah private
Private pada kelas dapat diibaratkan dengan suatu klub yang diperbolehkan untuk anggotanya saja. Fasilitas klub dapat diakses oleh anggota tapi, tidak untuk anggota luar.
13. 4 Menambahkan Fungsi Anggota
Konsep obyek pada C++ digunakan untuk menyatukan data dan fungsi yang mengakses data dalam suatu wadah.
Obyek
Anggota data
Fungsi data
Data yang terletak didalam kelas biasa disebut anggota data dan fungsi yang terletak didalamnya disebut fungsi anggota. Pada program konvensional data dapat dipakai sebagai komponen kelas kedua. Dan fungsi berkedudukan sebagai komponen utama, pada pemograman berorientasi obyek, data dan fungsi harus dirancang secara bersamaan. Pemograman konvensional bukan PBO.
Misal terdapat data :
- judul buku
- nama pengarang
- Jumlah buku
Awal pernacangan harus dibuat fungsi-fungsi dasar terlebih dahulu yang digunakan untuk mengakses ketiga data tersebut. Fungsi-fungsi yang dimaksud berupa:
- Mengisikan data
- Menampilkan data
Pendefinisian fungsi anggota pada kelas buku mempunyai aturan seperti fungsi biasanya missal untuk fungsi inisialisasi:
Inisialisasi ( ):
Void inisialisasi (char *judul, char *pengarang, int Jumlah)
{
strcpy (judul, judul);
strcpy (pengarang, pengarang);
Jumlah = Jumlah;
}
13. 5 Mendefinisikan Beberapa Obyek
Beberapa obyek dengan kelas dapat didefinisikan sebagaimana pendefinisian variable biasa (bukan obyek), misalnya :
Buku novel, fiksi;
Menyatakan pendefinisian obyek bernama novel dan fiksi.
Perhatikan contoh program berikut ini:
# include
# include
# include
class buku
{
private :
char judul [35];
char pengarang [25];
int Jumlah;
public:
void inisialisasi (char *judul, char *pengarang, int Jumlah)
{
strcpy (judul, judul);
strcpy (pengarang, pengarang);
Jumlah = Jumlah;
}
void info ( )
{
cout << “judul :” <<>
cout << “pengarang :” <<>
cout << “Jumlah buku :” <<>
}
};
void main ( )
{
clrscr ( );
buku novel, fiksi;
// Memberi nilai terhadap kedua obyek
novel.inisialisasi (“Meriam Benteng Navarone”, “Alistair Maclean”, 12);
fiksi.inisialisasi (“
// menampilkan informasi yang terdapat pada kedua obyek
novel.info ( );
fiksi.info ( );
}
Output:
C:\CPP>kelas 6
Judul : Meriam Benteng Navarone
Pengarang : Alistair Maclean
Jumlah buku : 12
Judul :
Pengarang : Michael Crichton
Jumlah buku : 3
C:\CPP_
13. 6 Penugasan Nilai Antar Obyek
C++ memungkinkan penyalinan nilai antarobyek dapat dilakukan dengan mudah cukup menggunakan operator sama dengan ( = ), contoh sebagai berikut :
Fiksi = novel;
Maka anggota data pada obyek fiksi akan diisi sesuai dengan angota data pada obyek novel
Kelas
sama
Obyek fiksi Obyek novel
Judul judul
Pengarang pengarang
Jumlah Jumlah
Fungsi anggota
Fiksi = novel
Jika dalam suatu kelas terdapat anggota data berupa pointer, penugasan antarobyek berbentuk :
Obyek1 = obyek2 ;
13. 7 Alternatif Penulisan Fungsi Aggota
Cara mendefinisikan fungsi anggota ada dua (2) macam, cara pertama :
Class buku
{
private:
char judul [35];
char pengarang [25];
int Jumlah ;
public:
void inisialisasi ( char *judul, char *pengarang, int Jumlah)
{
strcpy (judul, judul);
strcpy (pengarang, pengarang);
Jumlah = Jumlah;
}
…
};
bentuk kedua :
class buku
{
private :
char judul [35];
char pengarang [25];
int Jumlah ;
public void inisialisasi (char *judul, char *pengarang, int Jumlah);
void info ( );
};
Cara yang digunakan untuk mendefinisikan fungsi anggota dari suatu kelas yang mempengaruhi kode yang dibandingkan saat program kompilasi. Kode dibangkitkan menjadi sangat besar apabila pernyataan-pernyataan dilibatkan dalam fungsi anggota sangat banyak dan obyek yang diciptakan juga sangat banyak, maka masing-masing obyek tidak berbagi fungsi.
Beberapa pemogram C++ memadukan kedua cara untuk mendefinisikan fungsi anggota, bila fungsi anggota mengandung sedikit pernyataan maka definisi fungsi anggota ditulis dalam deklarasi kelas .
13. 8 Nama Parameter dan Anggota Data Sama
void buku ::inisialisasi (char *judul, char *pengarang, int Jumlah )
{
strcpy (judul, judul);
strcpy (pengarang, pengarang);
Jumlah = Jumlah;
}
Nama parameter (argument ) dan data anggota digunakan berbeda .Anggota data seperti ini tidak akan menimbulkan kerancuan / kesalahan.
13. 9 Nilai Balik Fungsi Anggota
Fungsi anggota selalu tidak mempunyai nilai balik (void), fungsi anggota juga bisa mempunyai nilai balik conto sebagai berikut:
Class tanggal
{
private :
int tanggal;
int bulan;
int tahun;
public :
void beri_tanggal (int tanggal, int bulan, int tahun);
void info ( );
int info_tanggal ( ) (return tanggal; );
int info_bulan ( ) (return bulan;);
int info_tahun ( ) (return tahun;);
};
13.4 Menambahkan Fungsi Anggota]
Konsep obyek pada C++ sebenarnya untuk menyatukan data dan fungsi yang mengakses data dalam suatu wadah
Selanjutnya data yang terletak di dalam kelas biasa disebut anggota. data dan fungsi yang terletak di dafamnya disebut fungsi anggota.
Konsep obyek ini tentu saja jauh berbeda dengan cara yang ditempuh pada program konvensional (bukan berorientasi obyek), yang memisahkan data dan fungsi yang mengaksesnya. Pada program konvensional, data hanya diperlakukan sebagai komponen kelas kedua. Fungsijustru berkedudukan sebagai komponen utama. Pada pemrograman berorientasi obyek, data dan fungsi harus dirancang secara bersamaan. Hal seperti inilah yang menjadikan PBO dirasakan sulit oleh mereka yang sudah terbiasa dengan pemrograman konvensional (bukan PBO).
Misalnya, bila terdapat data:
Ujudulbuku
U nama pengarang
U jumlah buku
di awal perancangan harus dipikirkan fungsi-fungsi dasar yang digunakan untuk mengakses ketiga data tersebut. Fungsi-fungsi yang dimaksud dapat berupa:
U Mengisikan data
U Menampilkan data
Kemudian juga perlu direncanakan, data atau fungsi m ana saja yang boleh diakses di luar obyek dan yang hanya dipergunakan secara internal oleh 6byek itu sendiri. Dalam hal ini penentu akses pubUc atau private yang menentukannya.
Untuk lebih jelasnya, marilah kita lihat program berikut
//*----------------------------------------------------------------------------------------*
//* kelas 5.cpp *
//* *
//* contoh sebuah kelas *
//* yang melibatkan anggota data dan *
//* fungsi anggota. *
//*---------------------------------------------------------------------------------------*
#include
#include
#include
class Buku
{
private:
char judul[35];
char pengarang[25];
int jumlah;
public:
void inisialisasi(char *Judul, char *Pengarang, int Jumlah)
{
strcpy(judul, Judul);
strcpy(pengarang, Pengarang);
jumlah = Jumlah;
}
void info ()
{
cout << "Judul <<>
cout << "Pengarang <<>
cout << "Jumlah buku <<>
}
};
Void main ()
{c1rscro; // Hapus layar
Buku novel; // Pendefinisian obyek
novel.inisialisasi("Meriam Benteng Navarone",
"Alistair MacLean", 12);
Novel.info();
Hasil eksekusi :
C:/cpp> kelas 5
Judul : Meriam genten Navarone
Pengarang : Alistair maclean
Jumlah buku : 12
C:\cpp>_
Pada, program di depan, kelas Buku memiliki tiga.buah anggota.data (judul, pengarang dan jumlah) dan dua. buah fungsi anggota. (inisi1isasi () dan info ()). Ketiga. data anggota. dinyatakan sebagai prifat. Oleh karena. itu, ketiga. data ini tidak dapat diakses di luar kelas. Namun data ini dapat diakses oleh kedua. fungsi anggota, dan semua. fungsi anggota. dapat diakses di luar kelas, mengingat dinyatakan sebagai publik. Melalui kedua. fungsi inilah data kelas dapat diakses, misalnya. pada. fungsi main().
Class Buku
{
Private:
Char judul [35]; anggota data
Public:
Void inisialisasi(…) fungsi
{
…
}
Void info() anggota
{
..
}
};
Gammbar 13.4 Data dan J:U~si anggota
Pendefinisian fungsi anggota. pada. kelas Buku mempunyai
aturan seperti halnya. fungsi biasa. Misalnya untuk fungsi
inisialisasi():
void inisialisasi(char *Judul, char *Pengarang,
int Jumlah)
{
Strcpy (judul, Judul);
strcpy(pengarang, Pengarang);
jumlah = Jumlah;
}
Namun ada hal yang perlu diperhatikan. Fungsi anggota seperti di atas dapat mengenali variabel seperti judul, pengarang dan jumlah, yang fidak lain adalah data anggota dari kelas Buku.
Pernyataan di dalam fungsi -min):
Buku novel;
digunakan untuk mendefinsikan obyek bernama novel.
Selanjutnya, di dalam fungsi m-In ) ini Idta bisa memanggil fungsi anggota. obyek novel dengan cara sebagai berikut :
(1) novel.inisialisasi("Meriam Benteng Navarone",
"Alistair MacLean", 12);
(2)novel.infoo;
Bentuk pemanggilannya:
Nama_obyek_nama_fungsi(argumen)
Pada contoh pertama (1)), ketiga argumen di atas digunakan untuk memberikan nilai terhadap kctiga anggota data obyek novel dan pada contoh kedua ((2)) ketiga anggota data dari obyek novel ditampilkan (perhatikan definisi fungsi anggota info () ).
Mungldn terpikir bagi Anda, "Mengapa kode pada Program 13.5 ini terlalu panjang, padahal hasilnya ternyata sama saja dengan Program 13.1 ?". Anda memang benar, tetapi cara pada Program 13.5 inflah yang merupakan cara pemrograman yang berorientasi obyek, khususnya pada C++. Jika Anda telah mencoba program di atas, Anda telah menginjak ke PBO.
13.5 Mendefinisikan Beberapa Obyek
Beberapa obyek dengan kelas sama dapat didefinisikansebagaima-na pendefinisian variabel biasa (bukan obyek). MisaInya:
Buku novel, fiksi;
merupakan pemyataan untuk mendefmisikan obyek bernama noveldan fiksi. Kelasnya sama, yaitu Buku. Tampak, nama kelas mendahului nama-nama obyek.
Perlu diketahui, jika terdapat lebih dari sebuah obyek danobyek-obyek tersebut mempunyai kelas yang sama, data anggotapada masing-masing obyek bersifat terpisah. Untuk mehhat hal ini perhatikan program berikut beserta hasil eksekusinya.
/ /*----------------------------------------------------------------- *
/ /* kelas6.cpp *
/ /* *
/ /* Contoh untuk memperlihatkan ketidaktergantungan *
/ /* anggota data pada dua buah obyek *
/ /* yang mempunyai kelas sama. *
/ /* --------------------------------------------------------------------
#include
#include
#include
class Buku
{
private:
char judul[35];
char pengarang[251;
int jumlah;
public:
void inisialisasi(char *Judul, char *Pengarang,
int Jumlah)
{
stzcpy(judul, Judul);
strcpy(pengarang, Pengarang);
jumlah = Jumlah;
}
void info()
{
cout << "Judul <<>
cout << "Pengarang <<>
cout << "Jumlah buku <<>
void main()
{
Clrscro (); // Hapus layar
Buku novel, fiksi; // Pendefinisian obyek
// Memberi nilai terhadap kedua obyek
novel.inisialisasi ("Meriam Benteng.Navarone",
"Alistair MacLean", 12);
fiksi.inisialisasi ("
"Michael Crichton", 3);
// Menanpilkan informasi yang terdapat
// pada kedua obyek
novel.infoo;
fiksi.infoo;
Hasil eksekusi
C;\ CPP> kelas6
Judul : Meriam Benteng Navarone
Pengarang : Aliastair Maclean
Jumlah buku : 12
Judul : Jurassic park
Pengarang : Michael Crichton
Jumlah buku : 3
C:\cpp>_
Hasil di atas menunjukkan bahwa data yang terkandung pada masing-masing obyek (novel dan fiksi) berbeda.
13.6 Penugasaan NU&i Antardbyek
C++ memungkinkan penyalinan nilai antarobyek dapatdilakukan dengan mudah, yaitu cukup menggunakan operator samadengan (=). Sebagai contoh, dua buah obyek berkelas Bukudiciptakan melalui pemyatagn
Buku novel, fiksi;
Dcngan menggunakan pernyataan:
fiksi = novel;
maka semua anggota data pada obyek fiksi akan diisi sesuai dengan anggota data pada obyek novel.
kelas sama.
Obyek fiksi Obyek novel
` Judul judul
pengarang pengarang
jumlah jumlah
fungsi anggota fungsi anggota
fiksi = novel;
Ganibar 13.5 Penugasan antarobyek berkelas sama
Contoh program yang menunjukkan penugasan antarobyek:
// *-----------------------------------------------------------------------------*
// * kelas7.cpp *
// * *
// * Contoh untuk menunjukkan operasi penugasan *
// * antarobyek. *
// *-----------------------------------------------------------------------------*
#include
#include
#include
{
private:
char judul[35];
char pengarang[25);
int jumlah;
public:
void inisialisasi(char *Judul, char *Pengarang,
` int Jumlah)
{
strcpy(judul, Judul);
strcpy(pengarang, Pengarang);
jumlah = Jumlah;
}
void info()
{
cout << "Judul <<>
cout << "Pengarang <<>
cout << "Jumlah buku <<>
}
};
void maino
{
clrscro; // Hapus layar
Buku novel, fiksi; // Pendefinisian obyek
// Memberi nilai terhadap obyek novel
novel.inisialisasi("Meriam Benteng Navarone",
"Alistair Maclean", 12);
// Penugasan obyek
fiksi = novel;
// Tampilkan informasi obyek fiksi
fiksi.info () ;
}
Hasil eksekusi :
C:\cpp > kelas 7
Judul : meriam benteng navarone
Pengarang : Alistair maclean
Jumlah buku : 12
C: \cpp>_
13.7 Alternatif Penulisaa Fungsi Anggota
Cara mendefinisikan fungsi anggota sebenarnya ada dua macam. Cara yang pertama adalah sesuai dengan contoh di depan, yakni fungsi anggota. didefinisikan di dalam deklarasi kelas. Misalnya:
class Buku
{
private:
char judul[35];
char pengarang[25];
int jumlah;
public:
void inisialisasi(char *Judul, char *Pengengarang,
int Jumlah)
}
strcpyfjudul, Judul); strcpy(pengarang, Pengarang);
jumlah = Jumlah;
}
...
};
Bentuk yang kedua, pada kelas hanya terdapat deklarasi fungsi anggota (prototipe), sehingga bentuknya menjadi semacam berikut:
class Buku
{
private:
char judul[35J;
char pengarang[25];
int jumlah;
public:
void inisialisasi(char *Judul, char *Pengarang, int Jumlah};
void info( ) ;
};
Definisi fungsi anggota ditempatkan di luar kelas.
Definisi untuk kedua fungsi anggota pada kelas Buku ditulis menjadi :
void Buku::inisialisasi (char *Judul, char *Pengarang,
int Jumlah)
{
strcpy(judul, Judul);
strcpy(pengarang, Pengarang);
jumlah = Jumlah;
}
void Buku: : info ()
{
cout « " Judul
cout « "Pengarang cout « "Jumlah buku
: "« judul « endl;
:" « pengarang « endl;
:" « jumlah « endl;
|
|
| Operator Lingkup |
Gambar 13.6 Pendefinisian fungsi anggota di luar kelas
Cara yang kedua ini lebih umum digunakan.
Perlu diketahui, pada penulisan fungsi seperti Buku::inisaliasasi, dengan sendirinya anggota data kelas Buku dikenali pada fungsi tersebut.
Contoh program berikut merupakan bentuk lain dari Program 13.5:
Program 13.8
/ / * -----------------------------------------------------------------------------------------*
// * kelas8.cpp *
// * *
// * Alternatif lain penulisan fungsi anggota *
/ / * --------------------------------------------------------------------------------------------------- *
#include
#include
#include
class Buku .
private:
char judul [35]
char pengarang[25];
int jumlah;
public:
void inisialisasi (char *Judul, char *Pengarang,
int Jumlah) ;
void info ( ) ;
};
void main()
{
Clrscr ( ); // Hapus layar
Buku novel; // Pendefinisian obyek
novel . inisialisasi ("Meriam Benteng Navarone",
"Alistair MacClean", 12);
novel . info ( ) ;
}
void Buku:.: inisialisasi (char *Judul, char *Pengarang,
int Jumlah)
{
strcpy (judul, Judul) ;
strcpy (pengarang, Pengarang) ;
jumlah = Jumlah;
}
void Buku::info()
{
Cout << “Judul : “ <<>
Cout << “Pengarang : “ <<>
Cout << “Jumlah buku : “ << style="" clear="all">
| Akhir Program |
| Hasil eksekusi : |
Perlu diketahui, dua cara yang digunakan untuk mendefinisikan fungsi anggota dari suatu kelas sebenarnya mempengaruhi kode yang dibangkitkan saat program kompilasi. Apabila definisi fungsi ditulis di dalam kelas (seperti pada Program 13.5), fungsi akan diperlakukan sebagai fungsi inline (F subbab 7.9). Perlakuan seperti ini sudah tentu mempunyai keuntungan dan kelemahan. Keuntungannya, semua kode terkumpul di dalam kelas itu sendiri. Hal ini dapat mempercepat pengeksekusian. Adapun kelemahannya :
� Kode yang dibangkitkan menjadi sangat besar terutama kalau pernyataan-pernyataan yang dilibatkan di dalam fungsi anggota sangat banyak dan obyek yang diciptakan juga banyak. Sebab, masing-masing obyek tidak berbagi fungsi.
Itulah sebabnya cara yang dilakukan pada Program 13.8 yang paling banyak digunakan.
Suatu fungsi yang bersifat inline juga dapat didefinisikan di luar kelas. Caranya yaitu dengan menambahkan kata-kunci inline di depan tipe fungsi. Contoh :
inline void Buku::inisialisasi(char *Judul, char *Pengarang,
int Jumlah)
{
strcpytjudul, Judul);
strcpy(pengarang, Pengarang);
jumlah = Jumlah;
}
Dengan mendefinisikan seperti di atas, fungsi anggota inisialisasi () akan diperlakukan sebagai fungsi inline.
13.8 Nama Parameter dan Anggota Data Sama
Pada contoh pendefinisian fungsi anggota inisialisasi () pada kelas Buku seperti terlihat di bawah ini:
void Buku::inisialisasi (char *Judul, char *Pengarang,
int Jumlah)
{
strcpy(judul, Judul);
strcpy(pengarang, Pengarang);
jumlah = Jumlah;
}
nama parameter (argumen) dan data anggota yang digunakan berbeda (Perbedaan terletak pada huruf awalnya). Hal seperti ini tidak akan menimbulkan kerancuan.
Berbeda halnya kalau nama parameter fungsi dan nama anggota data kelas ternyata sama, seperti pada contoh berikut :
void Buku:: inisialisasi (char *judul, char *pengarang,
int jumlah)
{
strcpy (judul, judul) ;
strcpy(pengarang, pengarang);
jumlah = jumlah;
Pada penulisan seperti di atas, sudah tentu kompiler tidak dapat membedakan antara parameter dan anggota data kelas. Sekalipun demikian jika kode seperti di atas dikompilasi ternyata kompiler tidak melaporkan kesalahan. Mengapa? Tidak lain adalah dengan sendirinya kompiler menganggap semua data pada fungsi anggota di atas sebagai parameter. Dengan kata lain, nama anggota data kelas menjadi tersembunyi.
Perlu ditekankan di sini, bahwa kalau nama anggota data kelas ternyata sama dengan nama parameter, nama anggota data tetap bisa diakses. Pengaksesannya melalui operator resolusi lingkup (::), dengan format :
| nama_kelas::nama._anggata_data |
Dengan demikian, fungsi inisialisasi ( ) dapat ditulis menjadi :
void Buku::inisialisasi(char *judul, char *pengarang,
int jumlah)
{
strcpy(Buku::judul, judul);
strcpy(Buku::pengarang, pengarang);
Buku: :jumlah = jumlah;
Pada contoh ini,
� Buku: : judul menyatakan anggota data bernama judul pada kelas Buku
� judul menyatakan parameter fungsi angota
Contoh program yang menggunakan cara seperti di depan:
| Program 13.9 |
// * --------------------------------------------------------------------------------------------------*
// * kelas9.cpp *
// * Contoh penulisan anggota data pada fungsi anggota *
// * dengan format kelas::data *
// * -------------------------------------------------------------------------------------------------*
#include
#include
#include
class Buku
{
private:
char judul[35];
char pengarang [25] ;
int jumlah;
publ i c :
void inisialisasi (char *judul, char *pengarang,
int jumlah) ;
void info ( ) ;
};
| void main ( ) { Clrscr (); Buku novel; |
// Hapus layar
// Pendefinisian obyek
novel. inisialisasi ("Meriam Benteng Navarone",
"Alistair MacClean", 12);
novel . info ( ) ;
}
void Buku: : inisialisasi (char *judul, char *pengarang,
int jumlah)
{
strcpy(Buku: : judul, judul);
strcpy (Buku: : pengarang, pengarang) ;
Buku:: jumlah = jumlah;
}
void Buku:: info ()
{
cout « "Judul
cout « "Pengarang cout cout« "Jumlah buku
}
" « judul « end1;
" « pengarang « endl;
" « jumlah « endl;
| Akhir Program |
13.9 Nilai Balik Fungsi Anggota
Pada semua contoh yang diberikan, fungsi anggota selalu tidak mempunyai nilai balik (void). Apakah memang demikian aturannya? Jawaba.nnya adalah tidak. Seperti halnya fungsi biasa, fungsi anggota juga bisa mempunyai nilai balik. Sebagai contoh dapat diiihat di bawah ini:
class Tanggal
{
private:
int tanggal;
int bulan;
int tahun;
public:
void beri_tanggal (int tanggal, int bulan, int tahun);
void info( );
int info_tanggal() { return tanggal; };
int info_bulan() { return bulan; };
int info tahun() { return tahun; };
}
Pada kelas Tanggal di atas terdapat
Contoh program lengkap :
Program 13.1O
// * ----------------------------------------------------------------------------------------*
// * kelastgl.cpp *
// *Contoh program yang memperlihatkan *
// *fungsi anggota yang mempunyai nilai balik. *
// * ------------------------------------------------------------------------*
#include
#include
#include
class Tanggal
{
private:
int tanggal;
int bulan;
int tahun;
public: ' .
void beri_tanggal (int tanggal, int bulan, int tahun);
void info();
int info_tanggal() { return tanggal; };
int info_bulan() { return bulan; };
int info tahun() { return tahun; };
};
void main()
{
clrscrf); // Hapus layar
Tanggal tanqgal_lahir;
tanggal_lahir . beri_tanggal(25, 6, 1991);
tanggal_lahir.info();
cout « tanggal_lahir.info_tanggal () « '-'
« tanggal_lahir-info_bulan() « '—'
« tanggal lahir.info_tahun();
}
void Tanggal: :beri tanggal (int tanggal, int bulan, int tahun)
{
Tanggal : :tanggal = tanggal;
Tanggal: :bulan = bulan;
Tanggal: : tahun = tahun;
}
void Tanggal: : info ()
{
cout « setfill ( '0' ) ;
cout « "Tanggal : " « setw(2) « tanggal
« '/' « setw(2
) « bulan
« '/' « tahun « endl;
cout « setfill ( ' ' );
}
Akhir Program
C : \ CCP>kelastgl Tanggal : 25/06/1991 25-6-1991 C; \CCP>_
Hasil eksekusi :
Tidak ada komentar:
Posting Komentar