LAPORAN PRAKTIKUM ALGORITMA DAN PEMROGRAMAN

KELAS

Oleh

Nama : Andre Rinaldi Zulhansyah

NIM : 2020204020006
Kelas : TT 2 A
Prodi : Teknologi Telekomunikasi
Semester : 4 (GENAP)
Dosen Pembimbing : Hanafi, S.T.,M.Eng.

KEMENTERIAN RISET, TEKNOLOGI DAN PENDIDIKAN TINGGI

POLITEKNIK NEGERI LHOKSEUMAWE
JURUSAN TEKNIK ELEKTRO
SEMESTER GANJIL TAHUN AJARAN 2021/2022

i
 Lembar Pengesahan

Nomor : 01
Nama : Andre Rinaldi Zulhansyah
NIM : 2020204020006
Kelas : TT 2A
Jurusan : Teknik Elektro
Prodi : Teknologi Telekomunikasi

Judul Praktikum : Kelas

Tanggal Praktikum : 23 Februari 2022
Tanggal Penyerahan : 2 Maret 2022
Dosen Pembimbing : Hanafi, S.T.,M.Eng.

Buket Rata, 2 Maret 2022

Mengetahui
Pembimbing, Penyusun

Hanafi,S.T.,M.Eng. Andre R. Zulhansyah

NIP. 196901172002121001 NIM. 2020204020006

ii
 DAFTAR ISI
Kelas................................................................................................................1
Tujuan Praktikum............................................................................................1
Dasar Teori......................................................................................................1
B.1 Pendahuluan........................................................................................2
B.2 Pengertian Kelas dan Objek................................................................3
B.3 Mendefinisikan Kelas dan Mendeklarasikan Objek...........................3
B.4 Konstruktor.........................................................................................4
B.5 Destruktor...........................................................................................4
B.6 Pewarisan............................................................................................5
B.7 Parameter Berupa Objek.....................................................................5
B.8 Nilai Balik Fungsi Serupa Objek........................................................6
B.9 Pointer This.........................................................................................6
B.10 Anggota Data yang bersifat Statis....................................................7
C Tugas-Tugas Pendahuluan............................................................................8
C.1 Ketikkan dan eksekusi kode sumber: .................................................
AndreRZ_06_ KelasPeg.cpp.....................................................................
C.2 Ketikkan dan eksekusi kode sumber:..................................................9
AndreRZ_06_ Konstruktor.cpp.................................................................
C.3 Ketikkan dan eksekusi kode sumber:..................................................10
AndreRZ_06_ BawaanPar.cpp..................................................................
C.4 Ketikkan dan eksekusi kode sumber:..................................................11
AndreRZ_06_ Destruktor.cpp...................................................................
C.5 Ketikkan dan eksekusi kode sumber:..................................................11
AndreRZ_06_ Pewarisan.cpp....................................................................
C.6 Ketikkan dan eksekusi kode sumber:..................................................12
AndreRZ_06_ ParObjek.cpp.....................................................................
C.7 Ketikkan dan eksekusi kode sumber:..................................................13
AndreRZ_06_ BalikObj.cpp......................................................................
C.8 Ketikkan dan eksekusi kode sumber:..................................................13
AndreRZ_06_ PtrThis.cpp.........................................................................
C.9 Ketikkan dan eksekusi kode sumber:..................................................13
AndreRZ_06_ DataStatis.cpp....................................................................
D Percobaan......................................................................................................13
D.1 Langkah-Langkah Praktikum Bahasa C++.........................................13
D.1.1 Diagram AndreRZ_06_KelasPeg.cpp.............................................13
D.1.2 Diagram AndreRZ_06_Konstruktor.cpp.........................................13
D.1.3 Diagram AndreRZ_06_BawaanPar.cpp..........................................13
D.1.4 Diagram AndreRZ_06_Destruktor.cpp...........................................14
D.1.5 Diagram AndreRZ_06_Pewarisan.cpp............................................14
D.1.6 Diagram AndreRZ_06_ParObjek.cpp.............................................14
D.1.7 Diagram AndreRZ_06_BalikObj.cpp..............................................14
iii
 D.1.8 Diagram AndreRZ_06_PtrThis.cpp.................................................14
