C++ Builder Pattern Interface

MUAZHAN

5 min read

·

Jul 01, 2024

29

Share

C++ Builder Pattern Interface

Pola desain Builder merupakan pola desain kreasi yang memungkinkan Anda untuk membangun objek kompleks secara bertahap, langkah demi langkah. Dalam C++, pola ini biasanya diimplementasikan dengan menggunakan antarmuka untuk mendefinisikan langkah-langkah dalam proses pembangunan objek.

Bagaimana Pola Builder Berfungsi

1. Interface: Anda pertama-tama mendefinisikan sebuah interface (misalnya, Builder) yang mendeklarasikan metode untuk setiap langkah dalam proses pembangunan objek.

2. Concrete Builders: Kemudian, Anda membuat kelas-kelas concrete yang mengimplementasikan interface Builder. Setiap kelas concrete mewakili variasi berbeda dari objek yang sedang dibangun.

3. Director: Sebuah kelas Director akan berinteraksi dengan concrete builder untuk membangun objek sesuai kebutuhan. Director menggunakan metode yang ditentukan dalam interface Builder untuk membangun objek secara langkah demi langkah.

Keuntungan Pola Builder

• Memisahkan konstruksi dari representasi: Pola ini memisahkan detail konstruksi objek dari representasi objek itu sendiri. Hal ini membuat kode lebih mudah dibaca dan diubah.
• Membuat objek yang kompleks lebih mudah dikonstruksi: Dengan membagi konstruksi menjadi langkah-langkah yang lebih kecil, Anda dapat membuat objek kompleks lebih mudah dibangun dan diubah.
• Memungkinkan Anda untuk membuat variasi objek yang berbeda: Anda dapat membuat berbagai variasi objek yang kompleks dengan menggunakan kelas ConcreteBuilder yang berbeda.

Contoh Implementasi

#include 

// Interface Builder
class Builder {
public:
    virtual void setPartA() = 0;
    virtual void setPartB() = 0;
    virtual void setPartC() = 0;
    virtual Product* getProduct() = 0;
};

// Produk yang akan dibangun
class Product {
private:
    std::string partA;
    std::string partB;
    std::string partC;

public:
    void setPartA(const std::string& part) { partA = part; }
    void setPartB(const std::string& part) { partB = part; }
    void setPartC(const std::string& part) { partC = part; }

    void showProduct() const {
        std::cout << "Product: " << std::endl;
        std::cout << "Part A: " << partA << std::endl;
        std::cout << "Part B: " << partB << std::endl;
        std::cout << "Part C: " << partC << std::endl;
    }
};

// Concrete Builder 1
class ConcreteBuilder1 : public Builder {
private:
    Product* product;
public:
    ConcreteBuilder1() { product = new Product(); }

    void setPartA() override { product->setPartA("Part A1"); }
    void setPartB() override { product->setPartB("Part B1"); }
    void setPartC() override { product->setPartC("Part C1"); }

    Product* getProduct() override { return product; }
};

// Concrete Builder 2
class ConcreteBuilder2 : public Builder {
private:
    Product* product;
public:
    ConcreteBuilder2() { product = new Product(); }

    void setPartA() override { product->setPartA("Part A2"); }
    void setPartB() override { product->setPartB("Part B2"); }
    void setPartC() override { product->setPartC("Part C2"); }

    Product* getProduct() override { return product; }
};

// Director
class Director {
public:
    void construct(Builder* builder) {
        builder->setPartA();
        builder->setPartB();
        builder->setPartC();
    }
};

int main() {
    // Menggunakan ConcreteBuilder1
    ConcreteBuilder1* builder1 = new ConcreteBuilder1();
    Director director;
    director.construct(builder1);
    Product* product1 = builder1->getProduct();
    product1->showProduct();

    // Menggunakan ConcreteBuilder2
    ConcreteBuilder2* builder2 = new ConcreteBuilder2();
    director.construct(builder2);
    Product* product2 = builder2->getProduct();
    product2->showProduct();

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

    return 0;
}

Kesimpulan

Pola desain Builder sangat berguna dalam membangun objek kompleks dengan cara yang terstruktur dan fleksibel. Dengan menggunakan interface dan kelas concrete, Anda dapat dengan mudah membuat variasi objek yang berbeda dengan cara yang terorganisir dan mudah diubah.