Constructor C++: Menginisialisasi Objek dengan Benar

Apa Itu Constructor

Di halaman sebelumnya kamu mendefinisikan class dan memberinya member variable. Namun member pada objek yang baru dibuat berisi sampah apa pun yang ada di memori itu, kecuali kamu mengisinya. Constructor mengatasi hal ini: ia adalah member function khusus yang berjalan otomatis saat objek dibuat, dan satu-satunya tugasnya adalah meninggalkan objek dalam keadaan yang valid dan terinisialisasi penuh.

Constructor punya nama yang sama dengan class-nya dan tidak punya tipe kembalian, bahkan bukan void. Kamu tidak pernah memanggilnya secara langsung; compiler memanggilkannya untukmu setiap kali sebuah objek muncul.

#include <iostream>
using namespace std;

class Counter {
public:
    int value;

    Counter() {          // constructor: same name as the class, no return type
        value = 0;
        cout << "Counter created\n";
    }
};

int main() {
    Counter c;           // the constructor runs right here
    cout << c.value << "\n";   // 0, not garbage
    return 0;
}

Counter() yang tanpa parameter disebut default constructor, yaitu constructor yang dipakai saat kamu membuat objek tanpa memberikan argumen.

Parameterized Constructor

Constructor tanpa argumen memang cukup, tetapi biasanya kamu ingin membuat objek dengan nilai tertentu. Parameterized constructor menerima argumen dan memakainya untuk menginisialisasi member.

#include <iostream>
using namespace std;

class Point {
public:
    int x;
    int y;

    Point(int startX, int startY) {
        x = startX;
        y = startY;
    }
};

int main() {
    Point p(3, 4);                // pass the values at creation
    cout << p.x << ", " << p.y << "\n";   // 3, 4
    return 0;
}

Sebuah class boleh punya lebih dari satu constructor, asalkan daftar parameternya berbeda. Ini sama dengan function overloading biasa, hanya saja diterapkan pada constructor. Di sini Point bisa dibuat dengan atau tanpa koordinat:

#include <iostream>
using namespace std;

class Point {
public:
    int x, y;

    Point() {            // default constructor
        x = 0;
        y = 0;
    }

    Point(int startX, int startY) {   // parameterized constructor
        x = startX;
        y = startY;
    }
};

int main() {
    Point origin;        // calls Point()
    Point p(3, 4);       // calls Point(int, int)

    cout << origin.x << ", " << origin.y << "\n";  // 0, 0
    cout << p.x << ", " << p.y << "\n";            // 3, 4
    return 0;
}

Jebakan yang umum: Point p(); tidak membuat objek. Compiler membacanya sebagai deklarasi fungsi bernama p yang mengembalikan Point. Untuk memanggil default constructor, tulis Point p; (tanpa tanda kurung) atau Point p{}; dengan kurung kurawal.

Member Initializer List

Sejauh ini contoh-contohnya mengisi member di dalam isi constructor. Cara itu berfungsi untuk tipe sederhana, tetapi bukan alat yang tepat. Saat isi constructor berjalan, setiap member sudah dibuat dengan nilai default; isi constructor lalu membuang nilai itu dan menimpanya. Member initializer list menginisialisasi setiap member secara langsung, sebelum isi constructor, dalam satu langkah.

Sintaksnya berupa titik dua setelah daftar parameter, lalu pasangan member(value):

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

class User {
public:
    string name;
    int age;

    User(string n, int a) : name(n), age(a) {   // initializer list
        // body can stay empty
    }
};

int main() {
    User u("Ada", 36);
    cout << u.name << " is " << u.age << "\n";   // Ada is 36
    return 0;
}

Untuk member string, cara ini juga menghindari pembuatan string kosong yang lalu ditimpa: initializer list langsung membangunnya dengan benar sejak awal.

Initializer list bukan sekadar optimasi; ia wajib dalam tiga kasus, karena isi constructor hanya bisa mengisi nilai, bukan menginisialisasi:

• Member const: kamu tidak bisa mengisi const setelah ia ada.
• Member referensi: referensi harus diikat saat ia dibuat.
• Member yang tipenya tidak punya default constructor.

class Sensor {
    const int id;        // const member
    int& slot;           // reference member

public:
    Sensor(int sensorId, int& s) : id(sensorId), slot(s) {}
    // Trying to set id or slot in the body would not compile.
};

