Pewarisan C++: Penjelasan Base Class & Derived Class

Memakai Ulang Class dengan Memperluasnya

Kamu sudah membuat class dengan constructor dan membersihkannya dengan destructor. Pewarisan adalah langkah berikutnya: daripada menyalin member satu class ke class lain, kamu menyatakan bahwa class baru adalah versi khusus dari class yang sudah ada, dan membiarkannya mewarisi semuanya secara otomatis.

Class yang sudah ada disebut base class (atau induk); class yang baru disebut derived class (atau turunan). Derived class dimulai dengan semua data dan perilaku milik base class, lalu menambahkan atau mengubah apa yang membuatnya berbeda. Inilah alat utama C++ untuk hubungan "is-a": sebuah Dog adalah Animal, sebuah SavingsAccount adalah BankAccount.

Sintaks Dasar: class Derived : public Base

Kamu mewarisi dengan menulis titik dua setelah nama derived class, lalu access specifier, lalu nama base class. Bentuk yang paling umum adalah pewarisan public.

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

class Animal {
public:
    string name;
    void eat() {
        cout << name << " is eating." << endl;
    }
};

// Dog is-a Animal: it gets name and eat() for free
class Dog : public Animal {
public:
    void bark() {
        cout << name << " says woof!" << endl;
    }
};

int main() {
    Dog d;
    d.name = "Rex";   // inherited member
    d.eat();          // inherited method
    d.bark();         // Dog's own method
    return 0;
}

Dog tidak pernah mendeklarasikan name atau eat(), tetapi keduanya berfungsi pada objek Dog karena diwarisi dari Animal. Derived class bebas menambahkan member seperti bark() yang sama sekali tidak diketahui base class.

protected: Member Khusus untuk Turunan

Member private milik base class tidak bisa diakses di dalam derived class; pewarisan tidak merusak enkapsulasi. Kalau kamu ingin bagian dalam base class tersembunyi dari dunia luar tetapi tersedia bagi subclass, pakai access specifier protected.

#include <iostream>
using namespace std;

class BankAccount {
protected:
    double balance = 0;   // visible to derived classes, not to outsiders
public:
    void deposit(double amount) { balance += amount; }
    double getBalance() const { return balance; }
};

class SavingsAccount : public BankAccount {
public:
    void addInterest(double rate) {
        balance += balance * rate;   // OK: protected member is reachable here
    }
};

int main() {
    SavingsAccount s;
    s.deposit(1000);
    s.addInterest(0.05);
    cout << s.getBalance() << endl; // 1050
    // s.balance = 0;   // ERROR: protected, not accessible from main
    return 0;
}

Bayangkan ketiga level itu sebagai lingkaran konsentris: private berarti "hanya class ini," protected berarti "class ini dan turunannya," dan public berarti "semua orang." Lihat access-specifiers untuk gambaran lengkapnya.

Urutan Constructor dan Destructor

Objek turunan berisi subobjek base, dan bagian base itu harus sudah hidup sebelum bagian turunannya dibangun. Jadi pembuatan dimulai dari base, penghancuran dimulai dari turunan (persis kebalikannya). Kalau base class butuh argumen constructor, kamu meneruskannya lewat member initializer list.

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

class Animal {
    string name;
public:
    Animal(string n) : name(n) {
        cout << "Animal ctor: " << name << endl;
    }
    ~Animal() { cout << "Animal dtor: " << name << endl; }
};

class Dog : public Animal {
public:
    // forward the argument to the base constructor
    Dog(string n) : Animal(n) {
        cout << "Dog ctor" << endl;
    }
    ~Dog() { cout << "Dog dtor" << endl; }
};

int main() {
    Dog d("Rex");
    return 0;
}

Output-nya membuat urutan itu jadi konkret:

Animal ctor: Rex   // base built first
Dog ctor           // then the derived part
Dog dtor           // destroyed in reverse...
Animal dtor: Rex   // ...base last

Kalau kamu lupa : Animal(n) dan base class tidak punya default constructor, kodenya tidak akan bisa dikompilasi, karena C++ tidak tahu cara membangun bagian base-nya. Base class yang ingin kamu turunkan hampir selalu sebaiknya mendeklarasikan destructor (dan, seperti yang ditunjukkan halaman berikutnya, sering kali destructor virtual).

Overriding: Mendefinisikan Ulang Method Base Class

Derived class bisa mengganti method yang diwarisi dengan mendeklarasikan method bersignature sama. Kamu tetap bisa menjangkau versi aslinya lewat Base::method().

#include <iostream>
using namespace std;

class Shape {
public:
    void describe() const { cout << "A generic shape" << endl; }
};

class Circle : public Shape {
public:
    void describe() const {
        Shape::describe();              // call the base version explicitly
        cout << "...specifically a circle" << endl;
    }
};

int main() {
    Circle c;
    c.describe();
    return 0;
}

Ini hanya name hiding biasa, bukan polimorfisme: describe() mana yang berjalan ditentukan saat kompilasi berdasarkan tipe statis variabelnya. Itu batasan yang penting: kalau kamu memanggil lewat Shape& atau Shape* yang sebenarnya menunjuk ke Circle, kamu tetap mendapat Shape::describe(). Untuk memperbaikinya dibutuhkan virtual, topik halaman berikutnya.

Waspadai Object Slicing

Karena referensi atau pointer base bisa merujuk ke objek turunan, ada godaan untuk menyalin objek turunan ke variabel bertipe base. Jangan lakukan: bagian turunannya akan terpotong.

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

class Animal {
public:
    string name = "?";
};

class Dog : public Animal {
public:
    string breed = "Labrador";
};

int main() {
    Dog d;
    d.name = "Rex";

    Animal a = d;   // SLICING: only the Animal part is copied
    cout << a.name << endl;   // Rex
    // a.breed is gone - it was never part of an Animal
    return 0;
}

a adalah Animal sungguhan, bukan Dog yang memakai label base, jadi breed memang tidak ada padanya. Untuk bekerja dengan objek turunan secara polimorfik, kamu harus memakai referensi base (Animal&) atau pointer base (Animal*), jangan pernah nilai base. Slicing terjadi diam-diam: kodenya berhasil dikompilasi dan datanya hilang begitu saja. Karena itulah slicing termasuk bug pewarisan yang paling mudah lolos ke produksi.

Kesalahan Umum yang Perlu Dihindari

• Mengira member private milik base bisa dijangkau di turunan. Tidak bisa. Pakai protected untuk data yang memang dibutuhkan derived class, dan jaga keadaan yang benar-benar internal tetap private.
• Lupa meneruskan argumen constructor base. Kalau base class tidak punya default constructor, kamu harus memanggilnya secara eksplisit di initializer list constructor turunan (: Base(args)).
• Memotong objek turunan menjadi nilai base. Menyalin Dog ke Animal membuang semua yang khas Dog. Teruskan dan simpan referensi atau pointer base saja.
• Terlalu sering memakai pewarisan untuk memakai ulang kode. Pewarisan memodelkan "is-a". Kalau hubungannya sebenarnya "has-a" (sebuah Car punya Engine), utamakan komposisi, yaitu objek sebagai member, daripada pewarisan.

Berikutnya: Virtual Function

Override yang baru kamu lihat ditentukan saat kompilasi, jadi memanggil lewat pointer base mengabaikan versi turunannya. Halaman berikutnya, virtual-functions, memperkenalkan kata kunci virtual dan override: mekanisme yang membuat tipe saat program berjalan menentukan method mana yang dijalankan, membuka polimorfisme yang sesungguhnya, dan menjelaskan kenapa base class butuh virtual destructor.