Constructor

Pemrograman OOP C++

Constructor pada C++

C()  adalah  anggota  class  yang  bertugas  melakukan  inisialisasi  obyek (instance)  dari suatu class C. Constructor mempunyai nama yang sama dengan nama class, dan  tidak mempunyai  return  value.  Sebuah  class  dapat mempunyai  lebih  dari  satu  constructor. Constructor  yang  tidak  mempunyai  argumen,  disebut  default  constructor,  sebaliknya constructor  yang  mempunyai  lebih  dari  satu  argumen  adalah  non-default  consructor. Constructor dengan satu default argument tetap merupakan sebuah default constructor,

 

class C

{

public:

C(int count=10) : _count(count) {}

…

private:

int _count;

};

 

Compiler C++ dapat menambahkan default constructor bilamana diperlukan,  jika dalam definisi class

• Tidak tertulis secara eksplisit sebuah default constructor dan tidak ada deklarasi constructor lain (copy constructor).
• Tidak ada anggota class berupa data const maupun reference.

 

Sebagai contoh definisi class C sebagai berikut,

 

class C {…};

 

C c1;    // memerlukan default constructor

C c2(c1);   // memerlukan copy constructor

 

Compiler C++ memutuskan untuk menambahkan default dan copy construtor setelah menemui kedua baris program tersebut, sehingga definisi class secara efektif menjadi sebagai berikut :

 

class C

{

public:

   C();               // default costructor

   C(const C& rhs);   // copy constructor

 

   ~C();              // destructor

   C& operator=(const C& rhs);   // assignment operator

   C* operator&();    // address-of operator

   const C* operator&(const C& rhs) const;

};

 

Compiler menambahkan public constructor, dan destructor. Selain itu, compiler juga menambahkan assignment operator dan address-of operator. Constructor (default dan non-default) tidak harus mempunyai akses public, sebagai contoh adalah pola desain (design pattern) Singleton.

class Singleton

{

public:

   static Singleton* instance();

protected:

   Singleton();

private:

   static Singleton* _instance;

};

 

Obyek (instance) singleton tidak dibentuk melalui constructor melainkan melalui fungsi instance. Tidak ada obyek singleton lain yang dapat dibentuk jika sudah ada satu obyek singleton. Umumnya default constructor bentukan compiler (generated default constructor) menggunakan default constructor anggota bertipe class, sedangkan anggota biasa (built-in type) tidak diinisialisasi. Demikian halnya dengan obyek yang dibentuk dari obyek lain (copy), maka copy constructor bentukan compiler (generated copy constructor) menggunakan copy constructor dari anggota bertipe class pada saat inisialisasi. Sebagai contoh deklarasi class C berikut ini,

class C

{

public:

   C(const char* aName);

   C(const string& aName);

…

private:

   std::string name;

};

 

Copy constructor bentukan compiler  menggunakan copy constructor class  string untuk inisialisasi name dari aName. Jika class C tidak mempunyai constructor, maka compiler menambahkan juga default constructor untuk inisialisasi name menggunakan default constructor class string. Inisialisasi obyek menggunakan constructor (non-default) dapat dilakukan dengan member initializer maupun dengan assignment sebagai berikut,

member initialization

class C                                                          assignment

{                                                                   class C

   int i,j;                                                         {

public:                                                                   int i,j

   C() : i(0),j(1) {}                                         public:

…                                                                          C()

};                                                                           {

                                                                                                   i=0;j=0;

                                                                                          }

                                                                                 …

                                                                                 };

Kedua cara tersebut memberikan hasil yang sama, tidak ada perbedaan signifikan antara kedua cara tersebut untuk data bukan tipe class. Cara member initializer  mutlak diperlukan untuk data const maupun reference, seperti kedua contoh berikut ini:

class C  //:1

{

public:

   C(int hi,int lo) : _hi(hi),_lo(lo) {}

…

private:

   const int _hi,_lo;   // const member

};

 

class C  //:2

{

public:

