[Original][Creative Mode] Understanding of Builder Mode

My understanding :
    In actual projects, many times our communication with some devices is done through data flow. Users and devices are processed through fixed-format packets. An example used in an actual project
is
    has a strict format, and different parameters have different meanings. Come, it can be understood as a typical Builder Pattern.

Process:
    The user represents the behavior of the client, so the logic is as follows:
    (1) The user connects to the device and determines the composition of the data packet according to the protocol. A complete data packet is actually a Product;
    (2) After determining the components of the data packet , we need to determine the order of each data composition (Director); in the example, the order of the data packets is 1, 2, 3, 4, 5;
but according to different situations, it is modified to 4, 1, 2, 3, 5, It is also very possible;
    (3) Use the original composition data to form a complete data packet in a certain order;




header file

//BuilderPattern.h

#ifndef BUILDER_PATTERN_H
#define BUILDER_PATTERN_H

#include <Windows.h>
#include <string>
using namespace std;

namespace BuilderPattern
{
    class Product
    {
    public:
        Product();
        ~Product();

        void AddPart(string strPart);
        string DisplayProduct();
        void EmptyParts();

    private:
        string m_strFullParts;
    };

    // Base Class
    //////////////////////////////////////////////////////////////////////////
    class AbstractBuilder
    {
    public:
        AbstractBuilder();
        virtual ~AbstractBuilder();

        virtual void BuildHead() = 0;
        virtual void BuildData() = 0;
        virtual void BuildType() = 0;
        virtual void BuildP1P1() = 0;
        virtual void BuildLen() = 0;
        virtual Product* GetProduct() = 0;
    };


    //////////////////////////////////////////////////////////////////////////
    class ConcreteBuilderA : public AbstractBuilder
    {
    public:
        ConcreteBuilderA(Product* pProduct);
        virtual ~ConcreteBuilderA();

        virtual void BuildHead();
        virtual void BuildData();
        virtual void BuildType();
        virtual void BuildP1P1();
        virtual void BuildLen();
        virtual Product* GetProduct();

    private:
        Product* m_pProduct;
    };

    //////////////////////////////////////////////////////////////////////////
    class ConcreteBuilderB : public AbstractBuilder
    {
    public:
        ConcreteBuilderB(Product* pProduct);
        virtual ~ConcreteBuilderB();

        virtual void BuildHead();
        virtual void BuildData();
        virtual void BuildType();
        virtual void BuildP1P1();
        virtual void BuildLen();
        virtual Product* GetProduct();

    private:
        Product* m_pProduct;
    };

    //////////////////////////////////////////////////////////////////////////
    class Director
    {
    public:
        Director(AbstractBuilder* pAbstractBuilder);
        ~Director();
        void Construct1();
        void Construct2();


    private:
        AbstractBuilder* m_pAbstractBuilder;
    };


    //////////////////////////////////////////////////////////////////////////
    void BuilderPattern_Test_A();
    void BuilderPattern_Test_B();

}

#endif

accomplish

#include "BuilderPattern.h"
#include <iostream>
using namespace std;

namespace BuilderPattern
{

    //////////////////////////////////////////////////////////////////////////
    Product::Product()
    {
    }
    Product::~Product()
    {
    }

    void Product::AddPart(string strPart)
    {
        m_strFullParts += strPart;
    }

    string Product::DisplayProduct()
    {
        cout << m_strFullParts << endl;
        return m_strFullParts;
    }

    void Product::EmptyParts()
    {
        m_strFullParts = "";
    }

    //////////////////////////////////////////////////////////////////////////
    AbstractBuilder::AbstractBuilder()
    {
    }
    AbstractBuilder::~AbstractBuilder()
    {
    }

    //////////////////////////////////////////////////////////////////////////
    ConcreteBuilderA::ConcreteBuilderA(Product* pProduct)
        : m_pProduct (NULL)
    {
        if (pProduct! = NULL)
        {
            m_pProduct = pProduct;
        }
    }

    ConcreteBuilderA::~ConcreteBuilderA()
    {
        if (m_pProduct != NULL)
        {
            delete m_pProduct;
            m_pProduct = NULL;
        }
    }

