А вот и вариант с частичной специализацией. Просьба увести детей от мониторов, особо впечатлительным лучше не смотреть

#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 <DWORD n0>
struct CNameIdHolder0
{
    template <DWORD n1>
    struct CNameIdHolder1
    {
        template <DWORD n2>
        struct CNameIdHolder2
        {
            template <DWORD n3>
            struct CNameIdHolder3
            {
                template <DWORD n4>
                struct CNameIdHolder4
                {
                    template <DWORD n5>
                    struct CNameIdHolder5
                    {
                        template <DWORD n6>
                        struct CNameIdHolder6
                        {
                            template <DWORD n7>
                            struct CNameIdHolder7
                            {
                                static LPCTSTR GetStr()
                                {
                                    static const TCHAR szBuffer[] = {
                                                                        FLATTEN_STR(n0),
                                                                        FLATTEN_STR(n1),
                                                                        FLATTEN_STR(n2),
                                                                        FLATTEN_STR(n3),
                                                                        FLATTEN_STR(n4),
                                                                        FLATTEN_STR(n5),
                                                                        FLATTEN_STR(n6),
                                                                        FLATTEN_STR(n7),
                                                                        _T('\0')
                                                                    };
                                    return szBuffer;
                                }
                            };
                            template <>
                            struct CNameIdHolder7<0>
                            {
                                static LPCTSTR GetStr()
                                {
                                    static const TCHAR szBuffer[] = {
                                                                        FLATTEN_STR(n0),
                                                                        FLATTEN_STR(n1),
                                                                        FLATTEN_STR(n2),
                                                                        FLATTEN_STR(n3),
                                                                        FLATTEN_STR(n4),
                                                                        FLATTEN_STR(n5),
                                                                        FLATTEN_STR(n6),
                                                                        _T('\0')
                                                                    };
                                    return szBuffer;
                                }
                            };
                        };
                        template <>
                        struct CNameIdHolder6<0>
                        {
                            template <DWORD n7>
                            struct CNameIdHolder7
                            {
                                static LPCTSTR GetStr()
                                {
                                    static const TCHAR szBuffer[] = {
                                                                        FLATTEN_STR(n0),
                                                                        FLATTEN_STR(n1),
                                                                        FLATTEN_STR(n2),
                                                                        FLATTEN_STR(n3),
                                                                        FLATTEN_STR(n4),
                                                                        FLATTEN_STR(n5),
                                                                        _T('\0')
                                                                    };
                                    return szBuffer;
                                }
                            };
                        };
                    };
                    template <>
                    struct CNameIdHolder5<0>
                    {
                        template <DWORD n6>
                        struct CNameIdHolder6
                        {
                            template <DWORD n7>
                            struct CNameIdHolder7
                            {
                                static LPCTSTR GetStr()
                                {
                                    static const TCHAR szBuffer[] = {
                                                                        FLATTEN_STR(n0),
                                                                        FLATTEN_STR(n1),
                                                                        FLATTEN_STR(n2),
                                                                        FLATTEN_STR(n3),
                                                                        FLATTEN_STR(n4),
                                                                        _T('\0')
                                                                    };
                                    return szBuffer;
                                }
                            };
                        };
                    };
                };
                template <>
                struct CNameIdHolder4<0>
                {
                    template <DWORD n5>
                    struct CNameIdHolder5
                    {
                        template <DWORD n6>
                        struct CNameIdHolder6
                        {
                            template <DWORD n7>
                            struct CNameIdHolder7
                            {
                                static LPCTSTR GetStr()
                                {
                                    static const TCHAR szBuffer[] = {
                                                                        FLATTEN_STR(n0),
                                                                        FLATTEN_STR(n1),
                                                                        FLATTEN_STR(n2),
                                                                        FLATTEN_STR(n3),
                                                                        _T('\0')
                                                                    };
                                    return szBuffer;
                                }
                            };
                        };
                    };
                };
            };
            template <>
            struct CNameIdHolder3<0>
            {
                template <DWORD n4>
                struct CNameIdHolder4
                {
                    template <DWORD n5>
                    struct CNameIdHolder5
                    {
                        template <DWORD n6>
                        struct CNameIdHolder6
                        {
                            template <DWORD n7>
                            struct CNameIdHolder7
                            {
                                static LPCTSTR GetStr()
                                {
                                    static const TCHAR szBuffer[] = {
                                                                        FLATTEN_STR(n0),
                                                                        FLATTEN_STR(n1),
                                                                        FLATTEN_STR(n2),
                                                                        _T('\0')
                                                                    };
                                    return szBuffer;
                                }
                            };
                        };
                    };
                };
            };
        };
        template <>
        struct CNameIdHolder2<0>
        {
            template <DWORD n3>
            struct CNameIdHolder3
            {
                template <DWORD n4>
                struct CNameIdHolder4
                {
                    template <DWORD n5>
                    struct CNameIdHolder5
                    {
                        template <DWORD n6>
                        struct CNameIdHolder6
                        {
                            template <DWORD n7>
                            struct CNameIdHolder7
                            {
                                static LPCTSTR GetStr()
                                {
                                    static const TCHAR szBuffer[] = {
                                                                        FLATTEN_STR(n0),
                                                                        FLATTEN_STR(n1),
                                                                        _T('\0')
                                                                    };
                                    return szBuffer;
                                }
                            };
                        };
                    };
                };
            };
        };
    };
    template <>
    struct CNameIdHolder1<0>
    {
        template <DWORD n2>
        struct CNameIdHolder2
        {
            template <DWORD n3>
            struct CNameIdHolder3
            {
                template <DWORD n4>
                struct CNameIdHolder4
                {
                    template <DWORD n5>
                    struct CNameIdHolder5
                    {
                        template <DWORD n6>
                        struct CNameIdHolder6
                        {
                            template <DWORD n7>
                            struct CNameIdHolder7
                            {
                                static LPCTSTR GetStr()
                                {
                                    static const TCHAR szBuffer[] = {
                                                                        FLATTEN_STR(n0),
                                                                        _T('\0')
                                                                    };
                                    return szBuffer;
                                }
                            };
                        };
                    };
                };
            };
        };
    };
};

