struct dan class

Struktur data seperti linked list, tree, atau graph memerlukan cara untuk membungkus beberapa variabel menjadi satu unit logis. C++ menyediakan struct dan class untuk tujuan tersebut. Pada Chapter ini kita akan mempelajari cara mendefinisikan tipe data baru dengan struct/class, menyembunyikan detail implementasi dengan access specifier, menggunakan constructor, dan membangun blok dasar Node untuk linked list — pondasi banyak struktur data yang akan kita pelajari nanti.

struct untuk Kumpulan Data #

struct adalah cara termudah mengelompokkan beberapa variabel menjadi satu tipe. Secara default seluruh anggota struct bersifat public — dapat diakses dari luar langsung.

Mekanisme: Tipe Baru dengan Member #

Ketika kita menulis struct Titik { int x; int y; };, compiler membuat tipe baru bernama Titik. Variabel bertipe Titik memesan memori cukup untuk dua int (biasanya 8 byte berurutan). Anggota diakses dengan operator titik ..

Kode: Struct Sederhana #

#include <iostream>

struct Titik {
    int x;
    int y;
};

int main() {
    Titik p{3, 4};
    std::cout << "titik: (" << p.x << "," << p.y << ")\n";
    return 0;
}

Output yang Dihasilkan:

titik: (3,4)

1. Baris struct Titik { int x; int y; };: mendefinisikan tipe Titik dengan dua anggota x dan y. Tanda titik koma di akhir struct wajib.
2. Baris Titik p{3, 4};: membuat variabel p bertipe Titik dan menginisialisasi x=3, y=4 secara aggregate.
3. Baris p.x: akses anggota x dari p melalui operator ..

class dengan Access Specifier #

class mirip struct, tetapi default access-nya private. Ini berarti anggota tidak dapat diakses dari luar kecuali dideklarasikan public. Konsep ini disebut encapsulation — menyembunyikan detail implementasi dan menyediakan antarmuka yang stabil.

Kode: Class Stack Sederhana #

#include <iostream>
#include <vector>

class Stack {
private:
    std::vector<int> data_;
public:
    void push(int nilai) {
        data_.push_back(nilai);
    }

    int pop() {
        int atas = data_.back();
        data_.pop_back();
        return atas;
    }

    bool empty() const {
        return data_.empty();
    }

    std::size_t size() const {
        return data_.size();
    }
};

int main() {
    Stack s;
    s.push(10);
    s.push(20);
    s.push(30);
    std::cout << "size  = " << s.size() << '\n';
    std::cout << "pop   = " << s.pop() << '\n';
    std::cout << "pop   = " << s.pop() << '\n';
    std::cout << "empty = " << std::boolalpha << s.empty() << '\n';
    return 0;
}

Output yang Dihasilkan:

size  = 3
pop   = 30
pop   = 20
empty = false

1. Baris private:: anggota setelah label ini hanya dapat diakses dari dalam class. data_ disembunyikan dari pengguna Stack.
2. Baris public:: anggota setelah label ini dapat diakses dari luar. Method push, pop, empty, dan size membentuk antarmuka publik.
3. Baris void push(int nilai): menambah elemen ke akhir data_. Pengguna tidak perlu tahu bahwa internal memakai std::vector.
4. Baris int pop(): mengambil elemen terakhir, menghapus dari data_, lalu mengembalikan nilainya. Mengikuti pola LIFO (Last In First Out).
5. Baris bool empty() const: keyword const setelah parameter menandakan method ini tidak memodifikasi objek. Memungkinkan pemanggilan pada instance const.

Constructor dan Member Initializer List #

Constructor adalah method khusus yang dipanggil saat objek dibuat. Ia menginisialisasi anggota ke keadaan valid. Member initializer list menginisialisasi anggota sebelum badan constructor berjalan — lebih efisien daripada assignment di badan.

Mekanisme: Inisialisasi Sebelum Badan #

Saat objek dibuat, setiap anggota diinisialisasi secara default terlebih dahulu, lalu constructor berjalan. Dengan member initializer list Node(int v) : nilai(v), berikutnya(nullptr) {}, kita menulis langsung ke anggota tanpa dua langkah (default-init + assign).

Kode: Node Linked List #

#include <iostream>

class Node {
public:
    int nilai;
    Node* berikutnya;
    Node(int v) : nilai(v), berikutnya(nullptr) {}
};

int main() {
    Node a(1), b(2), c(3);
    a.berikutnya = &b;
    b.berikutnya = &c;

    Node* cur = &a;
    std::cout << "list: ";
    while (cur != nullptr) {
        std::cout << cur->nilai << " -> ";
        cur = cur->berikutnya;
    }
    std::cout << "null\n";
    return 0;
}

Output yang Dihasilkan:

list: 1 -> 2 -> 3 -> null

1. Baris Node(int v) : nilai(v), berikutnya(nullptr) {}: constructor dengan member initializer list. nilai(v) menginisialisasi nilai dengan v; berikutnya(nullptr) menginisialisasi pointer ke null.
2. Baris Node a(1), b(2), c(3);: membuat tiga node dengan nilai 1, 2, 3. Constructor dipanggil otomatis.
3. Baris a.berikutnya = &b;: menghubungkan node a ke b. Penggunaan pointer Node* adalah pondasi linked list.
4. Baris cur->nilai: operator -> mengkombinasikan dereference dan akses anggota, ekuivalen dengan (*cur).nilai tapi lebih ringkas.

struct vs class: Mana yang Dipilih #

Aturan praktis:

Perbedaan teknis antara struct dan class hanyalah default access — semua fitur OOP (constructor, inheritance, method) tersedia di keduanya. Pilihan lebih merupakan sinyal niat: struct menyiratkan “kumpulan data”, class menyiratkan “tipe dengan invariants”.

Ringkasan #

• struct dan class membuat tipe baru dengan anggota; perbedaan utama adalah default access (public vs private).
• Encapsulation menyembunyikan detail implementasi dengan private dan menyediakan API public.
• Constructor dengan member initializer list menginisialisasi anggota secara efisien sebelum badan constructor berjalan.
• Method const (suffix const setelah parameter) menandakan method tidak memodifikasi objek — panggil pada instance const.
• Untuk DSA, Node dengan pointer berikutnya adalah blok dasar linked list, tree, dan graph — pola yang akan kita pakai berulang kali.