   C(const string& aName) : name(aName) {}

…

private:

   std::string& name;   // reference member

};

Cara  member  initialization  sebaiknya dilakukan untuk anggota bertipe class (user-defined type) seperti ditunjukkan pada contoh berikut ini,

class C

{

public:

   C(const string& aName) : name(aName) { }

private:

   std::string name;   // bukan reference member

};

Pertimbangan menggunakan cara member  initialization terletak pada efisiensi eksekusi program. Hal ini berkaitan dengan cara kerja C++ yang membentuk obyek dalam dua tahap,

•  pertama, inisialisasi data

•  kedua, eksekusi constructor (assignment)

 Dengan demikian jika menggunakan cara assignment sebenarnya eksekusi program dilakukan dua kali, pertama inisialisasi kemudian assignment, sedangkan menggunakan member  initialization hanya memanggil sekali constructor class  string. Semakin kompleks class tersebut (lebih kompleks dari class  string) semakin mahal (tidak efisien) proses pembentukan obyek melalui cara assignment.

Constructor dengan satu argumen berfungsi juga sebagai  implicit conversion operator. Sebagai contoh deklarasi class A dan B berikut ini,

class A

{

public:

   A();

};

 

class B

{

public:

   B(const A&);

};

Pada cuplikan baris program di bawah  ini terjadi konversi tipe obyek A ke B secara implisit melalui copy constructor class B.

A a

B b=a;   // implicit conversion

 

Dari penjelasan di atas dapat di implementasikan dalam program ini :

/*

Copy Constructor pada C++

karakteristik dari Constructor

-           Nama Const dan Nama Kelas harus sama

-           Tidak ada nilai balik (tidak boleh kosong)

*/

#include “iostream.h“

#include “iomanip.h“

#include “conio.h“

class Item

{

            private:

                        int item_no;

                        char *item_name;

            public :

                        Item()  //Constructor tanpa para

                        {

                                    cout << "Pemanggilan Cunstructor tanpa para" <<>

                        }

                        Item(int a,char *ptr)    //Constructor dengan para

                        {

                                    cout << "pemanggilan Constructor dengan 2 Para" <<>

                                    item_no = a;

                                    item_name = ptr;

                        }

                        Item(Item &x)             //Copy Constructor

                        {

                                    cout << "Copy constructor " <<>

                                    item_no = x.item_no;

                                    item_name = x.item_name;

                        }

                        void display()

                        {

                                    cout << "Item No   :" <<>

                                                << "item Name :" <<>

                        }

};

//=================================================

//          Main Function

//=================================================

void main()

{

            //clrscr();

            //Constructor dengan Para

            Item a(100,"Ram");

            cout << "Object A :===> ";

            a.display();

            //Copy Constructor

            Item b(a);

            cout << "Object B :===> ";

            b.display();

            //Copy Constructor

            Item c = a;

            cout << "Object C :===> ";

            c.display();

            //operator overload

            Item d;

            d.display();

            d = b;

            cout << "Object D :===> ";

            d.display();

 

            getch();

} 

Dengan hasil eksekusi program yaitu :

Overloading

OVERLOADING

Berdasarkan arti dari overloading yakni beban yang terlalu berat, tapi dalam pemrograman c++ overloading mempunyai 2 pengertian yang dapat disesuaikan dengan pemakaiannya.

OVERLOADING FUNCTION

Pada fungsi terdapat arti beberapa fungsi dapat memiliki argument berbeda tetapi nama fungsi yang sama sama. Pada fungsi ini dapat kita jelaskan pada progaram dalam pemanggilan fungsi yang mempunyai nama sama :

Contoh Program

# include “iostream.h” 

#include ”stdio.h”

class variabel

{

private: char c; long x;

public:

void tulis (char c)

{

printf("karakter=c\n");

}

void tulis (int x)

{

printf("Bilangan bulat=x\n");

}

};

void main()

{

variabel penentuan;

penentuan.tulis('c');

}

Bentuk hasil compiler :

