Click here to Skip to main content
15,501,342 members
Articles / General Programming
Posted 10 Apr 2012

Tagged as


87 bookmarked

Factory Pattern in C++

Rate me:
Please Sign up or sign in to vote.
4.88/5 (61 votes)
15 Sep 2012CPOL2 min read
Using the Factory pattern in C++ to expose only an object's abstract type--hiding the implementation class detail.


Up until now, I never really used the Factory pattern that often in C++. Recently, I found a use for it in a project I was working on and since I found it useful for my purposes, I thought I might share a tutorial on how the Factory pattern can be used in C++.

Disclaimer: Now I’m not entirely sure how closely my model fits the typical Factory pattern but as far as I understand the Factory pattern, it is pretty close if not exact.


Basically a Factory consists of an interface class which is common to all of the implementation classes that the factory will create. Then you have the factory class which is usually a singleton class that spawns instances of these implementation classes.

Abstract Interface Class

So let us create a quick interface class to start with. In this example, I used IAnimal

class IAnimal
    virtual int GetNumberOfLegs() const = 0;
    virtual void Speak() = 0;
    virtual void Free() = 0;

Now for simplicity’s sake, I used a typedef to define a type for the function that is used by the implementation classes to create instances of IAnimal. This typedef is also used in declaring the map that maps the animal name to the function that creates that particular type of animal. You can use whatever calling convention you like, but for this example, I chose __stdcall.

typedef IAnimal* (__stdcall *CreateAnimalFn)(void); 

Specific Implementation Class(es) 

Now come the implementation classes. These are the classes that implement the IAnimal interface. Here’re a few examples:

// IAnimal implementations
class Cat : public IAnimal
    int GetNumberOfLegs() const { return 4; }
    void Speak() { cout << "Meow" << endl; }
    void Free() { delete this; }

    static IAnimal * __stdcall Create() { return new Cat(); }

class Dog : public IAnimal
    int GetNumberOfLegs() const { return 4; }
    void Speak() { cout << "Woof" << endl; }
    void Free() { delete this; }

    static IAnimal * __stdcall Create() { return new Dog(); }

class Spider : public IAnimal // Yeah it isn’t really an animal…
    int GetNumberOfLegs() const { return 8; }
    void Speak() { cout << endl; }
    void Free() { delete this; }

    static IAnimal * __stdcall Create() { return new Spider(); }

class Horse : public IAnimal
    int GetNumberOfLegs() const { return 4; }
    void Speak() { cout << "A horse is a horse, of course, of course." << endl; }
    void Free() { delete this; }

    static IAnimal * __stdcall Create() { return new Horse(); }

Factory Class Declaration 

Now comes the Factory class. This is a singleton pattern implementation--meaning only one instance of the factory can ever be instantiated, no more, no less.

// Factory for creating instances of IAnimal
class AnimalFactory
    AnimalFactory(const AnimalFactory &) { }
    AnimalFactory &operator=(const AnimalFactory &) { return *this; }

    typedef map FactoryMap;
    FactoryMap m_FactoryMap;
    ~AnimalFactory() { m_FactoryMap.clear(); }

    static AnimalFactory *Get()
        static AnimalFactory instance;
        return &instance;

    void Register(const string &animalName, CreateAnimalFn pfnCreate);
    IAnimal *CreateAnimal(const string &animalName);

Factory Class Implementation

Now we need to work out a few definitions of the AnimalFactory class. Specifically the constructor, the Register, and the CreateAnimal functions.


The constructor is where you might consider registering your Factory functions. Though this doesn’t have to be done here, I’ve done it here for the purposes of this example. You could for instance register your Factory types with the Factory class from somewhere else in the code.

