AS>Параметров и так 8, а CNameIdHolder и не должен быть расширяем — расширяем CNameId, именно его и надо менять, если надо более длинное имя. Специализация вполне красивая, хотя и не маленькая (впрочем, можно и без нее, но так экономится размер бинарника), и макрос тут тоже лучше, чем набор отдельных классов — "не плодите сущности без необходимости", их уже и так много

template<
        TCHAR c0=0,
        TCHAR c1=0,
        TCHAR c2=0,
        TCHAR c3=0,
                //...
    >
class CNameIdHolderImpl
{
};

__>Зато в моем варианте не требуется переписывать для каждой специализации код.

TCHAR sz[] = _T("test");

template <LPCTSTR s>
struct C
{
};

С<sz> c;

__>template<
__>        TCHAR c0=0,
__>        TCHAR c1=0,
__>        TCHAR c2=0,
__>        TCHAR c3=0,
__>                //...
    >>
__>class CNameIdHolderImpl
__>{
__>};
__>

__>>Зато в моем варианте не требуется переписывать для каждой специализации код.

AS>Ваш вариант вообще работать не будет, он определяет массив из 8-ми TCHAR Забудьте про эту мысль, она плохая, уверяю вас, вы РОВНЫМ счетом ничего не съэкономите, а наоборот.

AS>TCHAR sz[] = _T("test");

AS>template <LPCTSTR s>
AS>struct C
AS>{
AS>};

AS>С<sz> c;
AS>

template<const TCHAR s>
struct x{};

#define DEF_STR(strname,str) \
 const TCHAR strname##__unique_name[] = str; \
 x<strname##__unique_name> some_type##str_name;

__>>template<
__>>        TCHAR c0=0,
__>>        TCHAR c1=0,
__>>        TCHAR c2=0,
__>>        TCHAR c3=0,
__>>                //...
    >>>
__>>class CNameIdHolderImpl
__>>{
__>>};
__>>

AS>Проблем и так нет, это вы их придумали А запись имени получится в 2.5 раза длиннее и еще непонятнее.

template<typename TTraits>
class x;

struct traits_kernel32_lib
{ static LPCTSTR get_name() { return "kernel32.lib" } };

x<traits_kernel32_lib> lib_kernel;