Penjelasan :

Pada program tersebut terdapat 2 fungsi yang sama, tapi tetapi compiler tahu fungsi manakah yang harus dipanggil yang di karenakan compiler tahu bahwa pada pemanggilan fungsi itu argument ”karakter= C” yang di panggil oleh compiler.

C++ hanya dapat mengkompilasi overloading function jika argument fungsinya berbeda. Bila argument fungsinya sama tetapi tipe nilai kembaliannya berbeda, compiler akan melaporkan adanya kesalahan.

Contoh :

Fungsi : double coba (int) ; ç dengan Fungsi è int coba (int) ;

* DEFAULT ARGUMEN

Contoh :

Void func ( int x = 0, int y = 0 ) ;

Maksudnya adalah :

Contoh fungsi diatas dapat dipanggil dengan 3 (tiga) cara berbeda :

1. func ( ) // nilai x dan y otomatis 0

2. func ( 7 ) // nilai x = 7 dan y = 0

3. func ( 7, 33 ) // nilai x = 7 dan y = 33

Contoh deklarasi fungsi diatas akan terjadi kesalahan, jika variable x diberi nilai, sedangkan variable y tidak beri nilai.

Contoh :

Void func ( int x = 2, int y ) ;

* AMBIGUITY PADA OVERLOADING FUNCTION

Beberapa hal yang menimbulkan ketidak jelasan pada program :

1. type conversion

Contoh :

Void f ( double nilai )

Main ( )

{

Int I = 12 ;

F ( I ) ;

}

2. reference parameter

Parameter yang memiliki perbedaan hanya pada argument, dimana fungsi yang satu menggunakan reference parameter dan yang lainnya menggunakan value parameter.

Contoh :

Void func ( int x , int y ); dengan void func func ( int x , int& y) ;

OPERATOR OVERLOADING

Seperti halnya pada fungsi, C++ juga mengizinkan kita untuk melakukan overload terhadap operator. Ini berarti bahwa operator tersebut dapat kita gunakan sesuai kebutuhan yang kita inginkan sendiri. Sebagai contoh, C++ sendiri sebenarnya telah melakukan overload terhadap operator +, sehingga operator ini dapat berlaku untuk menjumlahkan nilai yang bertipe bilangan bulat (seperti int dan long) maupun floating- point (seperti float dan double). Pada bagian ini kita akan mempelajari bagaimana konsep dasar untuk membuat suatu operator dapat bekerja sesuai yang kita harapkan. Konsep dasar yang harus dimiliki untuk dapat melakukan overload terhadap operator adalah dengan mendefinisikan suatu fungsi, yaitu yang dikenal dengan sebutan fungsi operator . Untuk membuat fungsi ini digunakan kata kunci operator. Fungsi operator kebanyakan berperan sebagai anggota (member function ) dari suatu kelas. Kalaupun tidak, maka fungsi tersebut biasanya merupakan suatu friend function . Terdapat perbedaan antara penulisan fungsi untuk pembuatan fungsi operator yang merupakan anggota kelas dan yang bukan. Berikut ini bentuk umum pembuatan fungsi operator yang merupakan anggota dari suatu kelas.

tipe_kembalian nama_kelas::operator#(daftar_parameter)

{

// Operasi yang akan dilakukan

}

Pada bentuk umum di atas, nama_kelas adalah nama dari kelas pemilik fungsi tersebut. Sedangkan tanda # di atas berfungsi sebagai placeholder , artinya di sinilah kita mendefinisikan operator apa yang akan kita overload . Apabila kita ingin melakukan overload terhadap operator +, maka penulisan fungsinya adalah operator+. Begitu pula jika kita akan melakukan overload terhadap operator /, maka kita akan menulisnya operator/. Sedangkan bentuk umum dari pembuatan fungsi yang bukan merupakan anggota kelas (yang biasanya adalah friend function ) adalah sama seperti pendefinisian fungsi biasa, yaitu sebagai berikut :

tipe_kembalian operator#(daftar_parameter)

