C++ SAMPLE CODE 6

 #include <iostream>

using namespace std;

class B

{

   public:

      void Tampil()

  {

         cout<<"Apakah Anda akan belajar C++?"<<endl;

  }

}; //akhir dari kelas B

class D : public B

{

   public :

      void Tampil()

  {

         cout<<"Saya juga belajar C++"<<endl;

  }

}; //akhir dari kelas D

int main()

{ 

   B b; //b adalah sebuah objek dari kelas basis B

   D d; //d adalah sebuah objek dari kelas terderivasi D

   B *bptr; //pointer ke kelas B

   bptr = &(B)b; //inisialisasi pointer ke objek dari kelas B

   bptr -> Tampil(); //fungsi Tampil() dipanggil dengan pointer

   bptr = & d; //pointer ditugasi alamat dari d.

   bptr -> Tampil(); //pointer dipakai untuk memanggil fungsi

   return 0;

}

===========================================

#include <iostream>

using namespace std;

class B

{

   public:

      void Tampil()

  { 

  cout<<"Apakah Anda akan belajar C++?"<<endl;

  }

}; //akhir dari kelas B

class D : public B

{

   public :

      void Tampil()

  {

         cout<<"Saya juga belajar C++"<<endl;

  }

}; //akhir dari kelas D

int main()

{ 

   B b; //b dideklarasikan sebagai objek dari kelas B

   D d; //d dideklarasikan sebagai objek dari kelas D

   D *dptr = &(D)d; //pointer ke kelas D

   dptr -> Tampil();

   dptr = & b; //dptr ditugasi alamat dari kelas basis

//ini akan menghasilkan error

   dptr -> Tampil();

return 0;

}

====================================

#include <iostream>

using namespace std;

class B

{

   public:

      void Tampil()

  { 

  cout<<"Apakah Anda akan belajar C++?"<<endl;

  }

}; //akhir dari kelas B

class D : public B

{

   public :

      void Tampil()

  {

         cout<<"Saya juga belajar C++"<<endl;

  }

}; //akhir dari kelas D

int main()

{ 

   B b; //b dideklarasikan sebagai objek dari kelas B

   D d; //d dideklarasikan sebagai objek dari kelas D

   B *bptr = & (B) b ; //pointer ke kelas B

   D *dptr = &(D) d ; // pointer ke kelas D

   bptr -> Tampil();

   dptr -> Tampil();

return 0;

}

=======================================

#include <iostream>

using namespace std;

class B

{

   public:

      virtual void Tampil()

  { 

  cout<<"Apakah Anda akan belajar C++?"<<endl;

  }

}; //akhir dari kelas B

class D : public B

{

   public :

      void Tampil()

  {

         cout<<"Saya juga belajar C++"<<endl;

  }

}; //akhir dari kelas D

int main()

{ 

   B b; //b dideklarasikan sebagai objek dari kelas B

   D d; //d dideklarasikan sebagai objek dari kelas D

   B *bptr = &(B) b ; //pointer kelas basis

   bptr -> Tampil(); //statemen untuk memanggil fungsi kelas basis

   bptr = & d; //pointer kelas basis ditugasi alamat dari objek terderivasi d

   bptr -> Tampil(); //memanggil fungsi Tampil() dari kelas terderivasi

   return 0;

}

=======================================

#include <iostream>

using namespace std;

class B

{

   public:

      virtual void Tampil()

  {

         cout<<"Tampil dari kelas B dipanggil"<<endl;

  }

}; //akhir dari kelas B

class D1 : public B

{ 

   public:

      void Tampil()

  {

         cout<<"Tampil dari kelas D1 dipanggil"<<endl;

  }

} ; //akhir dari kelas D1

class D2 : public B

{

   public :

      void Tampil ()

  { 

         cout<<"Tampil dari kelas D2 dipanggil"<<endl;

  }

}; //akhir dari kelas D2

int main ()

{

   B b; //b adalah sebuah objek dari kelas B

   B *bptr = &b; //pointer kelas basis

   D1 d1; //d1 dan d2 adalah objek dari kelas D1

   D2 d2; //dan kelas D2 

   bptr ->Tampil();

   bptr = &d1; //pointer kelas basis ditugasi alamat

//dari objek kelas terderivasi

   bptr -> Tampil();

   bptr = &d2;

   bptr ->Tampil() ;

   return 0 ;

}