D.1.9 Diagram AndreRZ_06_DataStatis.cpp............................................14
D.2 Buatlah kode sumber lain yang berbeda dengan yang telah ada di tugas
pendahuluan sesuai dengan judulnya................................................................15
D.2.1 AndreRZ_06_KelasPeg.cpp............................................................15
D.2.2 AndreRZ_06_Konstruktor.cpp........................................................17
D.2.3 AndreRZ_06_Destruktor.cpp..........................................................19
D.2.5 AndreRZ_06_Parameter Berupa Objek.cpp....................................22
D.3 Analisa Percobaan......................................................................................23
D.3.1 KelasPeg.cpp....................................................................................23
D.3.2 Konstruktor.cpp...............................................................................23
D.3.3 Destruktor.cpp..................................................................................23
D.3.5 Parameter Berupa Objek.cpp...........................................................23
D.4 Kesimpulan................................................................................................24
Daftar Pustaka...................................................................................................25

DAFTAR GAMBAR
iv
Gambar 1.1 Contoh Kelas Pegawai.......................................................................1
Gambar 1.2 Kelas sebagai cetakan untuk objek....................................................2
Gambar 1.3 Pewarisan Kelas.................................................................................3

v
 PRAKTIKUM 1
KELAS

Tujuan Instruksional Khusus

1. Mahasiswa dapat menjelaskan pengertian kelas dan objek.
2. Mahasiswa dapat mendefinisikan kelas dan mendeklarasikan objek.
3. Mahasiswa dapat memahami dan menjelaskan konstruktor.
4. Mahasiswa dapat memahami dan menjelaskan destructor.
5. Mahasiswa dapat memahami dan menjelaskan pewarisan.
6. Mahasiswa dapat memahami dan menjelaskan parameter berupa objek.
7. Mahasiswa dapat menjelaskan tentang nilai balik fungsi berupa objek.
8. Mahasiswa dapat menjelaskan dan memahami pointer this.
9. Mahasiswa dapat memahami anggota data yang bersifat statis.

Dasar Teori
B.1 Pendahuluan
Bab ini memberikan pengenalan terhadap kelas dan penggunaan kelas untuk
mendeklarasikan objek. Dengan berakhirnya bab ini diharapkan anda mempunyai dasar untuk
bekerja dengan objek.

B.2 Pengertian Kelas dan Objek

Kelas merupakan suatu tipe data yang menggabungkan data dan fungsi untuk
mengakses data. Sebagai contoh, suatu kelas Pegawai dapat mengandung data seperti NIP
(nomor induk pegawai), nama, dan jenis kelamin dan memiliki fungsi untuk mengakses data
tersebut, misalnya dengan nama:
 isiNama() untuk mengisikan nama pegawai,
 isiNIP() untuk mengisikan NIP,
 isiKelamin() untuk untuk menentukan jenis kelamin,
 perolehNama() untuk memperoleh nama pegawai,
 perolehNIP() untuk memperoleh NIP,
 perolehKelamin() untuk memperoleh jenis kelamin.

Pegawai
-nip: integer
-nama: string
-pria: Boolean
+inisialisasi(nip: integer, nama: string, pria: boolean): void
+isiNIP(nip: integer): void
+isiNama(nama: string): void
+isiKelamin(pria: boolean): void
+perolehNIP(): integer
+perolehNama(): string
+perolehKelamin(): boolean
Gambar B.1 Contoh Kelas Pegawai

1
 Data yang bersifat pada kelas umumnya bersifat privat, dalam arti hanya fungsi anggota
yang didefinisikan dalam kelas tersebut yang dapat mengakses data,sedangkan fungsi anggota
umumnya bersifat public, dalam arti bias diakses diluar kelas.