{

// Operasi yang akan dilakukan

}

Operator yang Tidak Dapat di- overload

Meskipun C++ telah memberikan kebebasan kepada kita untuk melakukan overload , namun ada beberapa operator yang tidak diizinkan untuk di- overload . Berikut ini operator- operator yang dimaksud di atas.

. .* :: ?:

Selain itu kita juga tidak diizinkan untuk melakukan overload terhadap simbol preprocessor , yaitu # dan ##. Untuk lebih jelasnya, berikut ini operator- operator yang dapat kita overload .

a. Operator Unary

+ - * & ~ ! ++ -- -> ->*

b. Operator Binary

+ - * / % ^ & | << >>

+= -= *= /= %= ^= &= |= <<= >>=

< <= > >= == != && ||

, [] ()

new new[] delete delete[]

Melakukan Overload terhadap Operator Binary

Pada bagian ini kita akan membahas mengenai overload terhadap operator binary , sedangkan operator unary akan dibahas pada sub bab selanjutnya di dalam buku ini. Hal ini dimaksudkan agar Anda dapat lebih memahami konsepnya terlebih dahulu. Adapun operator binary yang akan di- overload di sini hanyalah tiga, yaitu operator +, - dan =. Ini disebabkan karena Anda tentu sudah familiar dengan penggunaan operator- operator tersebut. Untuk lebih lengkapnya, diharapkan Anda dapat mengembangkannya sendiri dengan berbekal konsep- konsep yang telah di dapat pada bab ini. Berikut ini penjelasan mengenai cara- cara melakukan overload terhadap operator- operator yang dimaksud di atas.

Overload Operator +

Di sini kita akan membuat program yang di dalamnya terdapat overload operator plus (+) sehingga operator tersebut dapat menjumlahkan dua buah nilai yang bertipe objek. Fokuskan perhatian Anda ke pembuatan fungsi operator di bawah ini. Adapun sintak programnya adalah sebagai berikut.

Contoh Program

#include ”iostream” 

using namespace std;

// Membuat kelas TITIK

class TITIK

{

int X, Y;

public:

// Membuat fungsi constructor untuk kelas TITIK

TITIK(int XX, int YY)

{

X = XX;

Y = YY;

}

// Membuat fungsi ShowXY

void ShowXY()

{

cout<<"Nilai X : "<<

cout<<"Nilai Y : "<<

}

// Mendeklarasikan fungsi operator yang mengembalikan

// objek TITIK

TITIK TITIK::operator +(TITIK P);

};

// Implementasi dari fungsi operator di atas

TITIK TITIK::operator +(TITIK P)

{

return TITIK(P.X + X, P.Y + Y);

}

// Fungsi utama

int main()

{

// Melakukan instansiasi terhadap kelas TITIK

TITIK A(2, 3);

TITIK B(5, 4);

// Menampilkan nilai X dan Y yang terdapat pada objek A dan B

A.ShowXY();

cout<

B.ShowXY();

cout<

// Menjumlahkan objek A dan B dan menyimpannya ke objek C

TITIK C = A + B;

// Menampilkan nilai X dan Y yang terdapat pada objek C

C.ShowXY();

return 0;

}

Hasil yang akan diberikan dari program di atas adalah sebagai berikut :

Seperti yang kita lihat di atas bahwa operator + dapat kita gunakan untuk menjumlahkan dua buah objek bertipe TITIK. Secara default , operasi ini tentu tidak diperbolehkan oleh kompiler. Namun dengan melakukan overload terhadap operator tersebut, maka kita dapat melakukannya.

Overload Operator -

Untuk melakukan overload terhadap operator - tentu prinsipnya sama dengan overload terhadap operator + di atas. Namun, sebagai pengetahuan bagi Anda, kita akan melakukan modifikasi terhadap program di atas dengan menambahkan fungsi operator untuk operator -. Adapun sintak programnya adalah sebagai berikut :

Contoh Program

#include ”iostream”

using namespace std;

