Polymorphism dalam C++ - Virtual Void

Konstruksi polimorfisme dalam pemrograman berorientasi obyek memungkinkan untuk mengadakan ikatan dinamis(juga disebut ikatan tunda, atau ikatan akhir). Apabila fungsi-fungsi dari suatu kelas dasar didefinisikan ulang atau ditindih pada kelas turunan, maka obyek-obyek yang dihasilkan hirarki kelas berupa obyek polimorfik. Polimorfik artinya mempunyai banyak bentuk atau punya kemampuan untuk mendefinisi banyak bentuk.

Polimorfisme merupakan suatu konsep yang menyatakan bahwa sesuatu yang sama dapat memiliki berbagai bentuk dan perilaku yang berbeda. Dalam hal ini polimorfisme merupakan suatu sifat menyandarkan pada kesamaan nama dalam program. Pengenal data, instans, dan metode, bahkan nama fungsi dapat dibuat dengan nama yang sama untuk kegunaan yang berbeda.

#include <iostream>
#include <conio.h>
#include <string.h>
using namespace std;

class Manusia
{
      protected:
                string nama;
                string alamat;
      public:
                Manusia(string nama, string alamat):nama(nama),alamat(alamat){}
                
      virtual void judul()
      {
           cout<<"\n Kelas Manusia!";
      }
      
      virtual void tampil_data() //menggunakan fungsi virtual
      {
              cout<<"\n=======================";
              cout<<"\n\t MANUSIA"<<endl;
              cout<<"=======================";
              cout<<"\nNama       : "<<nama<<endl;
              cout<<"Alamat     : "<<alamat<<endl;
              cout<<"======================="<<endl;
      }
};

class Mahasiswa:public Manusia
{
      private:
              string nim;
              string jurusan;
      public:
             Mahasiswa(string nim, string nama, string jurusan, string alamat):Manusia(nama,alamat),nim(nim),jurusan(jurusan){}
             
      void judul()
      {
           cout<<"\n\n Kelas Mahasiswa! ";
      }
      
      void tampil_data()
      {
           cout<<"\n===============================";
           cout<<"\n\t MAHASISWA"<<endl;
           cout<<"===============================";
           cout<<"\n NIM       : "<<nim<<endl;
           cout<<" Nama      : "<<nama<<endl;
           cout<<" Jurusuan  : "<<jurusan<<endl;
           cout<<" Alamat    : "<<alamat<<endl;
           cout<<"==============================="<<endl;
      }
};

class Pegawai:public Manusia
{
      private:
              string nip;
              string jabatan;
      public:
             Pegawai(string nip, string nama, string alamat, string jabatan):Manusia(nama,alamat),nip(nip),jabatan(jabatan){}
             
      void judul()
      {
           cout<<"\n\n Kelas Pegawai!";
      }
      
      void tampil_data()
      {
           cout<<"\n=============================";
           cout<<"\n\t   PEGAWAI"<<endl;
           cout<<"=============================";
           cout<<"\n NIP     : "<<nip<<endl;
           cout<<" Nama    : "<<nama<<endl;
           cout<<" Alamat  : "<<alamat<<endl;
           cout<<" Jabatan : "<<jabatan<<endl;
           cout<<"============================="<<endl;
      }
};

int main()
{   
    Manusia man1("FAJAR","MALANG");
    Mahasiswa mhs1("201381070","FAJAR JATI","TEKNIK INFORMATIKA","JAKARTA");
    Pegawai peg1("4321.8765.1234","JATI","BANYUWANGI","MANAGER");
    Manusia *man; //definisi pointer ke objek berkelas manusia
    
    man=&man1; //menunjuk ke objek berkelas mahasiswa
    man->judul();
    man->tampil_data();
    
    man=&mhs1; //menunjuk ke objek berkelas mahasiswa
    man->judul();
    man->tampil_data();
    
    man=&peg1; //menunjuk ke objek pegawai
    man->judul();
    man->tampil_data();
    getch();
} 

Salah satu bentuk polimorfisme pada C++ dapat digunakan pada fungsi atau operator dan dikenal sebagai istilah overloading. Overloading terhadap fungsi akan memungkinkan sebuah fungsi dapat menerima bermacam-macam tipe dan memberikan nilai balik yang bervariasi pula.

Prototype virtual digunakan untuk memanggil fungsi kelas induk, apabila tidak menggunakan prototype virtual ini fungsi kelas induk tidak dapat dipanggil. Sebuah metode yang dideklarasikan menggunakan kata kunci virtual ini biasanya merupakan sebuah metode yang akan di overloading di kelas turunannya. Meskipun untuk pada kasus tertentu  penambahan kata kunci ini tidak dibutuhkan, seperti dalam program kita ini apabila kata kunci virtual ini dihilangkan maka tidak terjadi masalah.