C++ - Inheritance (Pewarisan Bertingkat dan Pewarisan Ganda) - nblognlife
» » C++ - Inheritance (Pewarisan Bertingkat dan Pewarisan Ganda)

C++ - Inheritance (Pewarisan Bertingkat dan Pewarisan Ganda)

— —

Contoh Program Inheritance (Pewarisan Bertingkat dan Pewarisan Ganda)

PEWARISAN BERTINGKAT
     OOP C++ memungkinkan untuk melakukan pewarisan bertingkat. Misalnya, Kelas C mewarisi sifat Kelas B yang telah mewarisi sifat kelas A.  
Berikut adalah contoh program sederhana yang menggunakan pewarisan bertingkat:
/*
      C++ - Inheritance (Pewarisan Bertingkat dan Pewarisan Ganda)
      Microsoft Visual Studio Express 2012
      [RS]
*/
#include <iostream>
#include <conio.h>
using namespace std;

//Kelas MakhlukHidup
class MakhlukHidup
{
private:
      bool bernafas, bergerak;

public:
      //kontruktor
      MakhlukHidup(bool bernafas, bool bergerak);
      void info();
};

//Kelas Hewan
class Hewan : public MakhlukHidup
{
private:
      char nama[15];
      char habitat[15];

public:
      //konstruktor
      Hewan(bool bernafas, bool bergerak, char *nama, char *habitat);
      void info();
};

//Kelas Burung
class Burung : public Hewan
{
private:
      char ciri_khusus[20];

public:
      //konstruktor
      Burung(bool bernafas, bool bergerak, char *nama, char *habitat, char *ciri_khusus);
      void info();
};

int main()
{
      //menciptakan objek "brg" sekaligus melakukan inisialisasi melalui Konstruktor dari Kelas Burung, Kelas Hewan, dan Kelas MakhlukHidup
      Burung brg(true, true, "Burung", "Hutan", "Bulu dan Sayap");

      cout<<"INHERITANCE PADA C++ - PEWARISAN BERTINGKAT"<<endl;
      cout<<"-------------------------------------------"<<endl;
      cout<<endl;
      cout<<"Berikut adalah salah satu jenis hewan : "<<endl;

      //memanggil fungsi info() pada kelas burung
      brg.info();

      _getche();
      return 0;
}

//konstruktor MakhlukHidup
MakhlukHidup::MakhlukHidup(bool bernafas, bool bergerak)
{
      //inisialisasi
      MakhlukHidup::bernafas = bernafas;
      MakhlukHidup::bergerak = bergerak;
}

void MakhlukHidup::info()
{
      if(bernafas==true && bergerak==true)
            cout<<"Termasuk makhluk hidup karena bernafas dan bergerak"<<endl;
}

Hewan::Hewan(bool bernafas, bool bergerak, char *nama, char *habitat) : MakhlukHidup(bernafas, bergerak)
{
      //inisialisasi
      strcpy(Hewan::nama, nama);
      strcpy(Hewan::habitat, habitat);
}

void Hewan::info()
{
      //memanggil fungsi info() pada kelas MakhlukHidup
      MakhlukHidup::info();
      cout<<"Nama        : "<<nama<<endl;
      cout<<"Habitat     : "<<habitat<<endl;
}

Burung::Burung(bool bernafas, bool bergerak, char *nama, char *habitat, char *ciri_khusus) : Hewan(bernafas, bergerak, nama, habitat)
{
      //inisialisasi
      strcpy(Burung::ciri_khusus, ciri_khusus);
}

void Burung::info()
{
      //memanggil fungsi info() pada kelas Hewan
      Hewan::info();
      cout<<"Ciri Khusus : "<<ciri_khusus<<endl;
}

Output
INHERITANCE PADA C++ - PEWARISAN BERTINGKAT
-------------------------------------------

Berikut adalah salah satu jenis hewan :
Termasuk makhluk hidup karena bernafas dan bergerak
Nama        : Burung
Habitat     : Hutan
Ciri Khusus : Bulu dan Sayap

