Class C++: Mendefinisikan Objek, Member, dan Method

Apa Itu Class

Class adalah cetak biru untuk tipe buatanmu sendiri yang menggabungkan data (member variable) dan perilaku (member function) menjadi satu kesatuan. Kalau tipe bawaan seperti int dan double menggambarkan satu nilai, class memungkinkan kamu memodelkan satu konsep utuh, misalnya rekening bank, titik 2D, atau pemain, sebagai satu nilai yang bisa kamu teruskan ke mana-mana.

Kamu sebenarnya sudah memakai class tanpa mendefinisikannya: std::string dan container vector adalah class dari standard library. Memanggil name.length() atau v.push_back(3) berarti memanggil member function pada sebuah objek. Sekarang kamu akan membuat tipe sendiri dengan cara yang sama, lalu lanjut ke constructor untuk menginisialisasinya.

Mendefinisikan Class dan Membuat Objek

Definisi class mencantumkan member-nya di antara kurung kurawal dan diakhiri titik koma. Lupa menulis ; di akhir adalah salah satu error paling umum bagi pemula. Setiap objek yang kamu buat dari class itu mendapat salinan member variable-nya sendiri.

#include <iostream>
#include <string>
using namespace std;

class Dog {
public:
    string name;   // member variable
    int age;       // member variable

    void bark() {  // member function
        cout << name << " says woof!" << endl;
    }
};

int main() {
    Dog rex;            // create an object (instance)
    rex.name = "Rex";   // set members with the . operator
    rex.age = 4;

    Dog luna;           // a second, independent object
    luna.name = "Luna";

    rex.bark();
    luna.bark();
    return 0;
}

rex dan luna adalah dua objek yang terpisah. Mengubah rex.name tidak menyentuh luna.name, karena setiap objek menyimpan datanya sendiri. Kamu mengakses member dengan operator titik . pada objek (atau -> kalau kamu memegang pointer ke objek itu).

public vs private

Secara default, semua yang ada di dalam class bersifat private: hanya member function milik class itu sendiri yang bisa menyentuhnya. Label public: membuka member untuk kode dari luar. Pembagian inilah inti dari enkapsulasi: kamu membuka antarmuka yang aman dan menyembunyikan data internal supaya tidak bisa dibuat masuk ke keadaan yang tidak valid.

#include <iostream>
using namespace std;

class Counter {
private:
    int count = 0;            // hidden - outsiders can't touch it

public:
    void increment() {        // the safe interface
        count++;
    }
    int value() const {       // const: this function won't modify the object
        return count;
    }
};

int main() {
    Counter c;
    c.increment();
    c.increment();
    cout << "Count: " << c.value() << endl;

    // c.count = 100;   // ERROR: 'count' is private
    return 0;
}

Karena count bersifat private, tidak ada pemanggil yang bisa menyelipkan nilai negatif atau nilai yang tidak masuk akal; mereka harus lewat increment(). const setelah daftar parameter value() berjanji bahwa fungsi itu tidak mengubah objek. Ini membuatmu bisa memanggilnya pada objek const dan sekaligus menunjukkan maksudmu kepada pembaca.

Deklarasi vs. Definisi Method

Untuk class kecil, mendefinisikan method secara inline (seperti di atas) tidak masalah. Untuk class yang lebih besar, umumnya method dideklarasikan di dalam class dan isinya didefinisikan di luar, dengan sintaks scope ClassName::method. Cara ini menjaga definisi class tetap mudah dibaca sebagai ringkasan antarmukanya.

#include <iostream>
#include <string>
using namespace std;

class Rectangle {
public:
    double width;
    double height;

    double area() const;        // declaration only
    void describe() const;      // declaration only
};

// Definitions live outside, qualified with Rectangle::
double Rectangle::area() const {
    return width * height;
}

void Rectangle::describe() const {
    cout << width << " x " << height
         << " = " << area() << endl;   // can call other members directly
}

int main() {
    Rectangle r;
    r.width = 3.0;
    r.height = 4.0;
    r.describe();
    return 0;
}

Awalan Rectangle:: memberi tahu compiler class mana pemilik fungsi tersebut. Di dalam definisi seperti itu kamu tetap merujuk member dengan namanya saja (width, area()), karena compiler tahu member itu milik objek yang memanggil method tersebut.

Pointer this

Di dalam member function non-static mana pun, this adalah pointer ke objek yang memanggil fungsi itu. Biasanya kamu tidak membutuhkannya, karena nama member saja sudah merujuk ke objek saat ini. Pointer ini berguna saat sebuah parameter menutupi (shadow) sebuah member karena namanya sama, sehingga kamu harus membedakannya.

#include <iostream>
using namespace std;

class Point {
public:
    int x = 0;
    int y = 0;

    void setX(int x) {     // parameter 'x' shadows member 'x'
        this->x = x;       // this->x is the member; x is the parameter
    }

    void print() const {
        cout << "(" << x << ", " << y << ")" << endl;
    }
};

int main() {
    Point p;
    p.setX(7);
    p.print();
    return 0;
}

Tanpa this->, menulis x = x; di dalam setX akan mengisi parameter dengan dirinya sendiri dan membiarkan member-nya tidak berubah. Ini bug yang diam-diam. this->x membuatnya jelas. Banyak codebase menghindari masalah ini sepenuhnya dengan memberi nama parameter yang berbeda (misalnya setX(int newX)), tetapi kamu akan sangat sering melihat this-> di kode nyata.

Kesalahan Umum

Beberapa jebakan class berulang kali menjebak orang:

• Lupa titik koma penutup. Definisi class diakhiri dengan };. Hilangkan ; dan kamu mendapat banjir error membingungkan yang menunjuk ke apa pun yang ada setelah class, bukan ke class-nya.
• Lupa menginisialisasi member. Member bawaan seperti int dan double tidak otomatis bernilai nol. Membaca member yang belum diinisialisasi adalah undefined behavior. Beri member nilai default (int count = 0;) atau inisialisasi di constructor.
• Mengakses member private dari luar. c.count = 5; pada member private adalah compile error, jadi lewat method public saja. Ini tandanya enkapsulasi bekerja sesuai rencana.
• Mencampuradukkan class dengan objek. Dog.bark(); itu salah, karena Dog adalah tipenya. Kamu memanggil method pada objek: rex.bark();.

// Uninitialized member - reading 'age' is undefined behavior:
class Cat {
public:
    int age;            // no default value
};

Cat c;
std::cout << c.age;     // garbage value, not 0

Berikutnya: Constructor

Mengisi setiap member secara manual setelah membuat objek, seperti rex.name = ...; rex.age = ...;, itu membosankan dan gampang terlupa. Persis seperti itulah member yang belum diinisialisasi muncul. Halaman berikutnya membahas constructor: fungsi khusus yang otomatis berjalan saat objek dibuat, sehingga kamu bisa menjamin setiap objek dimulai dalam keadaan valid dengan sintaks satu baris yang rapi, Dog rex("Rex", 4);.