Setelah sebuah kelas didefinisikan, kelas tersebut dapat dipakai untuk mendeklarasikan
satu atau sejumlah objek. Itulah sebabnya objek dapat dipandang sebagai cetakan untuk objek.

Gambar B.2 Kelas sebagai cetakan untuk objek

Pendeklarasian sebuah objek berdasarkan kelas seringkali disebut penginstansian
(instantion) dan objek itu sendiri dianamakan instan kelas.

B.3 Mendefinisikan Kelas dan Mendeklarasikan Objek

Contoh definisi sebuah kelas ditunjukkan dibawah ini:
class pegawai
{
private:
int nip;
char nama[35];
bool pria;
public:
void inisialisasi(int nip, char nama[], bool pria);
void isiNIP(int nip);
void isiNama(char nama[]);
void isiKelamin(bool pria);
int perolehNIP();
char * perolehNama();
bool perolehKelamin();
};
Perhatikan bahwa definisi kelas diakhiri dengan titik koma.

Baris private: menyatakn bahwa deklarasi berikutnya (sampai ada bentuk yang lain:
protected atau public jika ada) bersifat privat, yang artinya hanya dapat diakses oleh kode di
dalam kelas itu saja. Dalam hal initerdapat tiga dekalrasi anggota data, masing-masing dengan
nama nip,nama,dan pria.

Baris public: menyatakan bahwa deklarasi berikutnya (sampai ada bentuk lain:
protected atau public jika ada) bersifat public. Yang artinya dapat diakses oleh kode di yang
terletak dimana saja. Terdapat tujuh prototype fungsi anggota.

2
 Pada bentuk seperti itu, detail definisi fungsi anggota dapat diletakkan pada bagian lain.
Pada kode berikut, definisi fungsi anggota diletakkan dibawah main().

B.4 Konstruktor
Konstruktor adalah fungsi khusus di dalam sebuah kelas yang akan dijalankan secara
otomatis ketika sebuah objek baru dideklarasikan. Nama konstruktor sama dengan nama kelas.
Contoh berikut menunjukkan pelibatan konstruktor yang dipakai untuk menggantikan fungsi
inisialisasi() yang dibahas didepan.

B.5 Destruktor
Destruktor adalah fungsi khusus dalam sebuah kelas yang dijalankan secara otomatis
ketika objek musnah. Nama destructor sama dengan nama kelas, tetapi diawali simbol~
Perhatikan bahwa konstruktor dijalankan ketika objek diciptakan dan destruktor
dijalankan ketika objek hendak musnah. Dalam hal ini, objek dengan identitas Beta musnah
setelah fungsi tesFungsi () berakhir dijalankan dan objek dengan identitas Alpha musnah setelah
fungsi main() berakhir dijalankan.

B.6 Pewarisan
Pewarisan memungkinkan untuk membuat suatu kelas yang didasarkan kelas yang
sudah ada sehungga mewarisi semua anggota, baik anggota data maupun fungsi anggota.
Gambaran mengenai hal ini dapat dilihat pada gambar berikut:

Gambar 1.3 Pewarisan Kelas

Pada contoh seperti di atas, KelasX disebut Kelas dasar atau Superkelas, sedangkan
KelasY disebut Kelas turunan atau Kelas anak.
Pewarisan merupakan suatu mekanisme yang memungkinkan seorang pemograman
menciptakan suatu kelas baru berdasrakan kelas yang sudah tersedia tetapi tidak perlu
menulisakan kode dari nol. Dengan cara seperti ini, semua anggota terdapat pada kelas dasar
diturunkan ke kelas turunan. Namun kelas turunan dapat ditambah dengan anggota baru ataupun
menganti isi fungsi anggota.

3
 Sebagai contoh, terdapat kelas seperti berikut:
Class Orang
{
Private:
Char*nama;
Tanggal tglLahir;
Public:
//Konstruktor
Orang(Char* nama,
Tanggal tglLahir);

//Destruktor
~Orang ();
Void info ();
};

