CLASS

Sebuah kelas merupakan perluasan konsep struktur data: bukan hanya memegang data, dapat menyimpan data dan fungsi kedua.

Obyek adalah Instansiasi dari kelas. Dalam hal variabel, satu kelas akan jenis, dan objek akan menjadi variabel.

Kelas biasanya dinyatakan dengan menggunakan kata kunci class, dengan format berikut:

kelas class_name (
access_specifier_1:
member1;
access_specifier_2:
member2;
...
Object_names);


Dimana class_name merupakan identifier sah untuk kelas, object_names adalah opsional daftar nama-nama benda ini untuk kelas. Tubuh yang dapat berisi pernyataan anggota, yang dapat berupa data atau fungsi deklarasi, dan akses specifiers opsional.




Semua ini sangat mirip dengan deklarasi pada struktur data, kecuali yang kita dapat sekarang termasuk juga fungsi dan anggota, tapi juga hal baru ini disebut akses specifier. Akses specifier adalah salah satu dari tiga kata kunci berikut: swasta, publik atau dilindungi. Specifiers ini mengubah hak akses bahwa mereka memperoleh anggota berikut:

pribadi anggota satu kelas hanya dapat diakses dari anggota lain dari kelas yang sama atau dari teman-teman mereka.
dilindungi anggota dapat diakses dari anggota mereka sama kelas dan dari teman-teman mereka, tetapi juga dari anggota mereka berasal dari kelas.
Akhirnya, anggota masyarakat dapat diakses dari mana saja dimana objek akan terlihat.


Secara default, semua anggota dari kelas kelas yang dinyatakan dengan kata kunci memiliki akses pribadi untuk semua anggota. Karena itu, setiap anggota yang dinyatakan sebelum specifier kelas satu lainnya secara otomatis memiliki akses pribadi. Sebagai contoh:

class CRectangle {
int x, y;
public:
void set_values (int,int);
int area (void);
} rect;

Menyatakan satu kelas (misalnya, sebuah tipe) disebut CRectangle dan satu objek (misalnya, variabel) dari kelas ini disebut rect. Kelas ini berisi empat anggota: dua anggota data dari tipe int (anggota anggota x dan y) dengan akses swasta (karena swasta adalah tingkat akses standar) dan dua anggota fungsi dengan akses publik: set_values () dan area (), yang bagi sekarang kita hanya termasuk pernyataan mereka, mereka tidak definisi.

Perhatikan perbedaan antara nama kelas dan nama objek: Pada contoh sebelumnya, CRectangle adalah nama kelas (yakni, jenis), sedangkan rect adalah obyek dari jenis CRectangle. Ia adalah sama hubungan int dan ada dalam deklarasi berikut:

int a;

dimana int adalah nama tipe (kelas) dan merupakan nama variabel (objek).

Setelah sebelumnya deklarasi dari CRectangle dan rect, kita dapat lihat di dalam tubuh program ke salah satu anggota masyarakat yang seolah-olah objek rect mereka normal atau fungsi normal variabel, hanya dengan memasukkan nama objek diikuti dengan dot (. ) dan kemudian nama anggota. Semua sangat mirip dengan apa yang kita lakukan dengan plain struktur data sebelumnya. Misalnya:

rect.set_values (3,4);
myarea = rect.area();

Satu-satunya anggota rect yang tidak dapat kita akses dari tubuh program kami di luar kelas adalah x dan y, karena mereka memiliki akses pribadi dan mereka hanya dapat dirujuk dari anggota lain dari kelas yang sama.

Berikut adalah contoh lengkap dari kelas CRectangle:

// classes example
#include
using namespace std;

class CRectangle {
int x, y;
public:
void set_values (int,int);
int area () {return (x*y);}
};

void CRectangle::set_values (int a, int b) {
x = a;
y = b;
}