==========================================

#include <iostream>

using namespace std;

class B

{

   public:

      virtual void Tampil()

  {

         cout<<"Tampil dari kelas B dipanggil"<<endl;

  }

}; //akhir dari kelas B

class D1 : public B

{ 

   public:

      void Tampil()

  {

         cout<<"Tampil dari kelas D1 dipanggil"<<endl;

  }

} ; //akhir dari kelas D1

class D2 : public B

{

   public :

      void Tampil()

  { 

         cout<<"Tampil dari kelas D2 dipanggil"<<endl;

  }

}; //akhir dari kelas D2

class D3 : public B

{

   public :

      void Tampil()

  { 

         cout<<"Tampil dari kelas D3 dipanggil"<<endl;

  }

}; //akhir dari kelas D3

int main ()

{

   B b;

   D1 d1;

   D2 d2;

   D3 d3;

   B *bptr[] = {&b , &d1, &d2, &d3}; //Array yang memuat pointer-pointer kelas B

   for (int i = 0; i<4; i++)

      bptr[i] ->Tampil();

   return 0 ;

}

=======================================

#include <iostream>

using namespace std;

class B

{ 

   public :

      virtual void Tampil() = 0;

} ; //akhir dari kelas B

class D1 : public B // Derived class

{ 

   public :

      void Tampil(){ cout <<"Tampil() dari kelas D1 dipangil"<<endl;}

};

int main()

{ 

   B b ; //objek b dari kelas B dideklarasikan yang menghasilkan error

   B *bptr = &b;

   bptr -> Tampil();

   return 0 ;

}

=========================================

#include <iostream>

using namespace std;

class BangunBiasa {

   int sisi; //private secara default

   public:

      void set_sisi(int a)

  { 

         sisi = a;

  }

      int get_sisi() 

  {

         return sisi;

  }

      virtual double Luas (void) =0;

}; //akhir dari kelas BangunBiasa

class Lingkaran : public BangunBiasa

{

   public:

      double Luas (void)

  {

         return (3.14159*get_sisi()*get_sisi()/4);

  }

}; //akhir dari kelas Lingkaran

class Persegi : public BangunBiasa

{

   public:

      double Luas (void)

  {

         return (get_sisi()*get_sisi());

  }

}; //akhir dari kelas Persegi

int main ()

{ 

   double A1, A2;

   Persegi S1;

   Lingkaran C1;

   BangunBiasa* RS1 = & S1;

   BangunBiasa* RS2 = & C1;

   (*RS1).set_sisi(10);

   RS2 -> set_sisi(10);

   A1 = (*RS1).Luas(); //(*RS1).Luas() dan RS1 ->Luas() ekivalen

   A2 = RS2 -> Luas ();

   cout<<"A1 = "<<A1<<"\t A2 = "<<A2<<endl;

   return 0;

}

===========================================

#include <iostream>

using namespace std;

class B

{

   protected:

      int bx;

   public :

      B() {} //konstruktor kosong dari kelas basis

      B(int m) 

  { 

         bx = m ; //konstruktor dari kelas basis

         cout<<"Konstruktor dari kelas B dipanggil"<<endl;

  }

      virtual int Perkalian()

  {

         return 2*bx;

  }

  //fungsi destruktor tidak dideklarasikan virtual

      ~ B() 

  { 

         cout<<"Destruktor dari kelas B dipanggil"<<endl;

  }

}; //akhir dari kelas B

class D1

{

   protected :

      int D1x ;

   public :

      D1 () {} //konstruktor kosong (default) dari D1

      D1(int n)

  { 

         D1x = n; // constructor of class D1

         cout<<"Konstruktor dari D1 dipanggil"<<endl;

  }

      int getD1x()

  { 

         return D1x;

  }

      

  ~D1() 

  { 

         cout<<"Destruktor dari D1 dipanggil"<<endl;

  }

};

class D2

{

   protected :

      int D2x ;

   public :

      D2(){}

      D2(int p) 

  { 

         D2x = p ;

         cout <<"Konstruktor dari D2 dipanggil"<<endl;

  }

      int getD2x()

  { 

         return D2x;

  }

      ~D2()

  { 

         cout <<"Destruktor dari D2 dipanggil"<<endl;

  }

};

