C++ Array Of Different Classes

6 min read Jul 05, 2024
C++ Array Of Different Classes

C++ Array of Different Classes

Dalam pemrograman C++, array biasanya digunakan untuk menyimpan kumpulan data dari tipe data yang sama. Namun, bagaimana jika kita ingin menyimpan objek dari kelas yang berbeda dalam satu array? Artikel ini akan membahas bagaimana cara membuat array dari kelas yang berbeda dalam C++.

Teknik Menggunakan Penunjuk ke Kelas Induk

Salah satu cara untuk menyimpan objek dari kelas yang berbeda dalam satu array adalah dengan menggunakan penunjuk ke kelas induk. Berikut langkah-langkahnya:

  1. Membuat Kelas Induk: Pertama, kita perlu membuat kelas induk (parent class) yang memiliki semua atribut dan metode yang umum di antara kelas-kelas turunan.

  2. Membuat Kelas Turunan: Selanjutnya, kita membuat kelas turunan (child classes) yang mewarisi dari kelas induk. Kelas turunan ini dapat memiliki atribut dan metode tambahan yang spesifik untuk kelas tersebut.

  3. Deklarasi Array Penunjuk: Kita dapat mendeklarasikan array penunjuk ke kelas induk. Array ini dapat menyimpan objek dari kelas turunan yang berbeda, karena semua kelas turunan mewarisi dari kelas induk.

  4. Alokasi Dinamis: Setiap elemen array penunjuk dapat dialokasikan secara dinamis untuk menyimpan alamat objek dari kelas turunan.

Contoh:

#include 

// Kelas induk
class Animal {
public:
    virtual void makeSound() = 0;
};

// Kelas turunan
class Dog : public Animal {
public:
    void makeSound() override {
        std::cout << "Woof!" << std::endl;
    }
};

class Cat : public Animal {
public:
    void makeSound() override {
        std::cout << "Meow!" << std::endl;
    }
};

int main() {
    // Deklarasi array penunjuk ke kelas induk
    Animal* animalArray[2];

    // Alokasi dinamis untuk objek Dog dan Cat
    animalArray[0] = new Dog();
    animalArray[1] = new Cat();

    // Panggil metode makeSound() pada objek Dog dan Cat
    animalArray[0]->makeSound();  // Output: Woof!
    animalArray[1]->makeSound();  // Output: Meow!

    // Hapus alokasi dinamis
    delete animalArray[0];
    delete animalArray[1];

    return 0;
}

Teknik Menggunakan std::vector dan std::variant

Jika kita menggunakan C++17 atau lebih baru, kita dapat memanfaatkan std::vector dan std::variant untuk menyimpan objek dari kelas yang berbeda dalam satu array.

  1. Deklarasikan std::vector: Gunakan std::vector untuk menyimpan objek.
  2. Gunakan std::variant: Gunakan std::variant untuk menyimpan objek dari kelas yang berbeda dalam setiap elemen std::vector.

Contoh:

#include 
#include 
#include 

class Dog {
public:
    void bark() {
        std::cout << "Woof!" << std::endl;
    }
};

class Cat {
public:
    void meow() {
        std::cout << "Meow!" << std::endl;
    }
};

int main() {
    // Deklarasikan vector dengan std::variant sebagai tipe datanya
    std::vector> animalVector;

    // Tambahkan objek Dog dan Cat ke dalam vector
    animalVector.push_back(Dog());
    animalVector.push_back(Cat());

    // Akses objek dan panggil metodenya
    std::get(animalVector[0]).bark();  // Output: Woof!
    std::get(animalVector[1]).meow();  // Output: Meow!

    return 0;
}

Keuntungan dan Kekurangan

Teknik Penunjuk ke Kelas Induk:

Keuntungan:

  • Fleksibel dalam menyimpan berbagai jenis objek turunan.
  • Lebih mudah diimplementasikan.

Kekurangan:

  • Membutuhkan alokasi dinamis, sehingga meningkatkan kemungkinan kebocoran memori jika tidak dikelola dengan benar.
  • Dapat menjadi rumit untuk mengelola alokasi memori dan pointer.

Teknik std::vector dan std::variant:

Keuntungan:

  • Mengatur alokasi memori secara otomatis.
  • Menyederhanakan pengelolaan objek.
  • Lebih aman dan lebih efisien.

Kekurangan:

  • Membutuhkan C++17 atau lebih baru.
  • Dapat menjadi sedikit lebih kompleks dalam implementasi.

Kesimpulan

Ada beberapa cara untuk membuat array dari kelas yang berbeda dalam C++. Pilih metode yang paling sesuai dengan kebutuhan Anda dan pastikan untuk mengelola memori dengan benar untuk menghindari kebocoran memori. Teknik menggunakan std::vector dan std::variant menawarkan solusi yang lebih efisien dan aman, tetapi membutuhkan C++17 atau lebih baru.

Latest Posts


Featured Posts