    void ConcreteBuilderA::BuildHead()
    {
        m_pProduct->AddPart("ConcreteBuilderA::BuildHead\n");
    }
    void ConcreteBuilderA::BuildData()
    {
        m_pProduct->AddPart("ConcreteBuilderA::BuildData\n");
    }
    void ConcreteBuilderA::BuildType()
    {
        m_pProduct->AddPart("ConcreteBuilderA::BuildType\n");
    }
    void ConcreteBuilderA::BuildP1P1()
    {
        m_pProduct->AddPart("ConcreteBuilderA::BuildP1P1\n");
    }
    void ConcreteBuilderA::BuildLen()
    {
        m_pProduct->AddPart("ConcreteBuilderA::BuildLen\n");
    }
    Product* ConcreteBuilderA::GetProduct()
    {
        return m_pProduct;
    }


    //////////////////////////////////////////////////////////////////////////
    ConcreteBuilderB::ConcreteBuilderB(Product* pProduct)
        : m_pProduct (NULL)
    {
        if (pProduct! = NULL)
        {
            m_pProduct = pProduct;
        }
    }

    ConcreteBuilderB::~ConcreteBuilderB()
    {
        if (m_pProduct != NULL)
        {
            delete m_pProduct;
            m_pProduct = NULL;
        }
    }

    void ConcreteBuilderB::BuildHead()
    {
        m_pProduct->AddPart("ConcreteBuilderB::BuildHea\n");
    }
    void ConcreteBuilderB::BuildData()
    {
        m_pProduct->AddPart("ConcreteBuilderB::BuildData\n");
    }
    void ConcreteBuilderB::BuildType()
    {
        m_pProduct->AddPart("ConcreteBuilderB::BuildType\n");
    }
    void ConcreteBuilderB::BuildP1P1()
    {
        m_pProduct->AddPart("ConcreteBuilderB::BuildP1P1\n");
    }
    void ConcreteBuilderB::BuildLen()
    {
        m_pProduct->AddPart("ConcreteBuilderB::BuildLen\n");
    }
    Product* ConcreteBuilderB::GetProduct()
    {
        return m_pProduct;
    }

    //////////////////////////////////////////////////////////////////////////
    Director::Director(AbstractBuilder* pAbstractBuilder)
        : m_pAbstractBuilder(NULL)
    {
        if (pAbstractBuilder != NULL)
        {
            m_pAbstractBuilder = pAbstractBuilder;
        }
    }
    Director :: ~ Director ()
    {
        if (m_pAbstractBuilder != NULL)
        {
            delete m_pAbstractBuilder;
            m_pAbstractBuilder = NULL;
        }
    }
    void Director::Construct1()
    {
        m_pAbstractBuilder->GetProduct()->EmptyParts();

        m_pAbstractBuilder->BuildData();
        m_pAbstractBuilder->BuildType();
        m_pAbstractBuilder->BuildP1P1();
        m_pAbstractBuilder->BuildLen();
        m_pAbstractBuilder->BuildData();

        m_pAbstractBuilder->GetProduct()->DisplayProduct();
    }

    void Director::Construct2()
    {
        m_pAbstractBuilder->GetProduct()->EmptyParts();

        m_pAbstractBuilder->BuildLen();
        m_pAbstractBuilder->BuildData();
        m_pAbstractBuilder->BuildType();
        m_pAbstractBuilder->BuildP1P1();
        m_pAbstractBuilder->BuildData();

        m_pAbstractBuilder->GetProduct()->DisplayProduct();
    }

    //////////////////////////////////////////////////////////////////////////
    void BuilderPattern_Test_A()
    {
        Director* pDirector = new Director(new ConcreteBuilderA(new Product()));

        pDirector->Construct1();
        pDirector->Construct2();

        delete pDirector;
        pDirector = NULL;
    }

    void BuilderPattern_Test_B()
    {
        Director* pDirector = new Director(new ConcreteBuilderB(new Product()));

        pDirector->Construct1();
        pDirector->Construct2();

        delete pDirector;
        pDirector = NULL;
    }
}

client

#include "BuilderPattern.h"

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

void main()
{
    BuilderPattern_Test_A();
    BuilderPattern_Test_B();
}

operation result