class TITIK

{

      int X, Y;

public:

      // Membuat fungsi SetXY dan ShowXY

      void SetXY(int XX, int YY)

      {

            X=XX;

            Y=YY;

      }

      void ShowXY()

      {

            cout<<"Nilai X : "<<

            cout<<"Nilai Y : "<<

      }

      // Mendeklarasikan fungsi operator untuk operator -

      TITIK TITIK::operator -(TITIK P);

};

// Implementasi dari fungsi operator di atas

TITIK TITIK::operator -(TITIK P)

{

      TITIK temp;   // Membuat objek temporary yang bertipe TITIK

      temp.X = X - P.X;

      temp.Y = Y - P.Y;

      return temp;

}

// Fungsi utama

int main()

{

      // Melakukan instansiasi terhadap kelas TITIK

      TITIK A, B, C;

      // Mengeset nilai X dan Y untuk objek A dan B

      A.SetXY(10, 6);

      B.SetXY(4,2);

      // Menampilkan nilai X dan Y yang terdapat pada objek A

      A.ShowXY();

      cout<

     

      // Menampilkan nilai X dan Y yang terdapat pada objek A

      B.ShowXY();

      cout<

      // Melakukan pengurangan terhadap objek A dan B

      C = A - B;

      // Menampilkan nilai X dan Y yang terdapat pada objek C

      C.ShowXY();

      return 0;

}

Hasil yang akan diberikan dari program di atas adalah sebagai berikut :

Overload Operator =

Pada bagian ini kita akan melakukan overload terhadap operator =. Sebelumnya kita telah mengetahui bahwa operator = digunakan untuk melakukan assigment suatu nilai ke dalam suatu variabel. Namun di sini, kita akan menjadikan operator tersebut bekerja untuk assignment nilai ke dalam sebuah objek. Prinsip kerjanya sama dengan layaknya fungsi yang digunakan untuk pengesetan nilai (misalnya SetX()). Untuk lebih memahaminya, perhatikan dahulu program di bawah ini, dimana nilai diset melalui fungsi. Adapun sintaknya adalah sebagai berikut :

Contoh Program

#include ”iostream”

using namespace std;

class CONTOH

{

            int X;

public:

            void SetX(int XX)

            {

                        X = XX;

            }

            int GetX()

            {

                        return X;

            }

};

// Fungsi utama

int main()

{

            // Melakukan instansiasi terhadap kelas CONTOH

            CONTOH A;

            // Memasukkan nilai 5 ke variabel X yang terdapat

            // pada kelas CONTOH

            A.SetX(5);

            // Menampilkan nilai X

            cout<<"Nilai X : "<

            return 0;

}

Bila di compile akan tampil:

Seperti yang kita lihat di atas bahwa untuk memasukkan nilai ke dalam variabel X yang terdapat pada objek A, kita menggunakan fungsi SetX(). Di sini kita tidak dapat melakukannya dengan menggunakan operator =, yaitu dengan statemen :

A = 5; // SALAH, tidak diizinkan oleh kompiler

Namun, untuk mengatasi kasus seperti ini, sebenarnya kita dapat melakukan overload terhadap operator =. Berikut ini contoh program yang akan menunjukkan hal tersebut.

Contoh Program

#include ”iostream”

using namespace std;

class CONTOH

{

      int X;

public:

      int GetX()

      {

            return X;

      }

      // Membuat fungsi operator

      int operator =(int nilai)

      {

            X = nilai;

            return 1;   // return true

      }

};

// Fungsi utama

int main()

{

      // Melakukan instansiasi terhadap kelas CONTOH

      CONTOH A;

      // Memasukkan nilai 5 ke variabel X yang terdapat

      // pada kelas CONTOH

      A = 5;   // Sebenarnya memanggil A.operator=(5)

      // Menampilkan nilai X

      cout<<"Nilai X : "<

      return 0;

} 

Apabila kedua program di atas dijalankan, maka akan memberikan hasil yang sama, yaitu sebagai berikut :