class D3 : public B

{

   int D3x; // private secara default

   public :

      D3() {}

      D1 d1; //d1 dideklarasikan sebagai objek dari kelas D1

      D2 d2; //d2 dideklarasikan sebagai objek dari kelas D2

      

  D3( int p, int q , int r, int s): B(p), d1(q), d2(r) 

  { 

         D3x = s;

         cout<<"Konstruktor dari D3 dipanggil"<< endl;

  }

  int Perkalian()

  { 

         return D3x * d2.getD2x() * d1.getD1x() * bx;

  }

      ~D3() 

  { 

         cout<<"Destruktor dari D3 dipanggil"<<endl;

  }

};

int main ()

{

   B *Bp ;

   Bp = new B(10); //objek dinamis yang diciptakan dengan operator new

   cout<<"Perkalian dari B = "<<Bp ->Perkalian()<<endl;

   Bp = new D3(2, 3, 4, 5);

   cout<<"Perkalian = "<<Bp -> Perkalian()<<endl;

   delete Bp; //penghapusan pointer kelas basis

   return 0 ;

}

===============================================

#include <iostream>

using namespace std;

class B

{

   protected:

      int bx;

   public :

      B() {} //konstruktor kosong dari kelas basis

      B(int m) 

      { 

         bx = m ; //konstruktor dari kelas basis

         cout<<"Konstruktor dari kelas B dipanggil"<<endl;

      }

      virtual int Perkalian()

      {

         return 2*bx;

      }

      //fungsi destruktor tidak dideklarasikan virtual

      virtual ~B() 

      { 

         cout<<"Destruktor dari kelas B dipanggil"<<endl;

      }

}; //akhir dari kelas B

class D1

{

   protected :

      int D1x ;

   public :

      D1 () {} //konstruktor kosong (default) dari D1

      D1(int n)

      { 

         D1x = n; // constructor of class D1

         cout<<"Konstruktor dari D1 dipanggil"<<endl;

      }

      int getD1x()

      { 

         return D1x;

      }

      

  ~D1() 

      { 

         cout<<"Destruktor dari D1 dipanggil"<<endl;

      }

};

class D2

{

   protected :

      int D2x ;

   public :

      D2(){}

      D2(int p) 

      { 

         D2x = p ;

         cout <<"Konstruktor dari D2 dipanggil"<<endl;

      }

      int getD2x()

      { 

         return D2x;

      }

      ~D2()

      { 

         cout <<"Destruktor dari D2 dipanggil"<<endl;

      }

};

class D3 : public B

{

   int D3x; // private secara default

   public :

      D3() {}

      D1 d1; //d1 dideklarasikan sebagai objek dari kelas D1

      D2 d2; //d2 dideklarasikan sebagai objek dari kelas D2

      

      D3(int p, int q , int r, int s): B(p), d1(q), d2(r) 

      { 

         D3x = s;

         cout<<"Konstruktor dari D3 dipanggil"<< endl;

      }

      int Perkalian()

      { 

         return D3x * d2.getD2x() * d1.getD1x() * bx;

      }

      ~D3() 

      { 

         cout<<"Destruktor dari D3 dipanggil"<<endl;

      }

};

int main ()

{

   B *Bp ;

   Bp = new B(10); //objek dinamis yang diciptakan dengan operator new

   cout<<"Perkalian dari B = "<<Bp ->Perkalian()<<endl;

   Bp = new D3(2, 3, 4, 5);

   cout<<"Perkalian = "<<Bp -> Perkalian()<<endl;

   delete Bp; //penghapusan pointer kelas basis

   return 0 ;

}

=========================================================

#include <iostream>

using namespace std;

class B

{ 

   public:

      void Tampil() {cout<<"Fungsi Tampil() dari kelas B dipanggil"<<endl;}

};

class D1 : public B

{};

class D2 : public B

{};

class D3 : public D2, public D1

{};

int main()

{ 

   D3 d3;

   d3.Tampil();

   return 0;

}

================================

#include <iostream>

using namespace std;

class B

{ 

   public:

      void Tampil() {cout<<"Fungsi Tampil() dari kelas B dipanggil"<<endl;}

};

class D1 : virtual public B

{};

class D2 : virtual public B

{};

class D3 : public D2, public D1

{};

int main()

