// Некий интерфейс, реализации которого будем создавать с помощью фабрики
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();
};

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

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

// <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>>

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

bool IsSimple = HeaderFactory::IsSimpleType(48);

>> да, switch'а нет, зато есть std::map, что в плане производительности ещё хуже

struct IHeader
{
    typedef boost::shared_ptr<IHeader> Ptr;
    virtual ~IHeader() = 0 {};
};

struct Header1
{
    Header1(int);
};

struct Header2
{
    Header2(double);
};

struct Header3
{
    Header3(Ptr);
};

А>struct IHeader
А>{
А>    typedef boost::shared_ptr<IHeader> Ptr;
А>    virtual ~IHeader() = 0 {};
А>};

А>struct Header1
А>{
А>    Header1(int);
А>};

А>struct Header2
А>{
А>    Header2(double);
А>};

А>struct Header3
А>{
А>    Header3(Ptr);
А>};
А>

IElementPtr Factory::create(const std::string& ElementName, const std::string& ElementContent);

Element1::Element1(const std::string& ElementContent);

А>Т.е. таки старый добрый switch по индексу Вот и я о том же зачем вообще нужна фабрика?

MySpecificHeader h(i);

class Header1 : public Header<Header1>
{
...
IHeader::Ptr create();
...
};

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

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

R>

namespace HeaderDetails
{

template <typename T>
class HeaderTypeTraits{};

}

template<typename Derived>
struct Header : IHeader
{
private:
    struct Initializer
    {
        Initializer()
        {
            // Саморегистрация
            HeaderFactory::add( HeaderTypeTraits<Derived>::TYPECODE , IHeaderWrapper::Ptr(new HeaderWrapper<Derived>));
        }
    };

    static Initializer initializer;

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

class RealHeader : public ...


namespace HeaderDetails
{

template <>
class HeaderTypeTraits<RealHeader>
{
     static const int TYPECODE = 0;
};

}

class Header1 : public Header<Header1>
{
...
struct Meta
{
static const int TYPE = 1;
};
...
};

class Header1 : public Header<Header1>
{
...
};

templatе<>
struct Traits<Header1>
{
static const int TYPE = 1;
};
...

template<typename T>
struct HeaderTraits
{
 static const int TYPE = T::TYPE;
};

// ...
            // Саморегистрация
            HeaderFactory::add(HeaderTraits<Derived>::TYPE, IHeaderWrapper::Ptr(new HeaderWrapper<Derived>));

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

struct IHeader
{
...
// тут добавил развёрнутый комментарий по поводу назначения/изменения кодов
enum TYPE
{
  TYPE1 = 1,
  TYPE2 = 2,
  TYPE3 = 3
};
...
};

struct Header1 : Header<Header1>
{
    static const int TYPE = IHeader::TYPE1;
};

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

R>>bool IsSimple = HeaderFactory::IsSimpleType(48);
R>>

struct IHeaderWrapper
{
virtual bool IsSimpleType() = 0;
};

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

struct HeaderWrapper : IHeaderWrapper
{
    virtual bool IsSimpleType()
    {
        return HeaderType::IS_SIMPLE;
    }
};


struct Header1 : Header<Header1>
{
    static const bool IS_SIMPLE = true;
};

BF>Правда, ту либу я не считаю написанной "по рекомендациям лучших собаководов"

Factory::create(???);

R>Ну это хотя бы первое упоминание о реальном применении

R>Factory::create(???);
R>

Action * Parser::OnSomeEvent(bool flag)
{
   return m_factory.Create(flag ? ActionA::GetClassID() : ActionB::GetClassID());
}

class Factory
{
public:
   class Registrator
   {
   public:
      int RegisterWithId(int id, ClassDesc desc);
 
      int RegisterWithoutId(ClassDesc desc)
      {
         return RegisterWithId(NewId(), desc)
      }
   //...
   };
...
}

BF>      int RegisterWithoutId(ClassDesc desc)
BF>      {
BF>         return RegisterWithId(NewId(), desc)
BF>      }

BF>>      int RegisterWithoutId(ClassDesc desc)
BF>>      {
BF>>         return RegisterWithId(NewId(), desc)
BF>>      }
R>

int ActionA::m_classId = Factory::Registrator::GetInstance().RegisterWithId(actionA, NormalActionDesc<ActionA>());
//actionA -- из энума известных протоколов. 
int ActionB::m_classId = Factory::Registrator::GetInstance().RegisterWithoutId(NormalActionDesc<ActionB>());

#define MY_ACTION_MOVE    1
#define MY_ACTION_COPY    2
#define MY_ACTION_PASTE   3
...

R>Если на английском, то если кому не лень может запостить... ну с небольшой ссылочкой на автора

create();
create(T1 p1);
create(T1 p1, T2 p2);
...