/* Animal factory constructor.
Register the types of animals here.
    Register("Horse", &Horse::Create);
    Register("Cat", &Cat::Create);
    Register("Dog", &Dog::Create);
    Register("Spider", &Spider::Create);

Type Registration

Now let us implement the Register function. This function is pretty straightforward since I used a std::map to hold the mapping between my string (the animal type) and the create function.

void AnimalFactory::Register(const string &animalName, CreateAnimalFn pfnCreate)
    m_FactoryMap[animalName] = pfnCreate;

Type Creation

And last but not least, the CreateAnimal function. This function accepts a string parameter which corresponds to the string registered in the AnimalFactory constructor. When this function receives “Horse” for example, it will return an instance of the Horse class, which implements the IAnimal interface.

IAnimal *AnimalFactory::CreateAnimal(const string &animalName)
    FactoryMap::iterator it = m_FactoryMap.find(animalName);
    if( it != m_FactoryMap.end() )
    return it->second();
    return NULL;

Example Usage Program

int main( int argc, char **argv )
    IAnimal *pAnimal = NULL;
    string animalName;

    while( pAnimal == NULL )
        cout << "Type the name of an animal or ‘q’ to quit: ";
        cin >> animalName;

        if( animalName == "q" )

        IAnimal *pAnimal = AnimalFactory::Get()->CreateAnimal(animalName);
        if( pAnimal )
            cout << "Your animal has " << pAnimal->GetNumberOfLegs() << " legs." << endl;
            cout << "Your animal says: ";
            cout << "That animal doesn’t exist in the farm! Choose another!" << endl;
        if( pAnimal )
        pAnimal = NULL;
    return 0;
This article was originally posted at


This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Written By
Software Developer
United States United States
I'm an interactive software and web developer by day and a video game developer by night. I hold an Associate's degree in Computer Information Systems, a Bachelor's degree in Game and Simulation Programming, and have been writing various types of software since 1999.

The programming languages in which I am experienced include C, C++, C#, PHP, and JavaScript--just to name a few. I have experience in creating mobile, embedded, desktop, command-line/console, web, and video game applications for consumer, business, and government/defense purposes.

Comments and Discussions

GeneralMy vote of 5 Pin
kanalbrummer12-Aug-21 7:20
Memberkanalbrummer12-Aug-21 7:20 
QuestionThank you! Pin
therealorry7-Jan-21 14:55
Membertherealorry7-Jan-21 14:55 
AnswerClass Factory Using a Template Class and Nonstatic Generator Pin
Dr. Versaeg26-Aug-20 6:52
MemberDr. Versaeg26-Aug-20 6:52 
QuestionCreateAnimal isn't static Pin
Member 774162320-May-19 4:33
MemberMember 774162320-May-19 4:33 
QuestionReturns only one instance for any animals Pin
jeyasekhar14-Jul-18 7:55
Memberjeyasekhar14-Jul-18 7:55 
AnswerRe: Returns only one instance for any animals Pin
nasev6-Apr-21 13:22
Membernasev6-Apr-21 13:22 
GeneralMy vote of 3 Pin
Member 131704153-May-17 14:36
MemberMember 131704153-May-17 14:36 
QuestionHow to add common code to specific implementations Pin
Member 85340353-Oct-16 7:32
MemberMember 85340353-Oct-16 7:32 
QuestionI voted 5 Stars! Pin
bholman16-Sep-16 5:16
Memberbholman16-Sep-16 5:16 
Escellent example and explanation. It had been many years since I wrote anything in C++ using the Factory pattern, so I was searching for a refresher. This was perfect!

Bill Holman
Software Engineer
Video Gaming Technologies
Bill Holman
Sr. Systems Programmer

Questionnumbered, counted and parametric instances... Pin
LastBlow128-Jul-16 23:05
MemberLastBlow128-Jul-16 23:05 
GeneralMy vote of 5 Pin
Member 43208442-Jan-16 23:56
MemberMember 43208442-Jan-16 23:56 
Questionvery good demo. Pin
haidong83910-Dec-14 11:42
Memberhaidong83910-Dec-14 11:42 
QuestionConfiguration File Pin
RBaryolo18-Sep-14 8:48
MemberRBaryolo18-Sep-14 8:48 
GeneralMy vote of 4 Pin
jessierzlz14-Apr-13 15:57
Memberjessierzlz14-Apr-13 15:57 
GeneralMy vote of 5 Pin
iRaffnix20-Feb-13 21:29
MemberiRaffnix20-Feb-13 21:29 
GeneralMy vote of 5 Pin
sourabhmehta3-Feb-13 19:34
Membersourabhmehta3-Feb-13 19:34 
GeneralMy vote of 5 Pin
Anand Todkar17-Sep-12 4:46
MemberAnand Todkar17-Sep-12 4:46 
SuggestionThe kind of your factory pattern Pin
pasztorpisti16-Sep-12 8:49
Memberpasztorpisti16-Sep-12 8:49 
SuggestionWhy the factory pattern is particularly useful in C++ Pin
Espen Harlinn16-Sep-12 2:22
professionalEspen Harlinn16-Sep-12 2:22 
QuestionBad code design. Pin
Shurwint15-Sep-12 5:21
MemberShurwint15-Sep-12 5:21 
AnswerRe: Bad code design. Pin
Steve Giancarlo15-Sep-12 7:50
MemberSteve Giancarlo15-Sep-12 7:50 
AnswerRe: Bad code design. Pin
Cale Dunlap15-Sep-12 8:59
MemberCale Dunlap15-Sep-12 8:59 
SuggestionRe: Bad code design. Pin
pasztorpisti16-Sep-12 3:33
Memberpasztorpisti16-Sep-12 3:33 
GeneralRe: Bad code design. Pin
Cale Dunlap16-Sep-12 6:05
MemberCale Dunlap16-Sep-12 6:05 
GeneralRe: Bad code design. Pin
pasztorpisti16-Sep-12 7:30
Memberpasztorpisti16-Sep-12 7:30 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.