struct CNameIdHolder0<0>
{
    template <DWORD n1>
    struct CNameIdHolder1
    {
        template <DWORD n2>
        struct CNameIdHolder2
        {
            template <DWORD n3>
            struct CNameIdHolder3
            {
                template <DWORD n4>
                struct CNameIdHolder4
                {
                    template <DWORD n5>
                    struct CNameIdHolder5
                    {
                        template <DWORD n6>
                        struct CNameIdHolder6
                        {
                            template <DWORD n7>
                            struct CNameIdHolder7
                            {
                                static LPCTSTR GetStr()
                                {
                                    static const TCHAR szBuffer[] = {
                                                                        _T('\0')
                                                                    };
                                    return szBuffer;
                                }
                            };
                        };
                    };
                };
            };
        };
    };
};

template <DWORD n0 = 0, DWORD n1 = 0, DWORD n2 = 0, DWORD n3 = 0, DWORD n4 = 0, DWORD n5 = 0, DWORD n6 = 0, DWORD n7 = 0>
struct CNameId
{
    enum
    {
        m_n0 = n0,
        m_n1 = n1,
        m_n2 = n2,
        m_n3 = n3,
        m_n4 = n4,
        m_n5 = n5,
        m_n6 = n6,
        m_n7 = n7
    };
    static LPCTSTR GetStr()
    {
        return CNameIdHolder0<n0>::CNameIdHolder1<n1>::CNameIdHolder2<n2>::CNameIdHolder3<n3>::CNameIdHolder4<n4>::CNameIdHolder5<n5>::CNameIdHolder6<n6>::CNameIdHolder7<n7>::GetStr();
    }
};

Собственно, теперь максимальные потери — 4 байта. И никакого оверхеда на копирование\преобразование строк