#define USE_MODULE_BEGIN(nmspace, id, NameId) \
namespace nmspace \
{\
    struct nmspace##_traits##id##__unique_name
    { static LPCTSTR get_name() { return NameId; } };
    typedef CModule< CNameId< nmspace##_traits##id##__unique_name > > module_type;\

typedef CModule<
  CNameId<'k','e','r','n','e','l','3','2','.','d','l','l'>
 >kernel_module_type;

template<TCHAR c0=0,
         TCHAR c1=0,
         TCHAR c2=0,
         TCHAR c3=0,
         //...
        >
struct CNameId
{
  enum
  {
        m_c0 = c0,
        m_c1 = c1,
        m_c2 = c2,
        //...
        count   = (!c0) ? 0: 
                  (!c1) ? 1: 
                  (!c2) ? 2:
                  //...
   };
   static LPCTSTR GetStr()
   {
       static TCHAR strName[] =
       {
         c0,
         c1,
         c2,
         //...
         0
       };
       return strName;  
  }
};

// CAT
#define CAT_(x,y) x##y
#define CAT(x,y) CAT_(x,y)

// REPEAT_N
#define REPEAT_N_0(x) CAT(x,0)
#define REPEAT_N_1(x) REPEAT_N_0(x), CAT(x,1)
#define REPEAT_N_2(x) REPEAT_N_1(x), CAT(x,2)
#define REPEAT_N_3(x) REPEAT_N_2(x), CAT(x,3)
//...
#define REPEAT_N(n,x) CAT(REPEAT_N_,n)(x)

// REPEAT_EX_N
#define REPEAT_EX_N_0(x,y) CAT(CAT(x,0),y)
#define REPEAT_EX_N_1(x,y) REPEAT_EX_N_0(x,y), CAT(CAT(x,1),y)
#define REPEAT_EX_N_2(x,y) REPEAT_EX_N_1(x,y), CAT(CAT(x,2),y)
#define REPEAT_EX_N_3(x,y) REPEAT_EX_N_2(x,y), CAT(CAT(x,3),y)
//...
#define REPEAT_EX_N(n,x,y) CAT(REPEAT_EX_N_,n)(x,y)

// REPEAT_EX2_N
#define REPEAT_EX2_N_0(x,y) CAT(CAT(x,0),CAT(y,0))
#define REPEAT_EX2_N_1(x,y) REPEAT_EX2_N_0(x,y), CAT(CAT(x,1),CAT(y,1))
#define REPEAT_EX2_N_2(x,y) REPEAT_EX2_N_1(x,y), CAT(CAT(x,2),CAT(y,2))
#define REPEAT_EX2_N_3(x,y) REPEAT_EX2_N_2(x,y), CAT(CAT(x,3),CAT(y,3))
//...
#define REPEAT_EX2_N(n,x,y) CAT(REPEAT_EX2_N_,n)(x,y)

// DECLARE_CNAMEID
#define CNAME_ID_(n) \
{ \
    enum \
    { \
        REPEAT_EX2_N(n,m_c,t_c) \
    }; \
    static const TCHAR* GetStr() \
    { \
        static const TCHAR str[]= \
        { \
            REPEAT_N(n,t_c) \
            ,0 \
        }; \
        return str; \
    } \
};

#define SPEC_CNAMEID(n) \
template<REPEAT_N(n,TCHAR t_c)> \
struct CNameID<REPEAT_N(n,t_c)> \
CNAME_ID_(n)

#define DECLARE_CNAMEID(n) \
template<REPEAT_EX_N(n,TCHAR t_c,=0)> \
struct CNameID \
CNAME_ID_(n)

// определяем сам класс
DECLARE_CNAMEID(2)
// специализации
SPEC_CNAMEID(0)
SPEC_CNAMEID(1)

// тестим
void main()
{
 const TCHAR* str = CNameID<'a','b','c'>::GetStr();
}

AS>Мне — почти никак, он на VC6 компилится не будет, как я понял — там у вас частичная специализация?

CModule<'some','tex','t'>

template<TCHAR c0,TCHAR c1, ... >
struct CNameID
{...};

template<typename T,TCHAR str[]>
class str_to_char
{
 typedef T<str[0],str[1],...> type;  // как правильно не знаю :xz: 
};

// CAT
#define CAT_(x,y) x##y
#define CAT(x,y) CAT_(x,y)

// REPEAT_N
#define REPEAT_N_0(x) CAT(x,0)
#define REPEAT_N_1(x) REPEAT_N_0(x), CAT(x,1)
#define REPEAT_N_2(x) REPEAT_N_1(x), CAT(x,2)
#define REPEAT_N_3(x) REPEAT_N_2(x), CAT(x,3)
#define REPEAT_N_4(x) REPEAT_N_3(x), CAT(x,4)
#define REPEAT_N_5(x) REPEAT_N_4(x), CAT(x,5)
#define REPEAT_N_6(x) REPEAT_N_5(x), CAT(x,6)
#define REPEAT_N_7(x) REPEAT_N_6(x), CAT(x,7)
#define REPEAT_N_8(x) REPEAT_N_7(x), CAT(x,8)
//...
#define REPEAT_N(n,x) CAT(REPEAT_N_,n)(x)

// REPEAT2_N
#define REPEAT2_N_0(x,y) CAT(CAT(x,0),y)
#define REPEAT2_N_1(x,y) REPEAT2_N_0(x,y), CAT(CAT(x,1),y)
#define REPEAT2_N_2(x,y) REPEAT2_N_1(x,y), CAT(CAT(x,2),y)
#define REPEAT2_N_3(x,y) REPEAT2_N_2(x,y), CAT(CAT(x,3),y)
#define REPEAT2_N_4(x,y) REPEAT2_N_3(x,y), CAT(CAT(x,4),y)
#define REPEAT2_N_5(x,y) REPEAT2_N_4(x,y), CAT(CAT(x,5),y)
#define REPEAT2_N_6(x,y) REPEAT2_N_5(x,y), CAT(CAT(x,6),y)
#define REPEAT2_N_7(x,y) REPEAT2_N_6(x,y), CAT(CAT(x,7),y)
#define REPEAT2_N_8(x,y) REPEAT2_N_7(x,y), CAT(CAT(x,8),y)
//...
#define REPEAT2_N(n,x,y) CAT(REPEAT2_N_,n)(x,y)

// REPEAT2_EX_N
#define REPEAT2_EX_N_0(x,y) CAT(CAT(x,0),CAT(y,0))
#define REPEAT2_EX_N_1(x,y) REPEAT2_EX_N_0(x,y), CAT(CAT(x,1),CAT(y,1))
#define REPEAT2_EX_N_2(x,y) REPEAT2_EX_N_1(x,y), CAT(CAT(x,2),CAT(y,2))
#define REPEAT2_EX_N_3(x,y) REPEAT2_EX_N_2(x,y), CAT(CAT(x,3),CAT(y,3))
#define REPEAT2_EX_N_4(x,y) REPEAT2_EX_N_3(x,y), CAT(CAT(x,4),CAT(y,4))
#define REPEAT2_EX_N_5(x,y) REPEAT2_EX_N_4(x,y), CAT(CAT(x,5),CAT(y,5))
#define REPEAT2_EX_N_6(x,y) REPEAT2_EX_N_5(x,y), CAT(CAT(x,6),CAT(y,6))
#define REPEAT2_EX_N_7(x,y) REPEAT2_EX_N_6(x,y), CAT(CAT(x,7),CAT(y,7))
#define REPEAT2_EX_N_8(x,y) REPEAT2_EX_N_7(x,y), CAT(CAT(x,8),CAT(y,8))
//...
#define REPEAT2_EX_N(n,x,y) CAT(REPEAT2_EX_N_,n)(x,y)

// REPEAT3_NC_N
#define REPEAT3_NC_N_0(x,y,z) CAT(CAT(CAT(x,0),CAT(y,0)),z)
#define REPEAT3_NC_N_1(x,y,z) REPEAT3_NC_N_0(x,y,z) CAT(CAT(CAT(x,1),CAT(y,1)),z)
#define REPEAT3_NC_N_2(x,y,z) REPEAT3_NC_N_1(x,y,z) CAT(CAT(CAT(x,2),CAT(y,2)),z)
#define REPEAT3_NC_N_3(x,y,z) REPEAT3_NC_N_2(x,y,z) CAT(CAT(CAT(x,3),CAT(y,3)),z)
#define REPEAT3_NC_N_4(x,y,z) REPEAT3_NC_N_3(x,y,z) CAT(CAT(CAT(x,4),CAT(y,4)),z)
#define REPEAT3_NC_N_5(x,y,z) REPEAT3_NC_N_4(x,y,z) CAT(CAT(CAT(x,5),CAT(y,5)),z)
#define REPEAT3_NC_N_6(x,y,z) REPEAT3_NC_N_5(x,y,z) CAT(CAT(CAT(x,6),CAT(y,6)),z)
#define REPEAT3_NC_N_7(x,y,z) REPEAT3_NC_N_6(x,y,z) CAT(CAT(CAT(x,7),CAT(y,7)),z)
#define REPEAT3_NC_N_8(x,y,z) REPEAT3_NC_N_7(x,y,z) CAT(CAT(CAT(x,8),CAT(y,8)),z)
//...
#define REPEAT3_NC_N(n,x,y,z) CAT(REPEAT3_NC_N_,n)(x,y,z)

// CNameID
#define DECLARE_CNAMEID_IMPL(n) \
    template<unsigned N> \
    struct CNameIDImpl \
    CNAMEID_IMPL_(n,n)

#define SPEC_CNAMEID_IMPL(N,n) \
    template<> \
    struct CNameIDImpl<n> \
    CNAMEID_IMPL_(N,n)

#define CNAMEID_IMPL_(N,n) \
    { \
        template<REPEAT2_EX_N(N,TCHAR t_c,=0)> \
        struct Impl \
        { \
            static const TCHAR* GetStr() \
            { \
                static const TCHAR str[]= \
                { \
                    REPEAT_N(n,t_c), \
                    0 \
                }; \
                return str; \
            } \
        }; \
    };

#define DECLARE_CNAMEID(n) \
    template<REPEAT2_N(n,TCHAR t_c,=0)> \
    struct CNameID \
    { \
        enum \
        { \
            REPEAT2_EX_N(n,m_c,t_c), \
            count = REPEAT3_NC_N(n,!t_c,?,:) n+1 \
        }; \
        static const TCHAR* GetStr() \
        { return CNameIDImpl<count>::Impl<REPEAT_N(n,t_c)>::GetStr(); } \
    };

DECLARE_CNAMEID_IMPL(7)
SPEC_CNAMEID_IMPL(7,0)
SPEC_CNAMEID_IMPL(7,1)
SPEC_CNAMEID_IMPL(7,2)
SPEC_CNAMEID_IMPL(7,3)
SPEC_CNAMEID_IMPL(7,4)
SPEC_CNAMEID_IMPL(7,5)
SPEC_CNAMEID_IMPL(7,6)

DECLARE_CNAMEID(7)

void main()
{
    int n0 = CNameID<>::count;
    const TCHAR* s0 = CNameID<>::GetStr();
    int n1 = CNameID<'a'>::count;
    const TCHAR* s1 = CNameID<'a'>::GetStr();
    int n2 = CNameID<'a','b'>::count;
    const TCHAR* s2 = CNameID<'a','b'>::GetStr();
    int n3 = CNameID<'a','b','c'>::count;
    const TCHAR* s3 = CNameID<'a','b','c'>::GetStr();
    int n4 = CNameID<'a','b','c','d'>::count;
    const TCHAR* s4 = CNameID<'a','b','c','d'>::GetStr();
    int n5 = CNameID<'a','b','c','d','e'>::count;
    const TCHAR* s5 = CNameID<'a','b','c','d','e'>::GetStr();
}

//    delayimphlp.h: Delay import helper
//    Developer:    Andrew Solodovnikov
//    E-mail:        none
//    Date:        03.08.2004

#ifndef    __DELAYIMPHLP_H__
#define __DELAYIMPHLP_H__

#define DL_CAT_(x,y) x##y
#define DL_CAT(x,y) DL_CAT_(x,y)

#define MAX_DL_REPEAT 16

#define DL_REPEAT_EMPTY_PARAM()

// DL_REPEAT_N
#define DL_REPEAT_N_0(x) 
#define DL_REPEAT_N_1(x) DL_CAT(x,1)
#define DL_REPEAT_N_2(x) DL_REPEAT_N_1(x), DL_CAT(x,2)
#define DL_REPEAT_N_3(x) DL_REPEAT_N_2(x), DL_CAT(x,3)
#define DL_REPEAT_N_4(x) DL_REPEAT_N_3(x), DL_CAT(x,4)
#define DL_REPEAT_N_5(x) DL_REPEAT_N_4(x), DL_CAT(x,5)
#define DL_REPEAT_N_6(x) DL_REPEAT_N_5(x), DL_CAT(x,6)
#define DL_REPEAT_N_7(x) DL_REPEAT_N_6(x), DL_CAT(x,7)
#define DL_REPEAT_N_8(x) DL_REPEAT_N_7(x), DL_CAT(x,8)
#define DL_REPEAT_N_9(x) DL_REPEAT_N_8(x), DL_CAT(x,9)
#define DL_REPEAT_N_10(x) DL_REPEAT_N_9(x), DL_CAT(x,10)
#define DL_REPEAT_N_11(x) DL_REPEAT_N_10(x), DL_CAT(x,11)
#define DL_REPEAT_N_12(x) DL_REPEAT_N_11(x), DL_CAT(x,12)
#define DL_REPEAT_N_13(x) DL_REPEAT_N_12(x), DL_CAT(x,13)
#define DL_REPEAT_N_14(x) DL_REPEAT_N_13(x), DL_CAT(x,14)
#define DL_REPEAT_N_15(x) DL_REPEAT_N_14(x), DL_CAT(x,15)
#define DL_REPEAT_N_16(x) DL_REPEAT_N_15(x), DL_CAT(x,16)

#define DL_REPEAT_N(n, x) DL_CAT(DL_REPEAT_N_,n)(x)



// DL_REPEAT_PARAM_N
#define DL_REPEAT_PARAM_N0(n, m)
#define DL_REPEAT_PARAM_N1(n, m) DL_CAT(n,1) DL_CAT(m,1)
#define DL_REPEAT_PARAM_N2(n, m) DL_REPEAT_PARAM_N1(n, m), DL_CAT(n,2) DL_CAT(m,2)
#define DL_REPEAT_PARAM_N3(n, m) DL_REPEAT_PARAM_N2(n, m), DL_CAT(n,3) DL_CAT(m,3)
#define DL_REPEAT_PARAM_N4(n, m) DL_REPEAT_PARAM_N3(n, m), DL_CAT(n,4) DL_CAT(m,4)
#define DL_REPEAT_PARAM_N5(n, m) DL_REPEAT_PARAM_N4(n, m), DL_CAT(n,5) DL_CAT(m,5)
#define DL_REPEAT_PARAM_N6(n, m) DL_REPEAT_PARAM_N5(n, m), DL_CAT(n,6) DL_CAT(m,6)
#define DL_REPEAT_PARAM_N7(n, m) DL_REPEAT_PARAM_N6(n, m), DL_CAT(n,7) DL_CAT(m,7)
#define DL_REPEAT_PARAM_N8(n, m) DL_REPEAT_PARAM_N7(n, m), DL_CAT(n,8) DL_CAT(m,8)
#define DL_REPEAT_PARAM_N9(n, m) DL_REPEAT_PARAM_N8(n, m), DL_CAT(n,9) DL_CAT(m,9)
#define DL_REPEAT_PARAM_N10(n, m) DL_REPEAT_PARAM_N9(n, m), DL_CAT(n,10) DL_CAT(m,10)
#define DL_REPEAT_PARAM_N11(n, m) DL_REPEAT_PARAM_N10(n, m), DL_CAT(n,11) DL_CAT(m,11)
#define DL_REPEAT_PARAM_N12(n, m) DL_REPEAT_PARAM_N11(n, m), DL_CAT(n,12) DL_CAT(m,12)
#define DL_REPEAT_PARAM_N13(n, m) DL_REPEAT_PARAM_N12(n, m), DL_CAT(n,13) DL_CAT(m,13)
#define DL_REPEAT_PARAM_N14(n, m) DL_REPEAT_PARAM_N13(n, m), DL_CAT(n,14) DL_CAT(m,14)
#define DL_REPEAT_PARAM_N15(n, m) DL_REPEAT_PARAM_N14(n, m), DL_CAT(n,15) DL_CAT(m,15)
#define DL_REPEAT_PARAM_N16(n,m) DL_REPEAT_PARAM_N15(n, m), DL_CAT(n,16) DL_CAT(m,16)

#define DL_REPEAT_PARAM_N(c, n, m) DL_CAT(DL_REPEAT_PARAM_N,c)(n, m)

// DL_REPEAT_DEF_N
#define DL_REPEAT_DEF_N0(n, d)
#define DL_REPEAT_DEF_N1(n, d) DL_CAT(DL_CAT(n,1), d)
#define DL_REPEAT_DEF_N2(n, d) DL_REPEAT_DEF_N1(n, d), DL_CAT(DL_CAT(n,2), d)
#define DL_REPEAT_DEF_N3(n, d) DL_REPEAT_DEF_N2(n, d), DL_CAT(DL_CAT(n,3), d)
#define DL_REPEAT_DEF_N4(n, d) DL_REPEAT_DEF_N3(n, d), DL_CAT(DL_CAT(n,4), d)
#define DL_REPEAT_DEF_N5(n, d) DL_REPEAT_DEF_N4(n, d), DL_CAT(DL_CAT(n,5), d)
#define DL_REPEAT_DEF_N6(n, d) DL_REPEAT_DEF_N5(n, d), DL_CAT(DL_CAT(n,6), d)
#define DL_REPEAT_DEF_N7(n, d) DL_REPEAT_DEF_N6(n, d), DL_CAT(DL_CAT(n,7), d)
#define DL_REPEAT_DEF_N8(n, d) DL_REPEAT_DEF_N7(n, d), DL_CAT(DL_CAT(n,8), d)
#define DL_REPEAT_DEF_N9(n, d) DL_REPEAT_DEF_N8(n, d), DL_CAT(DL_CAT(n,9), d)
#define DL_REPEAT_DEF_N10(n, d) DL_REPEAT_DEF_N9(n, d), DL_CAT(DL_CAT(n,10), d)
#define DL_REPEAT_DEF_N11(n, d) DL_REPEAT_DEF_N10(n, d), DL_CAT(DL_CAT(n,11), d)
#define DL_REPEAT_DEF_N12(n, d) DL_REPEAT_DEF_N11(n, d), DL_CAT(DL_CAT(n,12), d)
#define DL_REPEAT_DEF_N13(n, d) DL_REPEAT_DEF_N12(n, d), DL_CAT(DL_CAT(n,13), d)
#define DL_REPEAT_DEF_N14(n, d) DL_REPEAT_DEF_N13(n, d), DL_CAT(DL_CAT(n,14), d)
#define DL_REPEAT_DEF_N15(n, d) DL_REPEAT_DEF_N14(n, d), DL_CAT(DL_CAT(n,15), d)
#define DL_REPEAT_DEF_N16(n,d) DL_REPEAT_DEF_N15(n, d), DL_CAT(DL_CAT(n,16), d)

#define DL_REPEAT_DEF_N(c, n, d) DL_CAT(DL_REPEAT_DEF_N,c)(n, d)


// DL_REPEAT_MACRO_N

#define DL_REPEAT_MACRO_N0(m, p)
#define DL_REPEAT_MACRO_N1(m, p) m(DL_CAT(p,1))
#define DL_REPEAT_MACRO_N2(m, p) DL_REPEAT_MACRO_N1(m, p), m(DL_CAT(p,2))
#define DL_REPEAT_MACRO_N3(m, p) DL_REPEAT_MACRO_N2(m, p), m(DL_CAT(p,3))
#define DL_REPEAT_MACRO_N4(m, p) DL_REPEAT_MACRO_N3(m, p), m(DL_CAT(p,4))
#define DL_REPEAT_MACRO_N5(m, p) DL_REPEAT_MACRO_N4(m, p), m(DL_CAT(p,5))
#define DL_REPEAT_MACRO_N6(m, p) DL_REPEAT_MACRO_N5(m, p), m(DL_CAT(p,6))
#define DL_REPEAT_MACRO_N7(m, p) DL_REPEAT_MACRO_N6(m, p), m(DL_CAT(p,7))
#define DL_REPEAT_MACRO_N8(m, p) DL_REPEAT_MACRO_N7(m, p), m(DL_CAT(p,8))
#define DL_REPEAT_MACRO_N9(m, p) DL_REPEAT_MACRO_N8(m, p), m(DL_CAT(p,9))
#define DL_REPEAT_MACRO_N10(m, p) DL_REPEAT_MACRO_N9(m, p), m(DL_CAT(p,10))
#define DL_REPEAT_MACRO_N11(m, p) DL_REPEAT_MACRO_N10(m, p), m(DL_CAT(p,11))
#define DL_REPEAT_MACRO_N12(m, p) DL_REPEAT_MACRO_N11(m, p), m(DL_CAT(p,12))
#define DL_REPEAT_MACRO_N13(m, p) DL_REPEAT_MACRO_N12(m, p), m(DL_CAT(p,13))
#define DL_REPEAT_MACRO_N14(m, p) DL_REPEAT_MACRO_N13(m, p), m(DL_CAT(p,14))
#define DL_REPEAT_MACRO_N15(m, p) DL_REPEAT_MACRO_N14(m, p), m(DL_CAT(p,15))
#define DL_REPEAT_MACRO_N16(m, p) DL_REPEAT_MACRO_N15(m, p), m(DL_CAT(p,16))

#define DL_REPEAT_MACRO_N(c, m, p) DL_CAT(DL_REPEAT_MACRO_N,c)(m,p)

#define FLATTEN_STR(val) \
        (TCHAR)HIBYTE(HIWORD(val)), (TCHAR)LOBYTE(HIWORD(val)), (TCHAR)HIBYTE(LOWORD(val)), (TCHAR)LOBYTE(LOWORD(val))


#define    DECLARE_STR_DWORD(Name, Idx) \
static const TCHAR Name[] = {FLATTEN_STR(Idx##0), FLATTEN_STR(Idx##1), FLATTEN_STR(Idx##2), FLATTEN_STR(Idx##3), FLATTEN_STR(Idx##4), FLATTEN_STR(Idx##5), FLATTEN_STR(Idx##6), FLATTEN_STR(Idx##7)};


template <int count>
struct CNameIdHolder
{
    template <DL_REPEAT_N(MAX_DL_REPEAT, DWORD n)>
    struct CNameIdHolderImpl
    {
        static LPCTSTR GetStr()
        {
            static const TCHAR szBuffer[] = {
                                                DL_REPEAT_MACRO_N(MAX_DL_REPEAT, FLATTEN_STR, n),
                                                _T('\0')
                                            };
            return szBuffer;
        }
    };
};

#define NAME_ID_HOLDER_SPEC(num)\
template <>\
struct CNameIdHolder<num>\
{\
    template <DL_REPEAT_N(MAX_DL_REPEAT, DWORD n)>\
    struct CNameIdHolderImpl\
    {\
        static LPCTSTR GetStr()\
        {\
            static const TCHAR szBuffer[] = {\
                                                DL_REPEAT_MACRO_N(num, FLATTEN_STR, n),\
                                                _T('\0')\
                                            };\
            return szBuffer;\
        }\
    };\
};

NAME_ID_HOLDER_SPEC(15)
NAME_ID_HOLDER_SPEC(14)
NAME_ID_HOLDER_SPEC(13)
NAME_ID_HOLDER_SPEC(12)
NAME_ID_HOLDER_SPEC(11)
NAME_ID_HOLDER_SPEC(10)
NAME_ID_HOLDER_SPEC(9)
NAME_ID_HOLDER_SPEC(8)
NAME_ID_HOLDER_SPEC(7)
NAME_ID_HOLDER_SPEC(6)
NAME_ID_HOLDER_SPEC(5)
NAME_ID_HOLDER_SPEC(4)
NAME_ID_HOLDER_SPEC(3)
NAME_ID_HOLDER_SPEC(2)
NAME_ID_HOLDER_SPEC(1)

template <>
struct CNameIdHolder<0>
{
    template <DL_REPEAT_N(MAX_DL_REPEAT, DWORD n)>
    struct CNameIdHolderImpl
    {
        static LPCTSTR GetStr()
        {
            return NULL;
        }
    };
};


template <DL_REPEAT_DEF_N(MAX_DL_REPEAT, DWORD n, = 0)>
struct CNameId
{
    enum
    {
        DL_REPEAT_PARAM_N(MAX_DL_REPEAT, m_n, =n),
        count   = (!n1) ? 0: (!n2) ? 1: (!n3) ?2: (!n4) ? 3: (!n5) ? 4: (!n6) ? 5: (!n7) ? 6: (!n8) ? 7: 
                  (!n9) ? 8: (!n10) ? 9: (!n11) ?10: (!n12) ? 11: (!n13) ? 12: (!n14) ? 13: (!n15) ? 14: (!n16) ? 15: 16
    };
    static LPCTSTR GetStr()
    {
        return CNameIdHolder<count>::CNameIdHolderImpl<DL_REPEAT_N(MAX_DL_REPEAT, n)>::GetStr();
    }
};

template <class Name>
class CModule
{
public:
    HMODULE m_hModule;
    typedef CModule<Name> type;
    typedef Name          name_type;
    static type &GetModule()
    {
        static type Module;
        return Module;
    }
    ~CModule()
    {
        if (m_hModule)
            FreeLibrary(m_hModule);
    }
private:
    CModule()
    {
        m_hModule = LoadLibrary(name_type::GetStr());
    }
};


template <class Module, class Name, class Proxy>
class CDynFunction
{
public:
    typedef CDynFunction<Module, Name, Proxy> type;
    typedef Proxy                              proxy_type;
    typedef Module                              module_type;
    typedef Name                              name_type;
    
    static proxy_type::fun_type &GetProxy()
    {
        static proxy_type::fun_type proxy = proxy_type::Proxy<type>::ProxyFun;
        return proxy;
    }
    static BOOL InitFunction()
    {
        HMODULE hModule = Module::GetModule().m_hModule;
        if (hModule)
        {
            FARPROC pFunction = GetProcAddress(hModule, name_type::GetStr());
            if (pFunction)
            {
                GetProxy() = (proxy_type::fun_type)pFunction;
                return TRUE;
            }
        }
        return FALSE;
    }
};

template<class R, R value = R()>
struct FunProxyValuePolicy
{
    template <class DynFunction> 
    struct Dummy
    {
        static DynFunction::proxy_type::ret_type MakeReturn()
        {
            return value;
        }
    };
};

struct CDynFunException
{
    CDynFunException();
    CDynFunException(LPCTSTR sMessage):m_sMessage(sMessage)
    {
    }
    CDynFunException(const CDynFunException &other):m_sMessage(other.m_sMessage)
    {
    }
    CDynFunException &operator = (const CDynFunException &other)
    {
        m_sMessage = other.m_sMessage;
        return *this;
    }
    CString m_sMessage;
};

template<class E = CDynFunException>
struct FunProxyThrowPolicy
{
    template <class DynFunction> 
    struct Dummy
    {
        static DynFunction::proxy_type::ret_type MakeReturn()
        {
            CString sMessage;
            sMessage.Format(_T("Can'n load procedure <%s>: %d"), DynFunction::name_type::GetStr(), GetLastError());
            throw E(sMessage);
            return 0;
        }
    };
};



#define FUN_PROXY(n) DL_CAT(FunProxy,n)

#define DECLARE_FUN_PROXY(param_count) \
template <typename R, DL_REPEAT_N(param_count, typename P), class Policy = FunProxyValuePolicy<R> > struct FUN_PROXY(param_count)\
{\
    typedef R (WINAPI *fun_type)(DL_REPEAT_N(param_count, P));\
    typedef R ret_type;\
    template <class DynFunction> struct Proxy\
    {\
        static R WINAPI ProxyFun(DL_REPEAT_PARAM_N(param_count, P, v))\
        {\
            if (DynFunction::InitFunction())\
                return DynFunction::GetProxy()(DL_REPEAT_N(param_count, v));\
            return Policy::Dummy<DynFunction>::MakeReturn();\
        }\
    };\
};


DECLARE_FUN_PROXY(1)
DECLARE_FUN_PROXY(2)
DECLARE_FUN_PROXY(3)
DECLARE_FUN_PROXY(4)
DECLARE_FUN_PROXY(5)
DECLARE_FUN_PROXY(6)
DECLARE_FUN_PROXY(7)
DECLARE_FUN_PROXY(8)
DECLARE_FUN_PROXY(9)
DECLARE_FUN_PROXY(10)
DECLARE_FUN_PROXY(11)
DECLARE_FUN_PROXY(12)
DECLARE_FUN_PROXY(13)
DECLARE_FUN_PROXY(14)
DECLARE_FUN_PROXY(15)
DECLARE_FUN_PROXY(16)

// usefull macro's

#define USE_MODULE_BEGIN(nmspace, NameId) \
namespace nmspace \
{\
    typedef CModule< CNameId< /NameId/ > > module_type;

#define USE_MODULE_END \
};



#define DECLARE_FUN_P1(Name, NameId, R, P1) \
static R (WINAPI *&Name)(P1) = CDynFunction<module_type, CNameId< /NameId/ >, FUN_PROXY(1)<R, P1> >::GetProxy();


#define DECLARE_FUN_P1_ERR(Name, NameId, R, P1, E)\
static R (WINAPI *&Name)(P1) = CDynFunction<module_type, CNameId< /NameId/ >, FUN_PROXY(1)<R, P1, FunProxyValuePolicy<R, E> > >::GetProxy();
 
#define DECLARE_FUN_P1_THROW(Name, NameId, R, P1)\
static R (WINAPI *&Name)(P1) = CDynFunction<module_type, CNameId< /NameId/ >, FUN_PROXY(1)<R, P1, FunProxyThrowPolicy<> > >::GetProxy();

#endif

#define CAT_0(x) CAT(x,0)
//...
#define CAT_n(x) CAT(x,n)

#define REPEAT_N(nfrom,nto,x) CAT(CAT_,nfrom)(x) /* как-нибудь перебор */ CAT(CAT_(nto))(x)

struct CDynFunException
{
    CDynFunException() : m_sMessage(0) {}
    CDynFunException(LPCTSTR sMessage) : m_sMessage(0)
    { SetMessage(sMessage); }
    CDynFunException(const CDynFunException &other) : m_sMessage(0)
    { SetMessage(other.sMessage); }
    CDynFunException &operator = (const CDynFunException &other)
    {
        SetMessage(other.sMessage);
        return *this;
    }
    ~CDynFunExecption()
    { delete[] m_sMessage; }

    const TCHAR* GetMessage() { return m_sMessage; }
private:
    void SetMessage(LPCTSTR sMessage)
    {
       delete[] m_sMessage;
       m_sMessage = new TCHAR[lstrlen(other.m_sMessage)+1];
       lstrcpy(m_sMessage,other.m_sMessage);
    }
    TCHAR* m_sMessage;
};