Penjelasan
  • Kelas Burung mewarisi anggota dari Kelas Hewan yang telah mewarisi anggota dari kelas MakhlukHidup. Burung merupakan Hewan dan Hewan merupakan makhluk hidup.
  • Kelas Burung mewarisi fungsi anggota info() dari kelas Hewan dan Kelas MakhlukHidup. Agar tidak rancu dan membuat bingung compiler, apabila fungsi info() yang ingin kita panggil adalah fungsi anggota info() dari kelas Hewan maka gunakan Hewan::info();, sedangkan untuk mengakses fungsi anggota info() dari kelas MakhlukHidup maka gunakan MakhlukHidup::info();.
  • Perhatikan pernyataan MakhlukHidup::bernafas = bernafas;, pada pernyataan seperti ini MakhlukHidup::bernafas mengacu pada variabel bernafas yang dideklarasikan pada kelas MakhlukHidup, sedangkan bernafas mengacu pada variabel yang berada pada parameter fungsi. Hal tersebut dilakukan ketika variabel/fungsi memiliki nama yang sama agar compiler dapat secara jelas mengetahui variabel/fungsi mana yang kita maksud.


PEWARISAN GANDA
     Selain memungkinkan untuk melakukan pewarisan bertingkat, C++ juga dapat melakukan pewarisan ganda, yakni pewarisan yang mengizinkan suatu kelas mewarisi lebih dari satu kelas. Analoginya, seorang anak dapat mewarisi bentuk wajah, warna kulit dari Ayahnya serta bentuk mata dan kecerdasan dari Ibunya.

Berikut adalah contoh program sederhana yang menggunakan pewarisan ganda:
Header kelas.h :
#ifndef __kelas
#define __kelas

#include <iostream>
#include <iomanip>
using namespace std;

//kelas Ayah
class Ayah
{
private:
      char bentuk_wajah[15];
      char warna_kulit[15];

public:
      //Konstruktor
      Ayah(char *bentuk_wajah, char *warna_kulit)
      {
            cout<<"//Konstruktor kelas Ayah dijalankan"<<endl;
            strcpy(Ayah::bentuk_wajah, bentuk_wajah);
            strcpy(Ayah::warna_kulit, warna_kulit);
      }

      //Destruktor
      ~Ayah()
      {
            cout<<"//Destruktor kelas Ayah dijalankan"<<endl;
            _getche();
      }

      void info()
      {
            cout<<"Bentuk wajah : "<<setiosflags(ios::left)<<setw(15)<<bentuk_wajah<<" (Diwariskan dari Ayah)"<<endl;
            cout<<"Warna kulit  : "<<setiosflags(ios::left)<<setw(15)<<warna_kulit<<" (Diwariskan dari Ayah)"<<endl;
      }
};

//Kelas Ibu
class Ibu
{
private:
      char bentuk_mata[15];
      bool kecerdasan;

public:
      //Konstruktor
      Ibu(char *bentuk_mata, bool kecerdasan)
      {
            cout<<"//Konstruktor kelas Ibu dijalankan"<<endl;
            strcpy(Ibu::bentuk_mata, bentuk_mata);
            Ibu::kecerdasan = kecerdasan;
      }

      //Destruktor
      ~Ibu()
      {
            cout<<"//Destruktor kelas Ibu dijalankan"<<endl;
      }

      void info()
      {
            cout<<"Bentuk mata  : "<<setiosflags(ios::left)<<setw(15)<<bentuk_mata<<" (Diwariskan dari Ibu)"<<endl;

            if(kecerdasan == true)
                  cout<<"Kecerdasan   : "<<setiosflags(ios::left)<<setw(15)<<"YA"<<" (Diwariskan dari Ibu)"<<endl;
      }
};

#endif