Melakukan Overload terhadap Operator Unary

Selain operator binary , kita juga dapat melakukan overload terhadap operator- operator unary . Adapun contoh yang akan kita bahas di sini hanya mencakup operator increment (++) dan decrement (--) saja.

1. Overload Operator ++

Secara default , dalam C++ operator increment (++) digunakan untuk menambahkan nilai satu terhadap suatu variabel yang bertipe bilangan bulat, bilangan floating- point maupun karakter. Namun di sini, kita akan melakukan overload terhadap operator tersebut sehingga dapat bekerja untuk tipe objek. Adapun kelas yang akan diambil sebagai contoh di sini adalah kelas titik (yang mempunyai data X dan Y). Pada contoh ini, setiap increment objek maka nilai X dan Y dari objek tersebut secara otomatis akan bertambah satu. Berikut ini sintak program yang menunjukkan hal tersebut.

Contoh Program

#include ”iostream”

using namespace std;

class TITIK

{

      int X, Y;

public:

      // Membuat fungsi constructor untuk kelas TITIK

      TITIK (int XX, int YY)

      {

            X= XX;

            Y= YY;

      }

      // Membuat fungsi ShowXY()

      void ShowXY()

      {

            cout<<"Nilai X : "<<

            cout<<"Nilai Y : "<<

      }

      // Membuat fungsi operator untuk pre-increment

      TITIK operator ++()

      {

            X += 1; // dapat dituliskan X = X + 1

            Y += 1; // dapat dituliskan Y = Y + 1

 

            return *this;

           

            // Membuat fungsi operator untuk post-increment

      }

 

      TITIK operator ++(int)

      {

            X += 1;

            Y += 1;

            return *this;

      }

};

// Fungsi utama

int main()

{

      // Melakukan instansiasi terhadap kelas TITIK

      TITIK A(2, 4);

      // Melakukan pre-increment terhadap objek A

      cout<<"Pre-increment untuk objek A"<

      ++A;

     

      // Menampilkan nilai X dan Y yang terdapat pada objek A

      A.ShowXY();

      cout<

     

      // Melakukan instansiasi terhadap kelas TITIK

      TITIK B(10, 5);

      // Melakukan post-increment terhadap objek B

      cout<<"Post-increment untuk objek B"<

      B++;

      // Menampilkan nilai X dan Y yang terdapat pada objek B

      B.ShowXY();

      return 0;

}

Hasil yang akan diberikan dari program di atas adalah sebagai berikut :

2. Overload Operator --

Masih seputar kelas TITIK, di sini kita akan menjadikan operator decrement (--) dapat bekerja untuk objek yang bertipe TITIK. Sebenarnya prinsip yang terapat di dalamnya adalah sama saja dengan overload terhadap operator increment (++) di atas. Untuk lebih jelasnya, perhatikan contoh program di bawah ini.

Contoh Program

#include ”iostream”

 

using namespace std;

 

class TITIK

{

                   int X, Y;

public:

                   // Membuat fungsi constructor untuk kelas TITIK

                   TITIK (int XX, int YY)

                   {

                        X = XX;

                        Y = YY;

                   }

                   // Membuat fungsi ShowXY()

                   void ShowXY()

                   {

                        cout<<"Nilai X : "<<

                        cout<<"Nilai Y : "<<

                   }

                   // Membuat fungsi operator untuk pre-increment

                   TITIK operator --()

                   {

                        X -= 1; // dapat dituliskan X = X - 1

                        Y -= 1; // dapat dituliskan Y = Y - 1

 

                        return *this;

                       

                   }

                   // Membuat fungsi operator untuk post-increment

                   TITIK operator --(int)

                   {

                        X -= 1;

                        Y -= 1;

                        return *this;

                   }

};

 

// Fungsi utama

int main()