int main () {
CRectangle rect;
rect.set_values (3,4);
cout << "area: " << rect.area();
return 0;

Baru yang paling penting dalam hal ini adalah kode operator lingkup (::, dua colons) termasuk dalam definisi set_values (). Digunakan untuk menentukan anggota kelas dari luar definisi kelas itu sendiri.

Anda mungkin memperhatikan bahwa definisi dari fungsi anggota area () telah dimasukkan secara langsung di dalam definisi yang diberikan CRectangle kelas yang ekstrim kesederhanaan, sedangkan set_values () hanya memiliki prototipe yang dinyatakan di dalam kelas, tetapi definisi yang luar. Dalam deklarasi ini di luar, kita harus menggunakan operator scope (::) untuk menentukan bahwa kita mendefinisikan sebuah fungsi yang merupakan anggota dari kelas CRectangle dan bukan fungsi global biasa.

Lingkup operator (::) untuk menentukan kelas mana anggota yang dinyatakan berada, justru memberikan lingkup properti yang sama seperti fungsi ini adalah definisi langsung dimasukkan dalam definisi kelas. Misalnya, dalam fungsi set_values () dari kode sebelumnya, kita sudah dapat menggunakan variabel x dan y, yang pribadi anggota kelas CRectangle, yang berarti mereka hanya dapat diakses dari anggota lain dari kelas mereka.

Satu-satunya perbedaan antara mendefinisikan kelas anggota fungsi sepenuhnya di dalam kelas atau hanya menyertakan prototipe dan kemudian dengan definisi, adalah bahwa dalam kasus pertama yang berfungsi secara otomatis akan dianggap sebagai fungsi anggota inline oleh compiler, sedangkan di yang kedua akan menjadi normal (not-inline) fungsi anggota kelas, yang sebenarnya tidak supposes perbedaan perilaku.

Anggota x dan y memiliki akses swasta (ingat bahwa jika tidak ada orang lain yang mengatakan, semua anggota dari sebuah kelas didefinisikan dengan kata kunci kelas memiliki akses pribadi). Oleh mereka menyatakan menolak akses pribadi kita kepada mereka dari mana saja di luar kelas. Ini masuk akal, karena kita sudah ditetapkan fungsi anggota untuk mengatur nilai-nilai bagi anggota dalam objek: fungsi anggota set_values (). Oleh karena itu, sisa dari program ini tidak perlu memiliki akses langsung ke mereka. Mungkin dalam apa yang sederhana seperti contoh ini, sulit untuk melihat sebuah utilitas dalam melindungi orang-orang dua variabel, tetapi dalam proyek-proyek besar mungkin sangat penting bahwa nilai tidak dapat dimodifikasi dalam cara yang tidak diharapkan (tidak terduga dari sudut pandang objek ).

Salah satu keuntungan yang lebih besar dari kelas itu, seperti jenis lain, kita dapat menyatakan beberapa benda itu. Sebagai contoh, berikut dengan contoh sebelumnya CRectangle kelas, kita dapat menyatakan objek rectb selain objek rect:

// example: one class, two objects
#include
using namespace std;

class CRectangle {
int x, y;
public:
void set_values (int,int);
int area () {return (x*y);}
};

void CRectangle::set_values (int a, int b) {
x = a;
y = b;
}

int main () {
CRectangle rect, rectb;
rect.set_values (3,4);
rectb.set_values (5,6);
cout << "rect area: " << rect.area() << endl;
cout << "rectb area: " << rectb.area() << endl;
return 0;
}

Dalam hal ini beton, kelas (jenis benda) yang kita bicarakan adalah CRectangle, dimana terdapat dua atau benda contoh: rect dan rectb. Masing-masing dari mereka memiliki anggota variabel dan fungsi anggota.

Pemberitahuan bahwa panggilan ke rect.area () tidak memberikan hasil yang sama seperti panggilan ke rectb.area (). Ini karena setiap objek kelas CRectangle memiliki variabel x dan y, karena mereka, dalam beberapa cara, mereka sendiri juga memiliki fungsi anggota set_value () dan area () yang masing-masing dengan menggunakan variabel objek sendiri untuk beroperasi.

Itulah dasar konsep pemrograman berorientasi objek: data dan fungsi-fungsi kedua anggota objek. Kami tidak lagi menggunakan set variabel global kami yang lulus dari satu fungsi lain sebagai parameter, namun kami menangani objek yang memiliki data dan fungsi sebagai anggota tertanam. Menyadari bahwa kita tidak harus memberikan parameter dalam salah satu panggilan ke rect.area atau rectb.area. Orang-orang anggota fungsi langsung digunakan data anggota dari masing-masing objek rect dan rectb.


Constructors dan destructors


Objek umumnya perlu initialize atau menetapkan variabel dinamis memori mereka selama proses penciptaan menjadi pembedahan dan untuk menghindari kembali nilai-nilai tak terduga selama eksekusi mereka. Misalnya, apa yang akan terjadi jika di contoh kita sebelumnya disebut fungsi anggota area () sebelum memanggil fungsi yang set_values ()? Mungkin kita akan mendapatkan sebuah hasil yg tak dpt ditentukan karena anggota x dan y akan pernah diberi nilai.

Untuk menghindari itu, satu kelas dapat menyertakan fungsi khusus disebut pembina, yang secara otomatis dipanggil ketika sebuah objek baru dari kelas ini dibuat. Pembina fungsi ini harus memiliki nama yang sama di kelas, dan tidak mempunyai kembali jenis; tidak bahkan tidak berlaku.

Kita akan melaksanakan CRectangle termasuk constructor:


// example: class constructor
#include
using namespace std;

class CRectangle {
int width, height;
public:
CRectangle (int,int);
int area () {return (width*height);}
};

CRectangle::CRectangle (int a, int b) {
width = a;
height = b;
}

int main () {
CRectangle rect (3,4);
CRectangle rectb (5,6);
cout << "rect area: " << rect.area() << endl;
cout << "rectb area: " << rectb.area() << endl;
return 0;
}


Seperti yang dapat anda lihat, hasil dari contoh ini adalah sama dengan sebelumnya. Tetapi sekarang kami telah menghapus anggota fungsi set_values (), dan ada yang bukan termasuk constructor yang melakukan tindakan serupa: ia initializes nilai-nilai yang lebar dan tinggi dengan parameter yang disampaikan kepadanya.

Memperhatikan bagaimana argumen yang disampaikan kepada constructor pada saat ini di mana objek dari kelas ini dibuat:

CRectangle rect (3,4);
CRectangle rectb (5,6);

Constructors tidak dapat disebut secara eksplisit jika mereka sebagai anggota biasa fungsi. Mereka hanya dijalankan ketika sebuah objek baru dari kelas yang dibuat.

Anda juga dapat melihat seberapa baik constructor prototipe deklarasi (dalam kelas) maupun yang kedua definisi pembina termasuk kembali nilai; tidak bahkan tidak berlaku

Destructor yang memenuhi fungsi yang berlawanan. Hal ini secara otomatis dipanggil ketika sebuah objek yang hancur, baik karena lingkup keberadaannya telah selesai (misalnya, jika telah ditetapkan sebagai objek lokal dalam sebuah fungsi dan fungsi berakhir) atau karena merupakan objek yang ditugaskan secara dinamis dan dilepaskan menggunakan operator hapus.

the destructors yang harus memiliki nama yang sama seperti kelas, tetapi diawali dengan tanda tilde (~) dan juga harus ada nilai kembali.

Penggunaan destructors sangat cocok bila obyek memberikan memori dinamis selama masa dan pada saat ini menjadi hancur kita ingin melepaskan memori objek yang telah dialokasikan.

// example on constructors and destructors
#include
using namespace std;

class CRectangle {
int *width, *height;
public:
CRectangle (int,int);
~CRectangle ();
int area () {return (*width * *height);}
};

CRectangle::CRectangle (int a, int b) {
width = new int;
height = new int;
*width = a;
*height = b;
}

CRectangle::~CRectangle () {
delete width;
delete height;
}

int main () {
CRectangle rect (3,4), rectb (5,6);
cout << "rect area: " << rect.area() << endl;
cout << "rectb area: " << rectb.area() << endl;
return 0;
}

Dalam hal ini, telah dinyatakan rectb tanpa argumen, jadi sudah diinisialisasi dengan constructor yang tidak memiliki parameter, yang initializes baik lebar dan tinggi dengan nilai 5.

Penting: Perhatikan bagaimana jika kita menyatakan obyek baru dan kita ingin menggunakan standar constructor (satu tanpa parameter), kami tidak menyertakan tanda kurung ():

CRectangle rectb; // right
CRectangle rectb(); // wrong!