Dasar hal in kelas Orang memiliki dua buang anggota data bernama nama (berupa
pointer yang menunjuk ke tipe char) dan tglLahir yang berupa struktur Tanggal. Struktur
Tanggal sendiri didefinisikan sebagai berikut:
Struct Tanggal
{
int tanggal;
int bulan;
int tahun;
};

Berdasarkan kelas orang, kelas lain dapat dibuat =; misalnya dengan menambahkan
anggota data bernama nip, sebagaimana diperlihatkan dibawah ini:

Class karyawan : public Orang

{
Private:
int nip;
public:
//konstruktor
Karyawan (int nip, char* nama,
Tanggal tglLahir);
//Destruktor
~karyawan ();
Void info ();
};

Pertama-tama, perhatikan kode:

: public Orang

Yang terletak sesuadah Class karyawan : Kode tersebut menyatakan bahwa karyawan
adalah kelas turunan yang didasarkan pada kelasr Orang. Kata public pada konteks tersebut
menyatakan bahwa bagian yang bersifat privat pada kelas dasar tidak dapat diakses secara
langsung oleh kelas turunan. Namun anggota yang bersifat public dan protected pada kelas
dasar tetap dapat diakses oleh kelas turunan.

4
 Kedua, kelas turunan (yaitu karyawan) dapat menyediakan anggota data baru dengan
nama nip
Perhatikan pula bahwa dalam definisi kelas karyawan terdapat fungsi dengan nama
yang sama dengan yang ada pada kelas Orang ( yaitu kelas info() ). Hal seperti itu
diperkenankan.

Mengingat baik kelas Orang dan Karyawan memeiliki nama fungsi yang sama yaitu
info, kelas Karyawan perlu menyebutkan Orang:: untuk memanggil info () milik kelas dasar.
Itulah sebabnya di dalam definisi fungsi anggota Karyawan:: info() terdapat pernyataan:
Orang::info();

Yang mengatakan pemanggilan terhaddap fungsi anggota info() milik kelas Orang.

B.7 Parameter Berupa Objek

Objek juga dapat berkedudukan sebagai parameter.

B.8 Nilai Balik Fungsi Serupa Objek

Suatu fungsi juga bisa memberikan nilai berupa objek. Contoh tentang hal ini
diperkirakan pada kode berikut:

Merupakan prototipe konstruktor yang menyatakan bahwa nilai bawaan untuk masing-
masing parameter beruppa nol.
Adapun definisi berikut:

Buah buah::tambah (buah b)

{
Buah tmp;
Tmp.apel += b.apel;
Tmp.jeruk += b.jeruk;
Return tmp;
}

Menyatakan bahwa fungsi anggota tambah melibatkan objek berkelas buah dan
memberikan nilai balik berupa objek berkelas buah.

B.9 Pointer This

Setiap kelas memiliki anggota data tersembunyi yang bernama this. Anggota data ini
berupa pointer yang menunjukan ke objek di dalam memori. Secara umum, sebenarnya
penulisan seperti:

Namakelas::namaAnggotaData
Identik dengan
This ->namaAnggotaData
Begitu juga
namaKelas::namafungsiAnggota()
identik dengan
this->namaFungsiAnggota()

Contoh berikut memperlihatkan pemakaian this.

Merupakan ekspresi untuk membandingkan hasil Anggota luas () milik objek

bersangkutan dengan funsgi anggota luas () milik objek kotak.

5
Ekspresi tersebut sebenarnya bisa saja di tulis menjadi:
PersegiPanjang::luas() > kotak.luas()

Atau bahkan cukup di tulis menjadi:

Luas() > Kotak,luas()

Pada main(),
If (kotakA,lebihBesar(KotakB))
Cout <<”kotak A lebih besar”
<< endl;
Else
Cout <<”Kotak A lebih besar”
<< endl;

Digunakan untuk melakukan perbandingan objek kotakA dan kotakB.

B.10 Anggota Data yang Bersifat Statis

Anggota data pada kelas juga dapat dibuat menjadi statis. Sebagai efeknya, data seperti
itu hanya akan dibuat satu dan semua objek dapat berbagi data.

