C++ Builder Pattern

6 min read Jul 01, 2024

Pola Desain Builder di C++

Pola desain Builder adalah sebuah pola desain creational yang membantu dalam membangun objek kompleks dengan cara yang lebih terstruktur dan fleksibel. Pola ini memecah proses pembangunan objek menjadi langkah-langkah yang terpisah, memungkinkan Anda untuk menciptakan berbagai konfigurasi objek yang berbeda tanpa mengubah kode inti dari kelas objek tersebut.

Kapan Menggunakan Builder?

Pola Builder cocok digunakan dalam situasi berikut:

Konstruktor yang rumit: Ketika kelas memiliki banyak parameter konstruktor atau ketika konstruktor tersebut sulit dibaca dan dipahami.
Objek kompleks dengan banyak atribut: Jika objek memiliki banyak atribut yang dapat diubah, pola Builder memungkinkan Anda untuk membangun objek secara bertahap dan memilih hanya atribut yang diperlukan.
Memisahkan proses pembangunan dari representasi objek: Pola Builder membantu memisahkan logika pembangunan objek dari representasi objek itu sendiri.

Komponen Pola Builder

Pola Builder terdiri dari beberapa komponen:

Builder: Interface yang mendefinisikan metode untuk membangun bagian-bagian objek.
ConcreteBuilder: Kelas-kelas konkret yang mengimplementasikan interface Builder dan bertanggung jawab untuk membangun objek yang spesifik.
Director: Kelas yang mengarahkan proses pembangunan objek dengan memanggil metode dari objek Builder.
Product: Kelas yang merepresentasikan objek kompleks yang akan dibangun.

Implementasi Pola Builder dalam C++

Berikut contoh sederhana implementasi pola Builder dalam C++:

#include 

// Interface Builder
class Builder {
public:
  virtual void setPartA(const std::string& partA) = 0;
  virtual void setPartB(const std::string& partB) = 0;
  virtual void setPartC(const std::string& partC) = 0;
  virtual Product* getProduct() = 0;
};

// Kelas konkret Builder
class ConcreteBuilder1 : public Builder {
private:
  Product* product;
public:
  ConcreteBuilder1() : product(new Product) {}
  void setPartA(const std::string& partA) override {
    product->setPartA(partA);
  }
  void setPartB(const std::string& partB) override {
    product->setPartB(partB);
  }
  void setPartC(const std::string& partC) override {
    product->setPartC(partC);
  }
  Product* getProduct() override {
    return product;
  }
};

// Kelas konkret Builder
class ConcreteBuilder2 : public Builder {
private:
  Product* product;
public:
  ConcreteBuilder2() : product(new Product) {}
  void setPartA(const std::string& partA) override {
    product->setPartA(partA);
  }
  void setPartB(const std::string& partB) override {
    product->setPartB(partB);
  }
  void setPartC(const std::string& partC) override {
    product->setPartC(partC);
  }
  Product* getProduct() override {
    return product;
  }
};

// Kelas Product
class Product {
private:
  std::string partA;
  std::string partB;
  std::string partC;
public:
  void setPartA(const std::string& partA) {
    this->partA = partA;
  }
  void setPartB(const std::string& partB) {
    this->partB = partB;
  }
  void setPartC(const std::string& partC) {
    this->partC = partC;
  }
  void show() {
    std::cout << "Part A: " << partA << std::endl;
    std::cout << "Part B: " << partB << std::endl;
    std::cout << "Part C: " << partC << std::endl;
  }
};

// Kelas Director
class Director {
public:
  void construct(Builder* builder) {
    builder->setPartA("Part A1");
    builder->setPartB("Part B1");
    builder->setPartC("Part C1");
  }
};

int main() {
  // Membangun objek Product dengan ConcreteBuilder1
  ConcreteBuilder1* builder1 = new ConcreteBuilder1();
  Director director;
  director.construct(builder1);
  Product* product1 = builder1->getProduct();
  product1->show();

  // Membangun objek Product dengan ConcreteBuilder2
  ConcreteBuilder2* builder2 = new ConcreteBuilder2();
  director.construct(builder2);
  Product* product2 = builder2->getProduct();
  product2->show();

  delete builder1;
  delete builder2;
  delete product1;
  delete product2;

  return 0;
}

Keuntungan Menggunakan Pola Builder

Kode yang lebih terstruktur: Pola Builder membantu memecah proses pembangunan objek menjadi langkah-langkah yang terpisah, sehingga kode lebih mudah dibaca dan diubah.
Fleksibel: Pola Builder memungkinkan Anda untuk membuat berbagai konfigurasi objek yang berbeda tanpa mengubah kode inti dari kelas objek.
Menghindari konstruktor yang rumit: Pola Builder membantu menghindari konstruktor dengan banyak parameter, yang bisa menjadi sulit dibaca dan diubah.
Mudah untuk menambahkan langkah pembangunan baru: Anda dapat menambahkan langkah pembangunan baru dengan mudah dengan membuat kelas ConcreteBuilder baru dan mengimplementasikan metode yang sesuai.

Kesimpulan

Pola desain Builder adalah pola desain creational yang kuat yang membantu dalam membangun objek kompleks dengan cara yang terstruktur dan fleksibel. Pola ini sangat berguna dalam situasi di mana kelas memiliki konstruktor yang rumit atau ketika objek memiliki banyak atribut yang dapat diubah.