Main :
/*
      C++ - Inheritance (Pewarisan Bertingkat dan Pewarisan Ganda)
      Microsoft Visual Studio Express 2012
      [RS]
*/

/*
      header iostream dan using namespace std di sini boleh dihilangkan,
      karena sudah disertakan pada header "kelas.h"
*/
#include <iostream>
#include <conio.h>
#include "kelas.h"
using namespace std;

//kelas Anak
class Anak : public Ayah, Ibu
{
private:
      char nama[15];
      int umur;

public:
      //konstruktor
      Anak(char *nama, int umur, char *bentuk_wajah, char *warna_kulit, char *bentuk_mata, bool kecerdasan) : Ayah(bentuk_wajah, warna_kulit), Ibu(bentuk_mata, kecerdasan)
      {
            cout<<"//Konstruktor kelas Anak dijalankan"<<endl;
            strcpy(Anak::nama, nama);
            Anak::umur = umur;
      }

      //destruktor
      ~Anak()
      {
            cout<<"//Destruktor kelas Anak dijalankan"<<endl;
      }

      void info()
      {
            cout<<"Nama         : "<<nama<<endl;
            cout<<"Umur         : "<<umur<<" tahun"<<endl;
            Ayah::info();
            Ibu::info();
      }
};

int main()
{
      //penciptaan objek "ank" sekaligus melakukan penginisialisasian
      Anak ank("JOE", 20, "Oval", "Sawo matang", "Bulat", true);

      cout<<endl;
      cout<<"INHERITANCE PADA C++ - PEWARISAN GANDA"<<endl;
      cout<<"--------------------------------------"<<endl;
      cout<<endl;
     
      ank.info();

      cout<<endl;
      return 0;
}

Output
//Konstruktor kelas Ayah dijalankan
//Konstruktor kelas Ibu dijalankan
//Konstruktor kelas Anak dijalankan

INHERITANCE PADA C++ - PEWARISAN GANDA
--------------------------------------

Nama         : JOE
Umur         : 20 tahun
Bentuk wajah : Oval           (Diwariskan dari Ayah)
Warna kulit  : Sawo matang    (Diwariskan dari Ayah)
Bentuk mata  : Bulat          (Diwariskan dari Ibu)
Kecerdasan   : YA             (Diwariskan dari Ibu)

//Destruktor kelas Anak dijalankan
//Destruktor kelas Ibu dijalankan
//Destruktor kelas Ayah dijalankan

Penjelasan
Ketika objek ank diciptakan secara otomatis konstruktor akan dijalankan. Lalu bagaimana urutannya? Seperti yang terlihat pada output program konstruktor kelas dasar pertama (Ayah), kemudian konstruktor kelas dasar kedua (Ibu), baru konstruktor kelas turunan (Anak) yang dijalankan. Destruktor kelas turunan (Anak) dijalankan terlebih dahulu, kemudian baru destruktor kelas dasar kedua (Ibu) dan pertama (Ayah) dijalankan.


*NB : Apabila masih bingung dengan bentuk pewarisan kedua program di atas, silahkan modifikasi hak akses variabel pada setiap kelas dari private ke protected/public dan modifikasi juga programnya seperti program pertama pada postingan "C++ - Inheritance (Dasar Pewarisan)".

 Baca juga untuk memudahkan pemahaman:
1. C++ - Inheritance (Dasar Pewarisan)
2. Mengenal OOP pada C++
3. Public, Protected, Private pada OOP
4. Konstruktor dan Destruktor pada OOP C++

[RS]

Klik Like & Share jika postingan ini bermanfaat
Apa tanggapan Anda?

Berikan tanggapan Anda melalui kolom komentar yang telah disediakan.
- Gunakan bahasa yang sopan;
- Saat menjadikan postingan pada blog ini sebagai referensi, jangan lupa mencantumkan sumbernya (link dari blog ini).

Jika blog ini bermanfaat jangan lupa memberikan 'like' atau 'share' untuk mendapatkan update terbaru.

Terima kasih