{

 

                   // Melakukan instansiasi terhadap kelas TITIK

                   TITIK A(10, 20);

                  

                   // Melakukan pre-decrement terhadap objek A

                   cout<<"Pre-decrement untuk objek A"<

                   --A;

                  

                   // Menampilkan nilai X dan Y yang terdapat pada objek A

                   A.ShowXY();

                   cout<

                  

                   // Melakukan instansiasi terhadap kelas TITIK

                   TITIK B(2, 6);

                  

                   // Melakukan post-decrement terhadap objek B

                   cout<<"Post-decrement untuk objek B"<

                   B--;

                  

                   // Menampilkan nilai X dan Y yang terdapat pada objek B

                   B.ShowXY();

                   return 0;

}

Hasil yang akan diberikan dari program di atas adalah sebagai berikut :

Melakukan Overload terhadap Operator Khusus

Seperti yang telah dikemukanan sebelumnya, C++ mengizinkan kita untuk melakukan overload terhadap operator- operator khusus selain dari operator binary dan unary . Adapun operator khusus yang akan dibahas sebagai contoh di sini hanyalah operator new dan delete. Hal ini disebabkan karena pada prakteknya dalam kebanyakan program C++ sering sekali ditemui adanya overload terhadap kedua buah operator ini.

1. Overload Operator new

Dalam C++, kita juga dapat melakukan overload terhadap operator new sehingga kita dapat melakukan pengalokasian secara khusus untuk suatu tipe ataupun kelas tertentu. Adapun bentuk umum untuk membuat fungsi operator untuk operator new yang telah ditentukan dalam C++ adalah sebagai berikut :

void *operator new(size_t size) {

// Statemen untuk menjalankan alokasi memori

// Jika alokasi gagal, lemparkan eksepsi bad_alloc

return pointer;

}

Pada bentuk umum di atas, size_t adalah suatu tipe yang telah didefinisikan di dalam C++ (hampir sama dengan tipe unsigned integer). Sebagai contoh di sini kita akan melakukan overload terhadap operator new untuk kelas titik, dimana apabila kita melakukan pengalokasian memori untuk kelas titik tersebut, maka operator new yang akan dipanggil oleh kompiler adalah operator yang telah kita definisikan sendiri, bukan operator new yang telah terdefinisi dalam C++. Untuk lebih memahaminya, berikut ini sintak program yang menunjukkan hal tersebut.

Contoh Program

#include ”iostream”

#include ”cstdlib” // Untuk menggunakan fungsi malloc()

#include ”new” // Untuk menggunakan eksepsi bad_alloc

 

using namespace std;

 

class TITIK

{

      int X, Y;

public:

      TITIK(int XX, int YY)

      {

            X = XX;

            Y = YY;

      }

      void ShowXY()

      {

            cout<<"Nilai X : "<<

            cout<<"Nilai Y : "<<

      }

    // Membuat fungsi operator untuk operator new

      void *operator new(size_t size)

      {

            void *P;

            cout<<"Operator new yang didefinisikan sendiri"<

            // Melakukan alokasi memori

            P = malloc(size);

            // Jika gagal, lemparkan eksepsi bad_alloc

            if (!P)

            {

                  bad_alloc BA;

                  throw BA;

            }

            return P;

      }

};

// Fungsi utama

int main()

{

      // Mendeklarasikan pointer PT yang akan menunjuk tipe TITIK

      TITIK *PT;

      // Melakukan alokasi dengan operator new

      try

      {

            PT = new TITIK(2, 5);

      // Menampilkan nilai X dan Y

            PT->ShowXY();

      }

      catch (bad_alloc E)

      {

            cout<<"Alokasi untuk PT gagal"<

            return 1;

      }

      // Mendealokasikan memori

      delete PT;

      // Mendeklarasikan pointer yang akan menunjuk ke tipe int

      int *PI;

    PI = new int;

      *PI = 300;

      cout<<"\nNilai *PI : "<<*PI<

      return 0;

}

Hasil yang akan diberikan dari program di atas adalah sebagai berikut :

