// Некий интерфейс, реализации которого будем создавать с помощью фабрики
struct IHeader
{
    typedef boost::shared_ptr<IHeader> Ptr;
    virtual ~IHeader() = 0 {};
};

// Интерфейс метакласса реализации IHeader
struct IHeaderWrapper
{
    typedef boost::shared_ptr<IHeaderWrapper> Ptr;
    virtual ~IHeaderWrapper() = 0 {};

    virtual IHeader::Ptr create() = 0;
};

// Фабрика реализаций IHeader
class HeaderFactory
{
private:
    typedef std::map<int, IHeaderWrapper::Ptr> map;

    static map& wrappers()
    {
        static map wrappers_instance;
        return wrappers_instance;
    }

public:
    // Метод создания экземпляра
    static IHeader::Ptr create(int type)
    {
        map::iterator iter = wrappers().find(type);
        if (wrappers().end() != iter)
            return iter->second->create();
        else
            throw std::runtime_error("unknown header type");
    }

    // Метод добавления нового типа экземпляра
    static void add(int type, IHeaderWrapper::Ptr wrapper)
    {
        if (!wrappers().insert(std::make_pair(type, wrapper)).second)
            throw std::logic_error("Header type added twice");
    }
};

// Метакласс реализации IHeader
template<typename HeaderType>
struct HeaderWrapper : IHeaderWrapper
{
    virtual IHeader::Ptr create()
    {
        return IHeader::Ptr(new HeaderType);
    }
};

// Базовый класс для реализаций IHeader - обеспечивает саморегистрацию реализаций в фабрике
template<typename Derived>
struct Header : IHeader
{
private:
    struct Initializer
    {
        Initializer()
        {
            // Саморегистрация
            HeaderFactory::add(Derived::TYPE, IHeaderWrapper::Ptr(new HeaderWrapper<Derived>));
        }
    };

    static Initializer initializer;

protected:
    ~Header()
    {
        // Надо обязательно заюзать эту переменную
        (void)initializer;
    }
};

template<typename HeaderType> typename Header<HeaderType>::Initializer Header<HeaderType>::initializer;

// Реализация IHeader
struct Header1 : Header<Header1>
{
    static const int TYPE = 1;
    // Реализация
};

// Реализация IHeader
struct Header2 : Header<Header2>
{
    static const int TYPE = 2;
    // Реализация
};

// Реализация IHeader
struct Header3 : Header<Header3>
{
    static const int TYPE = 3;
    // Реализация
};


int main()
{
    IHeader::Ptr h1 = HeaderFactory::create(1);
    IHeader::Ptr h2 = HeaderFactory::create(2);
    IHeader::Ptr h3 = HeaderFactory::create(3);
    IHeader::Ptr h4 = HeaderFactory::create(4); // Тут будет исключение
}

// Фабрика реализаций IHeader
class HeaderFactory
{
public:
    // Проверка на существование типа
    static bool exists(int type)
    {
        return wrappers().end() != wrappers().find(type)
    }
};

// Реализация IHeader
struct Header1 : Header<Header1>
{
    // Связываем с типом числовое значение
    static const int TYPE = 1;

    // Связываем с типом другой тип. Например, тип диалога, который может отобразить информацию о данной реализации
    typedef Header1Dlg DlgType;

    // Связываем с типом некий флаг
    static const bool IS_SIMPLE = true;

    // Связываем с типом строку, которую мы можем выводить пользователю
    static const char* GetName()
    {
        return "SOME_HEADER";
    }

    // Реализация
};

// Фабрика реализаций IHeader
class HeaderFactory
{
public:
    // Получить список всех метаклассов
    static std::vector<IHeaderWrapper::Ptr> getAllWrappers();
};

// <skip>

R>[ccode]
R>// Реализация IHeader
R>struct Header1 : Header<Header1>
R>{
R>    // Связываем с типом числовое значение
R>    static const int TYPE = 1;

R>    // Связываем с типом другой тип. Например, тип диалога, который может отобразить информацию о данной реализации
R>    typedef Header1Dlg DlgType;

R>    // Связываем с типом некий флаг
R>    static const bool IS_SIMPLE = true;

R>    // Связываем с типом строку, которую мы можем выводить пользователю
R>    static const char* GetName()
R>    {
R>        return "SOME_HEADER";
R>    }

R>    // Реализация
R>};
R>

struct Header1 : Header<Header1,
                        1,
                        Header1Dlg,
                        true,
                        mpl::list<mpl::long_<'SOME'>, mpl::long_<'_HEA'>, mpl::long_<'DER'> > >
{
};

template<typename T>
struct Header
{
 static const ID = increment_meta_function<T>::value;
};

R>... что-то уже до целой статьи дотягивает

R>

static const char * id () { staric const char name[]="name"; return name; }

__>struct Header1 : Header<Header1,
__>                        1,
__>                        Header1Dlg,
__>                        true,
__>                        mpl::list<mpl::long_<'SOME'>, mpl::long_<'_HEA'>, mpl::long_<'DER'> > >
__>{
__>};
__>

    // Связываем с типом числовое значение
    static const int TYPE = 1;

__>template<typename T>
__>struct Header
__>{
__> static const ID = increment_meta_function<T>::value;
__>};
__>

__>Пока не будут применятся в полную метапрограммирование на шаблонах и на макросах не будет полностью расширяемая

R>>... что-то уже до целой статьи дотягивает

__>Приветствуется

R>>

А>>См. Александреску "Современное проектирование...". ИМХО там реализация лучше. А в последних версиях Loki аффтар "творчески переработал" этот кусок.

    IHeader::Ptr h1 = HeaderFactory::create(48);
    h1 ... что дальше? IS_SIMPLE? как?