#define TOUCH_CTC(name) \
   template <> struct name<__LINE__> : name<__LINE__ - 1> \
   { \
      static constexpr int value = name<__LINE__ - 1>::value; \
   };

J>#define TOUCH_CTC(name) \
J>   template <> struct name<__LINE__> : name<__LINE__ - 1> \
J>   { \
J>      static constexpr int value = name<__LINE__ - 1>::value; \
J>   };
J>

#define TOUCH_CTC(name) \
   template <> struct name<__LINE__> : name<__LINE__ - 1> { };

template<int I> struct int_ { static constexpr int value = I; };
using int_0 = int_<0>;
using int_1 = int_<1>;

template<int I> struct point : int_0 {};
#define TAG_IT() template<> struct point<__COUNTER__> : int_1 {};

template<int L, int N> struct sumpoints;
template<int L, int H, int N> using splitsum = int_< sumpoints<L,H>::value + sumpoints<L+H,N-H>::value >;

template<int L> struct sumpoints<L, 0> : int_0 {};
template<int L> struct sumpoints<L, 1> : point<L> {};
template<int L, int N> struct sumpoints : splitsum<L, N/2, N> {};
    // лучше разбивать не пополам, а по старшему биту, - это даст меньше сочетаний <L,N> при массовом использовании
    // и, соответственно, меньше воплощений шаблона
    // но я сходу не вспомнил формулу для его нахождения

#define GET_IT() (sumpoints<0, __COUNTER__>::value)

constexpr int x = GET_IT();  // __COUNTER__ = 1, x = 0
constexpr int y = GET_IT();  // __COUNTER__ = 2, y = 0
TAG_IT();                    // __COUNTER__ = 3
TAG_IT();                    // __COUNTER__ = 4
TAG_IT();                    // __COUNTER__ = 5
constexpr int z = GET_IT();  // __COUNTER__ = 6, z = 3

constexpr int pivot(unsigned N) {
  int r = N & (N-1); // обнуление младшего бита
  return r ? r : N/2;
}

0,7 =  0,3             + 3,4
       0,1 + 1,2         3,2       + 5,2
             1,1 + 2,1   3,1 + 4,1   5,1 + 6,1

0,11 = 0,5                   + 5,6
       0,2       + 2,3         5,3             + 8,3
       0,1 + 1,1   2,1 + 3,2   5,1 + 6,2         8,1 + 9,2
       ===   ===   ===   ###         6,1 + 7,1         9,1 + 10,1
                                     ===

0,12 = 0,6                   + 6,6
       0,3 + 3,3               6,3             + 9,3
       ###   3,1 + 4,2         6,1 + 7,2         9,1 + 10,2
             ===   4,1 + 5,1   ===   7,1 + 8,1   ===   10,1 + 11,1
                   ===   ===         ===   ===         ====

0,7 =  0,4                   + 4,3
       0,2       + 2,2         4,2       + 6,1
       0,1 + 1,1   2,1 + 3,1   4,1 + 5,1

0,11 = 0,8                   + 8,3
       0,4 + 4,4               8,2       + 10,1
       ###   4,2 + 6,2         8,1 + 9,1
             ###   6,1 + 7,1
                   ===

0,12 = 0,8 + 8,4
       ###   8,2 + 10,2
             ###   10,1 + 11,1
                   ====

0,7 =  0,6                               + 6,1
       0,4                   + 4,2
       0,2       + 2,2         4,1 + 5,1
       0,1 + 1,1   2,1 + 3,1

0,11 = 0,10                              + 10,1
       0,8                   + 8,2
       0,4 + 4,4               8,1 + 9,1
       ###   4,2 + 6,2
             ###   6,1 + 7,1
                   ===

0,12 = 0,10 + 10,2
       ####   10,1 + 11,1
              ====

• Не используются никакие константы препроцессора (__LINE__, __COUNTER__ и пр);
  
• Не используется специализации шаблона основного класса счетчика, что допускает его применение не только в пространстве имен, но и в теле классов (до C++17 спещиализация вложенных классов должна была выполняться только в обрамляющем пространстве имен);
  
• Возможность одновременного использования множества независимых счетчиков;
  
• Огранченность областью видимости. Счетчики из вложенных областей видимости не конфликтуют с одноименными счетчиками из охватывающих областей видимости;
  
• Автоматический инкремент при каждом обращении к счетчику.

• Ограничение максимального значения счетчика, довольно низкое. Над этим заморачиваться не нужно, решение уже найдено;
  
• ГЛАВНАЯ ПРОБЛЕМА: привести счетчик в соответствие требованиям стандарта! Сейчас эта реализация работает только на msvc. Как я ни бился, мне так и не удалось заставить это заработать под gcc. Причина ясна — дружественная функция не появляется в окружающем пространстве имен.

constexpr size_t CTC_MAX = 498;

template <size_t i>
struct Index : Index<i - 1> { static constexpr size_t value = i; };
template <> struct Index<0> { static constexpr size_t value = 0; };

Index<0> generate(...);

#define CREATE_CTC(name) \
   template <typename T = decltype(generate(Index<CTC_MAX>()))> \
   struct name : T \
   { \
      friend Index<T::value + 1> generate(T); \
   };

#define GET_CTC(name) name<>::value

CREATE_CTC(ctc1)

enum class Foo
{
   zero = GET_CTC(ctc1),
   one = GET_CTC(ctc1),
   two = GET_CTC(ctc1),
   three = GET_CTC(ctc1),
   four = GET_CTC(ctc1),
   five = GET_CTC(ctc1),
};

template <size_t> struct MemeberTraits;

CREATE_CTC<MemberCounter>

template <>
struct MemeberTraits<GET_CTC<MemberCounter>> // MemeberTraits<0>
{
  //...
};
template <>
struct MemeberTraits<GET_CTC<MemberCounter>> // MemeberTraits<1>
{
  //...
};
template <>
struct MemeberTraits<GET_CTC<MemberCounter>> // MemeberTraits<2>
{
  //...
};