#ifndef FACTORY_H
#define FACTORY_H

#include <string>

class CAlgorithmBase;

template<typename TYPE>
class CFactoryBase
{
public:
    virtual TYPE *createInstance() = 0;
    virtual void destroyInstance(void *) = 0;
};

template<typename TYPE, typename BASETYPE>
class CFactoryAlgorithm : public CFactoryBase<BASETYPE>
{
public:
    TYPE *createInstance()
    {
        TYPE *pType = new TYPE();
        return pType;
    }
    void destroyInstance(void *p)
    {
        delete static_cast<TYPE*>(p);
    }
};


template<typename TYPE>
CFactoryBase<CAlgorithmBase>* MakeFactoryAlgorithm()
{
    static CFactoryAlgorithm<TYPE, CAlgorithmBase> fac;
    return &fac;
}

struct sFactoryAssocAlgorithm
{
    std::string szNameAlgorithm;
    CFactoryBase<CAlgorithmBase> *pFactory;
};


#endif // FACTORY_H

#include "factory.h"
#include <iostream>

class CAlgorithmBase
{
protected:
    std::string m_szName;
public:
    CAlgorithmBase(){m_szName = "CAlgorithmBase";}
    void print(){std::cout << "Algorithm: " << m_szName << std::endl;}
};

class CAlgo0 : public CAlgorithmBase
{
public:
    CAlgo0(){m_szName = "CAlgo0";}
};

class CAlgo1 : public CAlgorithmBase
{
public:
    CAlgo1(){m_szName = "CAlgo1";}
};

class CAlgo2 : public CAlgorithmBase
{
public:
    CAlgo2(){m_szName = "CAlgo2";}
};

sFactoryAssocAlgorithm g_algos[]=
{
    {"algo0", MakeFactoryAlgorithm<CAlgo0>()},
    {"algo1", MakeFactoryAlgorithm<CAlgo1>()},
    {"algo2", MakeFactoryAlgorithm<CAlgo2>()}
};

int main(int argc, char *argv[])
{
    int nCount = sizeof(g_algos)/sizeof(*g_algos);
    std::cout << "Algorithm count: " << nCount << std::endl;
    for( int n = 0; n < nCount; n++ )
    {
        CAlgorithmBase *pObj = g_algos[n].pFactory->createInstance();
        pObj->print();
        g_algos[n].pFactory->destroyInstance( pObj );
    }

    return 0;
}

Algorithm count: 3
Algorithm: CAlgo0
Algorithm: CAlgo1
Algorithm: CAlgo2