aLways thiNk +

Sekilas Tentang Overloading dan Constructor pada C++

Posted on: September 23, 2009

Sebuah class mempunyai beberapa fungsi khusus, yaitu constructor, copy constructor, destructor dan copy assignment operator.

Constructor

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.

Overloading

Menuliskan kembali method dengan nama yang sama pada suatu class.
Tujuan : memudahkan penggunaan/pemanggilan method dengan fungsionalitas yang mirip.

Aturan Pendeklarasian Method Overloading

  • Nama method harus sama
  • Daftar parameter harus berbeda
  • Return type boleh sama, juga boleh berbeda

Daftar Parameter Pada Overloading

Perbedaan daftar parameter bukan hanya terjadi pada perbedaan banyaknya parameter, tetapi juga urutan dari parameter tersebut.
Misalnya saja dua buah parameter berikut ini :
function_member(int x, String n)
function_member(String n, int x)
Dua parameter tersebut juga dianggap berbeda daftar parameternya.

Daftar Parameter Pada Overloading

Daftar parameter tidak terkait dengan penamaan variabel yang ada dalam parameter.
Misalnya saja 2 daftar parameter berikut :
function_member(int x)
function_member(int y)
Dua daftar parameter diatas dianggap sama karena yang berbeda hanya penamaan variabel parameternya saja.

Contoh Overloading

public class Bentuk {

public void Gambar(int t1) {

}
public void Gambar(int t1, int t2) {

}
public void Gambar(int t1, int t2, int t3) {

}
public void Gambar(int t1, int t2, int t3, int t4) {

}
}

Overloading juga bisa terjadi antara parent class dengan subclass-nya jika memenuhi ketiga syarat overload. Misalnya saja dari class Bentuk pada contoh sebelumnya kita turunkan sebuah class baru yang bernama WarnaiBentuk.

public class WarnaiBentuk extends Bentuk {

public void Gambar(String warna, int t1, int t2, int3) {

}
public void Gambar(String warna, int t1, int t2, int3, int t4) {

}

}

2 Responses to "Sekilas Tentang Overloading dan Constructor pada C++"

ikut copas Kang🙂

Tolonglah penjelasannya tentang singleton dikirm ke email students .Thank you very much yea

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

%d bloggers like this: