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 :