{ 

   D3 d3;

   d3.Tampil();

   return 0;

}

================================================

#include <iostream>

using namespace std;

class B

{ 

   public:

      virtual char Tipe(){return 'B';}

};

class C : public B

{ 

   public:

      char Tipe(){return 'C';}

};

class D : public B

{

   public:

      char Tipe(){return 'D';}

};

int main()

{ 

   B b;

   C c ;

   D d ;

   B* pb = &b;

   cout<<"Tipe dari pb sekarang adalah : "<< pb -> Tipe()<<endl;

   pb = & c;

   cout<<"Tipe dari pb sekarang adalah : "<<pb -> Tipe()<<endl;

   pb = & d;

   cout<<"Tipe dari pb sekarang adalah : "<<pb -> Tipe()<<endl;

   return 0 ;

}

===============================================

#include <iostream>

# include <typeinfo> //file header untuk typeid()

using namespace std;

class B

{};

class D1 : public B

{};

class D2 : public D1

{};

int main ()

{ 

   D2 d2;

   D1 d1;

   if (typeid( d1) == typeid (d2))

      cout<<"Kedua objek sama"<<endl;

   else

      cout<<"Kedua objek berbeda tipe"<<endl;

   cout<<"Tipe dari d1 adalah "<<typeid(d1).name()<<endl;

   cout<<"Tipe dari d2 adalah "<<typeid(d2).name()<<endl;

   return 0;

}

=====================================

#include <iostream>

using namespace std;

class B

{ 

   public:

      B() {};

      virtual void Fungsi(){};

};

class D1 : public B

{}; 

class D2 : public B

{};

class D3 : public B

{};

int main ()

{ 

   B* Ab[3];

   Ab[0] = new D1;

   Ab[1] = new D2;

   Ab[2] = new D3;

   for (int i =0; i<3; i++)

   {

      D2 *ptrd2 = dynamic_cast<D2*>(Ab[i]);

      

  if (ptrd2 != 0 )

         cout<<"Objek D2 ditemukan\n"; 

   }

   return 0; 

}

===============================

#include <iostream>

using namespace std;

class Basis

{ 

   public :

      int x;

      int y;

      void Bicara() { cout<<"Saya adalah kelas Basis.\n";}

}; //akhir dari kelas Basis

class D : public Basis

{ 

   public:

      void bicara() { cout<<"Saya adalah kelas D. \n";}

      Basis B; //B adalah objek dari kelas Basis

      int Luas(Basis B)

  {return B.x*B.y;}

};

int main()

{

   Basis B ;

   B.x =5;

   B.y = 20;

   Basis * basisp = &B; // pointer ke kelas Basis

   cout<<"Fungsi Bicara() dipanggil dengan basisp."<<endl;

   basisp -> Bicara();

   cout<<"Setelah operator static cast(), fungsi D dipanggil"<<endl;

   D * dp = static_cast<D*>(basisp); //basisp cast dikonversi menjadi tipe D

   dp->bicara(); //fungsi Bicara() dari kelas D dipanggil oleh pointer dp

   D* dp1 = (D*)basisp; //konversi konvensional dari bahasa C

   cout<<"Setelah konversi konvensional dari bahasa C, untuk memanggil Bicara()"<<endl;

   dp1 -> bicara();

   D d; //d dideklarasikan sebagai objek dari kelas D

   cout<<"Luas = "<< d.Luas(B)<<endl; //memanggil fungsi Luas()

   cout<<"Setelah mengkonversi sebuah objek menjadi referensi menggunakan konversi konvensional"<< endl;

   D &dp2 = (D&) B; //mengkonversi sebuah referensi dengan konversi konvensional bahasa C

   dp2.Bicara(); //memanggil sebuah fungsi dari kelas Basis

   dp2.bicara(); //memanggil sebuah fungsi dari kelas D

   D &dp3 = static_cast<D&>(B); //mengkonversi sebuah referensi dengan operator static_cast()

   cout<<"Setelah penerapan operator static_cast(), fungsi-fungsi dipanggil lagi"<<endl;

   dp3.Bicara(); //Bicara() dan Bicara() adalah dua fungsi yang berbeda

   dp3.bicara();

   return 0 ;

}

===================================

#include <iostream>

#include <string>

using namespace std;

class A; //kelas tak-utuh