Seperti yang kita lihat di atas bahwa pada saat kita mengalokasikan tipe TITIK, maka yang akan dipanggil adalah operator new yang kita definisikan sendiri. Namun pada saat kita mengalokasikan tipe int, operator new yang digunakan adalah operator new asli yang terdapat pada C++. Sebagai bukti, di saat kita mengalokasikan tipe int, kita tidak melihat adanya teks "Operator new yang didefinisikan sendiri". Untuk operator delete di atas juga menggunakan operator yang telah terdefinisi secara default dalam C++. Walaupun demikian, kita juga dapat melakukan overload terhadap operator delete seperti yang akan dibahas pada sub bab di bawah ini.

2. Overload Operator delete

Pada bagian ini kita akan membahas overload untuk operator delete melalui sebuah contoh program. Namun sebelumnya kita harus mengetahui terlebih dahulu bentuk umum untuk pembuatan fungsi operator untuk operator delete, yaitu seperti yang tampak di bawah ini.

void operator delete(void *p)

{

// Mendealokasikan memori yang ditunjuk oleh pointer p

}

Adapun program yang akan dituliskan di bawah ini merupakan modifikasi dari program di atas. Di sini, kita akan melakukan overload terhadap operator delete sehingga dapat digunakan secara khusus untuk kelas TITIK. Berikut ini sintak program yang dimaksud.

Contoh Program :

#include ”iostream”

#include”cstdlib”  // Untuk menggunakan fungsi malloc()

                    // dan free()

#include ”new”     // Untuk menggunakan eksepsi bad_alloc

 

using namespace std;

 

class TITIK

{

            int X, Y;

public:

            TITIK(int XX, int YY)

            {

                        X = XX;

                        Y = YY;

            }

    void ShowXY()

            {

                        cout<<"Nilai X : "<<

                        cout<<"Nilai Y : "<<

            }

            // Membuat fungsi operator untuk operator new

            void *operator new(size_t size)

            {

                        void *P;

                        cout<<"Operator new yang didefinisikan sendiri"<

                        // Melakukan alokasi memori

                        P = malloc(size);

                        // Jika gagal, lemparkan eksepsi bad_alloc

                        if (!P)

                        {

                                    bad_alloc BA;

                                    throw BA;

                        }

                        return P;

            }

    // Membuat fungsi operator untuk operator delete

            void operator delete(void *P)

            {

                        cout<<"Operator delete yang didefinisikan sendiri"<

                        free(P);

            }

};

// Fungsi utama

int main()

{

           

            // Mendeklarasikan pointer PT yang akan menunjuk tipe TITIK

    TITIK *PT;

            // Melakukan alokasi dengan operator new

            try

            {

                        PT = new TITIK(2, 5);

                        // Menampilkan nilai X dan Y

                        PT->ShowXY();

            }

            catch (bad_alloc E)

            {

                        cout<<"Alokasi untuk PT gagal"<

                        return 1;

            }

            // Mendealokasikan memori

            delete PT;

            // Mendeklarasikan pointer yang akan menunjuk ke tipe int

            int *PI;

            PI = new int;

            *PI = 300;

            cout<<"\nNilai *PI : "<<*PI<

            return 0;

}

"-n
(0ȡge: SV'>      delete PT;

      // Mendeklarasikan pointer yang akan menunjuk ke tipe int

      int *PI;

    PI = new int;

      *PI = 300;

      cout<<"\nNilai *PI : "<<*PI<

      return 0;

}

Hasil yang akan diberikan dari program di atas adalah sebagai berikut :

Berbeda dengan program sebelumnya, operator delete yang digunakan di sini adalah operator delete yang khusus kita definisikan sendiri untuk kelas TITIK. Sebagai bukti pernyataan ini, pada saat kita menggunakan operator delete terhadap pointer yang menunjuk ke kelas TITIK, maka di layar akan ditampi lkan teks “Operator delete yang didefinisikan sendiri”. Sedangkan untuk penghapusan pointer PI yang menunjuk ke tipe int, operator delete yang digunakan masihlah operator asli yang terdapat pada C++.