Need comment on Factory Pattern Example

Hi All,

I am studying design patterns and create a program for "Factory Pattern ".

I have read various tutorials and create my own with the help of it.

I just need your comments that whether this implementation is correct or it can be made

accurate according to Factory pattern.

Code:

#include<iostream>
using namespace std;

class Pizza
{
public:
    virtual void displayPrice() = 0;   
};

class MacDonald : public Pizza
{
public:
    int m_price;

    MacDonald() {}

    MacDonald( int price )
    {
        m_price = price;
    }

    void displayPrice()
    { 
        cout<<"The Rate of MacDonald Pizza is "<<120;
    } 
};

class HotMillion : public Pizza
{
public:
    int m_price;

    HotMillion(){}

    HotMillion(int price )
    {
       m_price = price;     
    }

    void displayPrice()
    { 
        cout<<"The Rate of HotMillion Pizza is "<<200;
    } 
};

class Factory
{
public:

int m_index;
    Factory(int index)
    {
        m_index = index;
    } 

     Pizza* show()
     {    
        switch( m_index )
        {
            case 1:
            new  MacDonald;
            break; 
            
            case 2:
            new  HotMillion;
            break;
        } 
    }
};


int main()
{
    Factory a( 1 ); 
    Pizza *p = a.show();
    p->displayPrice();
}

Its running fine and values are hard coded for time being.

Please give your valuable suggestion.

Thanks

Code:

     Pizza* show()
     {    
        switch( m_index )
        {
            case 1:
            new  MacDonald;
            break; 
            
            case 2:
            new  HotMillion;
            break;
        } 
    }

Using a switch pattern such as this is usually a poor Factory (I think at least).
A better approach might be a virtual function.

Typically, you may derive your objects from the factories and overload a New function that is virtual and returns an object of itself.
The Factory can then call this virtual function New() and return a correct object.
With this, you wouldn't need a switch at all.

A factory, generically, is any object, function, or class that can create another object -- or retrieve/find an object (picture the factory as a special warehouse) and return a reference/pointer to it. If a factory creates an object, it is also usually a good idea to have a defined manner to destroy the object when finished with it.

Ideally, a factory would not need to be modified to support new object types (i.e. you would not need to hardcode some function to create each types, and modify that function when you introduce a new type). It is also often a good idea to prevent objects from being created by arbitrary code. There are several techniques available to achieve such things.

I would have the factory class distinct from the objects it creates/finds/etc. Cars do not manufacture themselves.