class B; //kelas tak-utuh

class Basis

{ 

   public :

      void Bicara() {cout<<"Saya adalah kelas Basis.\n";}

};

class D : public Basis

{ 

   public:

      void bicara() {cout<<"Saya adalah kelas D.\n";}

};

int main()

{ 

   int x = 65;

    

   int* px = &x; //px adalah pointer yang menunjuk ke int x

   char* chp = (char*) px; //px dikonversi menjadi pointer char* chp

//dengan konversi konvensional bahasa C

   cout<<"*chp = "<<*chp<<endl; //statemen keluaran untuk *chp

   cout<<*px <<endl;

   //berikut konversi sama yang dilakukan oleh reinterpret_cast<>()

   char* ptrx = reinterpret_cast<char*> (px);

   cout<<"*ptrx = "<<*ptrx<<endl;

   D* ptrd = reinterpret_cast<D*>(px); //px dikonversi menjadi tipe D

   ptrd -> bicara();

   B* bp; //Operator ini juga dapat diterapkan pada kelas tak-utuh

   A* ap = reinterpret_cast<A*>(bp);

}

=====================================

#include <iostream>

using namespace std;

void Fungsi1()

{ 

   cout<<"Ini adalah fungsi void dengan argumen void.\n";

}

void Fungsi2(int m, int n)

{ 

   cout<<"Ini adalah fungsi void dengan dua argumen.\n";

}

int Fungsi3 (int x, int y)

{

   return x*y;

}

int main()

{ 

   int x = 65;

   

   int * px = &x; //px adalah pointer yang menunjuk ke int x

   typedef void (*PF)(); //typedef atas pointer ke fungsi void

   PF fungsi1 = (PF)Fungsi1; //menggunakan konversi konvensional

   fungsi1() ; //pemanggilan fungsi

   PF fungsi2 = reinterpret_cast<PF>(Fungsi1); //oleh reinterpret_cast

   fungsi2(); // fungsi2 dipanggil

   int y = 2;

   PF aFungsi2 = reinterpret_cast<PF>(Fungsi2);

   aFungsi2();

   typedef int(*pF)(int, int); //definisi tipe atas pointer yang menunjuk ke

//fungsi-fungsi int yag memiliki dua parameter int

   pF fungsi3 = (pF) Fungsi3 ; //konversi konvensional dari bahasa C

   cout<<fungsi3(x,y )<<endl; //pemanggilan fungsi

   //berikut adalah konversi yang sama menggunakan reinterpret_cast<>()

   pF fungsi4 = reinterpret_cast<pF>(Fungsi3);

   cout<< fungsi4(x,y)<< endl;

   return 0;

}

============================================

#include <iostream>

using namespace std;

void F(char* M)

{cout<<M<<endl;}

int main()

{ 

   const char * S= "Jakarta";

   //F(S); Error, tidak dapat mengkonversi dari const char* menjadi char*

   F(const_cast<char*>(S)); //ini OK

   const int n = 10;

   const int *ptrn = &n;

   // n= n+5; Error, n adalah const. Tetapi berikut OK

   *(const_cast<int*>(ptrn)) = n + 5;

   cout<<*(const_cast<int*>(ptrn))<<endl;

   //const_cast<int>(n) = n+8; Ini menghasilkan error, operator const_cast

   //tidak dapat mengkonversi dari const int menjadi int.

   cout << n <<endl;

   return 0 ;

}

=================================================================

#include <iostream>

using namespace std;

class Mahluk

{

   public:

      virtual void Bicara() = 0;

};

class Anjing : public Mahluk

{ 

   public:

      void Bicara ()

  {cout<<"Guk guk guk"<<endl;}

};

class Kucing : public Mahluk

{

   public:

      void Bicara(void)

  {cout<<"Meonk meonk meonk"<<endl;}

};

class IngMan : public Mahluk

{ 

   public :

      void Bicara(){cout<<"I can speak English"<<endl;}

};

class IndMan : public Mahluk

{ 

   public :

      void Bicara(){cout<<"Saya bicara bahasa Indonesia"<<endl;}

};

void main ()

{

   Anjing A;

   Kucing K;

   IngMan IgM;

   IndMan InM;

   A.Bicara();

   K.Bicara();

   IgM.Bicara();

   InM.Bicara();

   cout<<"\n";

}