Satu detail halus yang perlu kamu tahu: member diinisialisasi sesuai urutan deklarasi-nya di class, bukan urutan kamu menuliskannya di initializer list. Kalau initializer satu member membaca member lain, urutan deklarasilah yang menentukan. Ketidakcocokan keduanya adalah sumber klasik pemakaian nilai yang belum diinisialisasi.

Argumen Default dan Delegating Constructor

Kamu tidak selalu butuh overload terpisah. Argumen default membuat satu constructor bisa menangani beberapa kasus: hilangkan sebuah argumen dan nilai default akan mengisinya:

#include <iostream>
using namespace std;

class Point {
public:
    int x, y;

    Point(int startX = 0, int startY = 0) : x(startX), y(startY) {}
};

int main() {
    Point a;          // 0, 0
    Point b(5);       // 5, 0
    Point c(5, 9);    // 5, 9

    cout << a.x << "," << a.y << "  "
         << b.x << "," << b.y << "  "
         << c.x << "," << c.y << "\n";
    return 0;
}

Hati-hati menggabungkan parameterized constructor yang punya nilai default dengan default constructor Point() yang terpisah. Compiler tidak bisa menentukan mana yang harus dipanggil untuk Point p; dan akan melaporkan ambiguitas. Pilih salah satu cara saja.

Kalau kamu memang punya beberapa constructor dengan langkah persiapan yang sama, delegating constructor (C++11) membuat satu constructor bisa memanggil constructor lain alih-alih mengulang logikanya. Kamu "mendelegasikan" dengan menaruh constructor lain itu di initializer list:

#include <iostream>
using namespace std;

class Rectangle {
public:
    int width, height;

    Rectangle(int w, int h) : width(w), height(h) {
        cout << "full constructor\n";
    }

    Rectangle() : Rectangle(1, 1) {   // delegates to the constructor above
        cout << "default delegated\n";
    }
};

int main() {
    Rectangle r;                      // runs full constructor, then default body
    cout << r.width << "x" << r.height << "\n";   // 1x1
    return 0;
}

Copy Constructor

Saat kamu membuat objek sebagai salinan objek lain, misalnya dengan meneruskannya by value, mengembalikannya, atau menulis Foo b = a;, yang berjalan adalah copy constructor. Signature-nya menerima referensi const ke tipe yang sama:

ClassName(const ClassName& other);

Kalau kamu tidak menulisnya, compiler membuatkan copy constructor default yang menyalin setiap member. Untuk class yang hanya berisi nilai (int, string, vector), itu sudah tepat dan kamu sebaiknya tidak menulis versimu sendiri.

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

class Box {
public:
    string label;
    int size;

    Box(string l, int s) : label(l), size(s) {}

    // Custom copy constructor, here just to see it fire:
    Box(const Box& other) : label(other.label + " (copy)"), size(other.size) {
        cout << "copy made\n";
    }
};

int main() {
    Box original("widget", 10);
    Box duplicate = original;      // copy constructor runs

    cout << duplicate.label << " " << duplicate.size << "\n";  // widget (copy) 10
    return 0;
}

Jebakan besarnya ada di bab berikutnya tentang memori: kalau class-mu memiliki raw pointer ke memori heap, copy constructor default menyalin pointer-nya, bukan datanya. Akibatnya dua objek menunjuk ke memori yang sama, dan keduanya akan mencoba membebaskannya. Itulah bug double-free. Patokannya adalah Rule of Three/Five: kalau kamu menulis destructor sendiri, hampir pasti kamu juga butuh copy constructor (dan copy assignment) sendiri. Di C++ modern, solusi yang lebih rapi adalah menyimpan std::vector atau smart pointer supaya copy yang dibuat compiler langsung berfungsi.

Perhatikan juga bahwa menerima parameter by reference itu wajib, bukan pilihan: copy constructor yang menerima argumennya by value harus menyalin argumen itu untuk memanggil dirinya sendiri. Hasilnya rekursi tanpa akhir yang bahkan tidak akan bisa dikompilasi.

Berikutnya: Destructor

Constructor menyiapkan objek; destructor membongkarnya. Saat objek keluar dari scope atau di-delete, destructor-nya berjalan otomatis. Ini tempat yang tepat untuk melepaskan file, koneksi jaringan, atau memori heap yang dipegang objek itu. Halaman berikutnya membahas cara kerja destructor, kapan tepatnya ia berjalan, dan bagaimana ia berpasangan dengan constructor untuk membentuk pola RAII yang andal di C++.