Factory Design Pattern Example - Review

[ravss2]

Hi ,

I have written the below program to demonstrate factory design pattern out of my understanding from the study.

my Doubt is almost all the examples on internet are using interface create function as static, can this be a proper example for factory design pattern.

#include <iostream>

using namespace std;

enum ProductType { ProductType1 = 0, ProductType2 };

//Interface
class InterfaceClass
{
    public:
        virtual void nameOfProduct() = 0;
        void createProduct(ProductType type);
};

//product 1
class Product1Class : public InterfaceClass
{
    public:
        virtual void nameOfProduct() {
            cout<<"Creating Product 1" <<endl;
        }
};

//product 2
class Product2Class : public InterfaceClass
{
    public:
        virtual void nameOfProduct() {
            cout<<"Creating Product 2" <<endl;
        }
};

#if 0
/*
client class implements the products
if library class (Interface class ) changes by adding a new product , 
we will have to add one more if-else to the new product, 
so for complex class or products this will be not desired

*/
class ClientClass{
    private:
        InterfaceClass *Prod;
    public:
    ClientClass(ProductType type){
        if(type == ProductType1 )
            Prod = new Product1Class;
        else if(type == ProductType2)
            Prod =new Product2Class;
    }
    
    ~ClientClass(){
        if(Prod)
            delete Prod;
        Prod = NULL;
    }
    InterfaceClass *getProduct() {
        return Prod;
    }
        
};

#endif

/*
    Better design   
*/

InterfaceClass * createProduct(ProductType type)
{
    InterfaceClass * Prod = NULL;
    
     if(type == ProductType1 )
        Prod = new Product1Class;
        else if(type == ProductType2)
        Prod =new Product2Class;   
        
        return Prod;
}

class ClientClass{
    private:
        InterfaceClass *Prod;
    public:
    ClientClass(ProductType type){
        Prod  = createProduct(type);
    }
    ~ClientClass(){
        if(Prod)
            delete Prod;
        Prod = NULL;
    }
    InterfaceClass *getProduct() {
        return Prod;
    }
        
};


int main() {

    ClientClass *Cp1 = new ClientClass(ProductType1);
    Cp1->getProduct()->nameOfProduct();
    
    ClientClass *Cp2 = new ClientClass(ProductType2);
    Cp2->getProduct()->nameOfProduct();
    
    return 0;
}

[TheToaster]

A proper factory should be static. This is because it should technically not require access based on individual objects. All it should do is return an object of that class's type, which could be a subclass/derived type.

std::make_shared is a popular example of a factory function in the standard library

[mbozzi]

Try not to put obvious information in the names of entities. It is obvious from the declaration
class ClientClass
That ClientClass is a class type.

Similarly, it is obvious from the declaration
int CounterVariable
That CounterVariable is a variable.

Either use the space to make the code clearer, or make the code shorter, and eliminate the obvious information.

[thmm]

A factory could also be a class if it needs resources.
Imagine a factory that creates sprites.
Sprites might need bitmaps, so the factory need a way to know about the bitmaps and store them.
A factory can also be abstract so that you can choose between different factories at runtime.