C Tugas Pendahuluan
C.1 Ketikkan dan eksekusi kode sumber: KelasPeg.cpp, kemudian catat hasil
eksekusi.
#include <iostream.h>
#include <string.h>
class Pegawai{
private:
int nip;
char nama[35];
bool pria;

public:
void inisialisasi(int nip, char nama[], bool pria);
void isiNIP(int nip);
void isiNama(char nama[]);
void isiKelamin(bool pria);
int perolehNIP();
char* perolehNama();
bool perolehKelamin();
};
int main() {
Pegawai pegAkuntansi;
pegAkuntansi.inisialisasi(12350, "Wanto Irawan", true);
Pegawai pegPemasaran;
pegPemasaran.isiNIP(12355);
pegPemasaran.isiNama("Rita Ananda");
pegPemasaran.isiKelamin(false);

cout << "Pegawai Akuntansi:" << endl;

cout << "NIP:"
<< pegAkuntansi.perolehNIP()
<< endl;

6
cout << "Nama:"
<< pegAkuntansi.perolehNama()
<< endl;

cout << "NIP:"

<< (pegAkuntansi.perolehKelamin() ?
"Pria" : "Wanita")
<< endl;

cout << endl;

cout << "Pegawai Pemasaran:" << endl;

cout << "Nama :"

<< pegPemasaran.perolehNama()
<< endl;

return 0;

}
void Pegawai::inisialisasi(int nip, char* nama, bool pria) {
Pegawai::nip = nip;
strcpy(Pegawai::nama, nama);
Pegawai::pria = pria;
}
void Pegawai::isiNIP(int nip) {
Pegawai::nip = nip;
}
void Pegawai::isiNama(char* nama) {
strcpy(Pegawai::nama, nama);
}
void Pegawai::isiKelamin(bool pria) {
Pegawai::pria = pria;
}
int Pegawai::perolehNIP() {
return Pegawai::nip;
}
char* Pegawai::perolehNama() {
return Pegawai::nama;
}
bool Pegawai::perolehKelamin() {
return Pegawai::pria;
}

7
C.2 Ketikkan dan eksekusi kode sumber: Konstruktor.cpp, kemudian catat hasil
eksekusi.
#include <iostream.h>
#include <string.h>
class Pegawai
{
private:
int nip;
char nama[35];
bool pria;
public:
Pegawai(int nip,char nama[],bool pria);
void isiNIP(int nip);
void isiNama(char nama[]);
void isiKelamin(bool pria);
int perolehNIP();
char* perolehNama();
bool perolehKelamin();
};
int main()
{
Pegawai pegAkuntansi(12350,"Wanto Irawan",true);
cout<<"Pegawai Akuntansi:"<<endl;
cout<<"NIP:"<<pegAkuntansi.perolehNIP()<<endl;
cout<<"Nama:"<<pegAkuntansi.perolehNama()<<endl;
cout<<"Kelamin"<<(pegAkuntansi.perolehKelamin)()?"Pria":"Wanita"<<endl;
cout<<endl;
return 0;
}
Pegawai::Pegawai(int nip,char nama[],bool pria){
Pegawai::nip=nip;
strcpy(Pegawai::nama,nama);
Pegawai::pria=pria;
}
void Pegawai::isiNIP(int nip){
Pegawai::nip=nip;
}
void Pegawai::isiNama(char nama[]){
strcpy(Pegawai::nama,nama);
}
void Pegawai::isiKelamin(bool pria){

8
 Pegawai::pria=pria;
}
int Pegawai::perolehNIP(){
return Pegawai::nip;
}
char* Pegawai::perolehNama(){
return Pegawai::nama;
}
bool Pegawai::perolehKelamin(){
return Pegawai::pria;
}

C.3 Ketikkan dan eksekusi kode sumber: BawaanPar.cpp, kemudian catat hasil
eksekusi.
#include <iostream.h>
#include <string.h>
class Pegawai
{
private:
int nip;
char nama[35];
bool pria;
public:
Pegawai(int nip=0,char nama[]="Nama belum diisi",bool pria=false);
void isiNIP(int nip);
void isiNama(char nama[]);
void isiKelamin(bool pria);
int perolehNIP();
char* perolehNama();
bool perolehKelamin();
};
int main()
{
Pegawai pegEDP;
cout<<"Pegawai EDP:"<<endl;
cout<<"NIP:"<<pegEDP.perolehNIP()<<endl;
cout<<"Nama:"<<pegEDP.perolehNama()<<endl;
cout<<"Kelamin"<<(pegEDP.perolehKelamin()?"Pria":"Wanita"<<endl;
cout<<endl;
return 0;
}
Pegawai::Pegawai(int nip,char nama[],bool pria){
Pegawai::nip=nip;
strcpy(Pegawai::nama,nama);
Pegawai::pria=pria;

9
 }
void Pegawai::isiNIP(int nip){
Pegawai::nip=nip;
}
void Pegawai::isiNama(char nama[]){
strcpy(Pegawai::nama,nama);
}
void Pegawai::isiKelamin(bool pria){
Pegawai::pria=pria;
}
int Pegawai::perolehNIP(){
return Pegawai::nip;
}
char* Pegawai::perolehNama(){
return Pegawai::nama;
}
bool Pegawai::perolehKelamin(){
return Pegawai::pria;
}

C.4 Ketikkan dan eksekusi kode sumber: Desktruktor.cpp, kemudian catat hasil
eksekusi.
#include <iostream.h>
#include <string.h>
void tesFungsi();
class Coba{
private:
char id[15];
public:
Coba(char id[]);
~Coba();
};
int main(){
Coba Alpha("Alpha");
tesFungsi();
cout<<"Ketika main() hendak berakhir"<<endl;
return 0;
}
void tesFungsi(){
cout<<"tesFungsi() dijalankan"<<endl;
Coba Beta("Beta");
}

10
 Coba::Coba(char id[]){
strcpy(Coba::id,id);
cout<<"Id:"<<Coba::id<<"."<<"Konstruktor diajalankan..."<<endl;
}
Coba::~Coba(){
cout<<"Id: "<<Coba::id<<"."<<"Destruktor dijalankan..."<<end;
}

C.5 Ketikkan dan eksekusi kode sumber: Pewarisan.cpp, kemudian catat hasil
eksekusi.
#include <iostream.h>
#include <string.h>
struct Tanggal
{
int tanggal;
int bulan;
int tahun;
};
class Orang
{
private:
char* nama;
Tanggal tglLahir;
public:
Orang(char* nama,Tanggal tglLahir);
~Orang();
void info();
};
class Karyawan:public Orang
{
private:
int nip;
public:
Karyawan(int nip,char* nama,Tanggal tglLahir);
~Karyawan();
void info;
};
int main(){
Tanggal tgl_lahir={23,6,1975};
Karyawan pegBaru(12364,"Indra Lesmana",tgl_lahir);
pegBaru.info();
cout<<"Sebelum main() berakhir..."<<endl;
return 0;
}

11
 Orang::Orang(char* nama,Tanggal tglLahir){
Orang::nama=new char[35];
strcpy(Orang::nama,nama);
Orang::tglLahir=tglLahir;
cout<<"Konstruktor orang dijalankan"<<endl;
}
Orang::~Orang(){
delete[]Orang::nama;
cout<<"Destruktor orang dijalankan..."<<endl;
}
void Orang::info(){
cout<<"nama: "<<Orang::nama<<endl;
cout<<"Tanggal
lahir:"<<Orang::tglLahir.tanggal<<"/"<<Orang::tglLahir.bulan"/"<<Orang::tglLahir.tah
un<<endl;
}
Karyawan::Karyawan(int nip,char* nama,Tanggal tglLahir):Orang(nama,tglLahir){
Karyawan::nip=nip;
cout<<"Konstruktor Karyawan dijalankan..."<<endl;
}
Karyawan::~Karyawan(){
cout <<"Destruktor Karyawan dijalankan..."<<endl;
}
void Karyawan::info(){
cout<<endl;
cout<<"NIP:"<<Karyawan::nip<<endl;
Orang::info();
cout<<endl;
}

C.6 Ketikkan dan eksekusi kode sumber: ParObjek.cpp, kemudian catat hasil
eksekusi.
#include <iostream.h>
#include <string.h>
class Buku
{
private:
char judul[35];
char pengarang[35];

12
public:
Buku(char* judul,char *pengarang);
void info();
};
int main(){
Buku novel("Badai pasti berlalu","Marga T.");
infoBuku(novel);
return 0;
}
Buku::Buku(char* judul, char *pengarang){
strcpy(Buku::judul,judul);
strcpy(Buku::pengarang,pengarang);
}
void Buku::info(){
cout<<"judul:"<<Buku::judul<<endl;
cout<<"pengarang:"<<Buku::pengarang<<endl;
}
void infoBuku(Buku buku){
cout<<"__INFORMASI BUKU__"<<endl;
buku.info();
}

C.7 Ketikkan dan eksekusi kode sumber: BalikObj.cpp, kemudian catat hasil
eksekusi.
#include <iostream.h>
#include <string.h>
class Buah
{
private:
int apel;
int jeruk;
public:
Buah(int jumlahApel=0,int jumlahJeruk=0);
void info();
Buah tambah(Buah b);
};
int main(){
Buah buah1(5,3);
Buah buah2(4,1);
Buah buah3;
buah3=buah1.tambah(buah2);
cout<<"buah1:"<<endl;
buah1.info();
cout<<"buah2:"<<endl;
buah2.info();
cout<<"buah3:"<<endl;
buah3.info();
return 0;
}
Buah::Buah(int jumlahApel,int jumlahJeruk){
apel=jumlahApel;
jeruk=jumlahJeruk;

13
 }
void Buah::info(){
cout<<"apel:"<<apel<<"jeruk"<<jeruk<<endl;
}
Buah Buah::tambah(Buah b){
Buah tmp;
tmp.apel+=b.apel;
tmp.jeruk+=b.jeruk;
return tmp;
}

C.8 Ketikkan dan eksekusi kode sumber: PtrThis.cpp, kemudian catat hasil
eksekusi.
#include <iostream.h>
#include <string.h>
class PersegiPanjang
{
private:
double panjang;
double lebar;
public:
PersegiPanjang(double panjang,double lebar);
double luas();
bool lebihBesar(PersegiPanjang kotak);
};
int main(){
PersegiPanjang kotakA(20,30);
PersegiPanjang kotakB(21.5,28.5);
if (kotakA.lebihBesar(kotakB))
{
cout<<"kotak A lebih besar"<<endl;
}
else{
cout<<"kotak B lebih besar"<<endl;
}
return 0;
}
PersegiPanjang::PersegiPanjang(double panjang, double lebar){
PersegiPanjang::panjang=panjang;
PersegiPanjang::lebar=lebar;
}
double PersegiPanjang::luas(){
return panjang*lebar;

14
 }
bool PersegiPanjang::lebihBesar(PersegiPanjang kotak){
return this->luas()>kotak.luas();
}

C.9 Ketikkan dan eksekusi kode sumber: DataStatis.cpp, kemudian catat hasil
eksekusi.
#include <iostream.h>
#include <string.h>
class Monster
{
private:
static int jumlah;
public:
Monster();
void info();
};
int Monster::jumlah=0;
int main(){
Monster mon1;
mon1.info();
Monster mon2;
mon2.info();
Monster mon3;
mon3.info();
return 0;
}
Monster::Monster(){
jumlah++;
}
void Monster::info(){
cout<<"jumlah Monster:"<<Monster::jumlah<<endl;
cout<<endl;
}

15
D Percobaan
D.1 Buatlah diagram kelas setiap tugas pendahuluan diatas
D.1.1 Diagram AndreRZ_06_KelasPeg.cpp

D.1.2 Diagram AndreRZ_06_Konstruktor.cpp

D.1.3 Diagram AndreRZ_06_BawaanPar.cpp

16
D.1.4 Diagram AndreRZ_06_Destruktor.cpp

D.1.5 Diagram AndreRZ_06_Pewarisan.cpp

D.1.6 Diagram AndreRZ_06_ParObjek.cpp

D.1.7 Diagram AndreRZ_06_BalikObj.cpp

17
D.1.8 Diagram AndreRZ_06_PrtThis.cpp

D.1.9 Diagram AndreRZ_06_DataStatis.cpp

18
D.2 Buatlah kode sumber lain yang berbeda dengan yang telah ada di
tugas pendahuluan sesuai dengan judulnya.
D.2.1 AndreRZ_06_Kelas dan Objek

202020402006, AndreRinaldiZ ,

19
 2020204020006
AndreRinaldiZ

D.2.2 AndreRZ_06_Konstruktor

(176, “AndreRinaldiZ”, 100);

20
 176
AndreRinaldiZ

21
D.2.3 AndreRZ_06_Destruktor

22
D.2.5 AndreRZ_06_Parameter Berupa Objek

23
D.3 Buatlah Analisa Percobaan D.2
D.3.1 Kelas
Pada percobaan ini, Kelas berisi objek-objek yang terdiri dari private dan public.
Pada class ada tipe data int, nama[], dan bool. Masing-masing memiliki Set dan Get
pada public. Kemudian ketika diamankan dengan int main(), maka digunakan untuk
dua tipe data, yaitu mhsPoliteknik dan mhsUnivsumut untuk memasukkan dua nama
mahasiswa. Pada mhsPoliteknik kita menggunakan tipe data NIM, Nama dan Jenis
Kelamin, sedangkan pada mhsUnivsumut kita hanya menggunakan Nama. Pada
mhsPoliteknik terdapat tipe data bool yang berfungsi untuk mengetahui apakah tipe
datanya true atau false dengan memasukkan “Pria”:”Wanita”, dalam inisialisasi yang
dimasukkan adalah true. Maka pada Output akan keluar “Pria”.
D.3.2 Konstruktor
Percobaan ini sama seperti Kelas, hanya saja digunakan untuk satu inisialisasi.
Kelas berisi objek-objek yang terdiri dari private dan public. Pada class ada tipe data
int, nama[], dan double. Masing-masing memiliki Set dan Get pada public. Kemudian
ketika diamankan dengan int main(), maka digunakan untuk satu tipe data, yaitu
ptjKanada.. Pada ptjKanada kita menggunakan tipe data Tinggi, Nama dan Berat.
Pada ptjKanada terdapat tipe data int untuk Tinggi Badan, nama untuk Nama, dan
double untuk Berat Badan.
D.3.3 Destruktor
Pada percobaan ini, kita membuat fungsi khusus dalam class yang dijalankan
secara otomatis ketika objek musnah. class Coba terdiri dari private: char id[15]., dan
public: Coba (char id[]), ~Coba(). Tanda ~ digunakan sebagai destructor. Setelah kode
program dijalankan, maka akan keluar hasil yang terdiri dari Id; Alpha. Konstruktor
dijalankan…, pembatas destructor adalah tesFungsi() dan Ketika main(). Pada
Ketika main(), maka objek dengan identitas Beta musnah setelah fungsi main()
berakhir dijalankan.
D.3.5 Parameter Berupa Objek
Pada percobaan ini, objek juga bisa digunakan sebagai parameter. class nya adalaha
Buku. setelah kode program diketik dan dijalankan, maka akan keluar output seperti diatas.
void infoBuku(Buku buku) harus digunkan sehingga program bisa berfungsi. Kemudian pada
infoBuku(novel) adalah parameter berupa objek yang bisa dijalankan setelah menggunakan
void.

24
 DAFTAR PUSTAKA
Abdul Kadir. 2004. Panduan Pemrograman Visual C++. Yogyakarta, Penerbit ANDI
Yogyakarta.

25