template <int ORIGIN = 0, int INCREMENT = 1>
struct CTCOrigin : std::integral_constant<int, ORIGIN>
{
   static constexpr int increment = INCREMENT;
};

#define CREATE_CTC(name, ...) \
   template <size_t N> struct name : name<N - 1> { }; \
   template <> struct name<__LINE__> : CTCOrigin<__VA_ARGS__> { };

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

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

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

#include <iostream>
using namespace std;
#define DEF_BASE(name)       namespace { constexpr int name##localbase = __COUNTER__; }
#define GET_BASE(name)       (name##localbase)
#define GET_OFFSET(name)     GET_OFFSET_C(name,__COUNTER__)
#define GET_OFFSET_C(name,C) ((C)-GET_BASE(name))


#define BODY(V) { static constexpr int value = (V); }

#define START(name) \
  DEF_BASE(name) \
  template<int offset> struct name                      BODY(name<offset-1>::value); \
  template<>           struct name<0>                   BODY(0);

#define GET(name) (name<GET_OFFSET(name)>::value)

#define NEXT(name) NEXT_C(name, __COUNTER__)  // нам понадобится одно значение дважды, поэтому опосредуем
#define NEXT_C(name, C) \
  template<>           struct name<GET_OFFSET_C(name,C)>  BODY(name<GET_OFFSET_C(name,C)-1>::value + 1);

const int c0 = (__COUNTER__, __COUNTER__);
START(foo)
const int x = GET(foo);
const int c1 = (__COUNTER__, __COUNTER__);
const int y = GET(foo);
const int c2 = (__COUNTER__, __COUNTER__);
NEXT(foo)
const int z = GET(foo);
const int c3 = (__COUNTER__, __COUNTER__);
const int t = GET(foo);

int main() {
    cout << c0 << endl;
    cout << x << endl;
    cout << c1 << endl;
    cout << y << endl;
    cout << c2 << endl;
    cout << z << endl;
    cout << c3 << endl;
    cout << t << endl;
}

#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 ORIGIN = 0, int INCREMENT = 1>
struct $CTCOrigin : std::integral_constant<int, ORIGIN>
{
   static constexpr int increment = INCREMENT;
};
 
template <typename Tag, size_t LINE>
struct $CTC : $CTC<Tag, LINE - 1> { };
 
template <typename Tag>
struct $CTC<Tag, 0> : $CTCOrigin<0, 1> { };
 
#define RESET_CTC(Tag, ...) \
   template <> struct $CTC<class Tag, __LINE__> : $CTCOrigin<__VA_ARGS__> { };
 
#define UPDATE_CTC(Tag) \
   template <> struct $CTC<class Tag, __LINE__> : $CTC<class Tag, __LINE__ - 1> \
   { \
      static constexpr int value = $CTC<class Tag, __LINE__ - 1>::value + increment; \
   };
 
#define GET_CTC(Tag) \
   $CTC<class Tag, __LINE__ - 1>::value

R>Возможно, ты имеешь в виду использование одних и тех же счетчиков в разных заголовочных файлах? Да, с этим, конечно же проблема. Нот э таргет сценарио, как говорится

// setup.h
CREATE_CTC(foo, 1000)

// some.h
const int x = GET_CTC(foo); // __LINE__ = 2 --> 1000
UPDATE_CTC(foo)             // __LINE__ = 3 --> 1001
const int y = GET_CTC(foo); // __LINE__ = 4 --> 1001

// some.cc - хороший
#include "setup.h"
#include "some.h"
.....
UPDATE_CTC(foo)             // __LINE__ = 101 --> 1002
const int z = GET_CTC(foo); // __LINE__ = 102 --> 1002
const int t = GET_CTC(foo); // __LINE__ = 103 --> 1002


// some.cc - плохой
#include "setup.h"
.....
UPDATE_CTC(foo)             // __LINE__ = 100 --> 1001
const int z = GET_CTC(foo); // __LINE__ = 101 --> 1001
#include "some.h"           // ошибка компиляции - специализация после использования
const int t = GET_CTC(foo); // __LINE__ = 103

#define BATCH_UPDATE(x,y) \
  const int x = GET_CTC(foo) /* foo<L> */ \
  UPDATE_CTC(foo) /* foo<L> : foo<L> + 1 */ \
  const int y = GET_CTC(foo) /* foo<L> */ \
  //endmacro

BATCH_UPDATE(xxx, yyy)  // ошибка компиляции - специализация после использования

template <int ORIGIN = 0, int INCREMENT = 1>
struct $CTCOrigin : std::integral_constant<int, ORIGIN>
{
   static constexpr int increment = INCREMENT;
};

#define CREATE_CTC(name, ...) \
   template <size_t N> struct name : name<N - 1> { }; \
   template <> struct name<0> : $CTCOrigin<__VA_ARGS__> \
   { \
      static constexpr int counter_base = __COUNTER__; \
   };

#define UPDATE_CTC_(name, counter) \
   template <> struct name<counter - name<0>::counter_base> \
   : name<counter - name<0>::counter_base - 1> \
   { \
      using base = name<counter - name<0>::counter_base - 1>; \
      static constexpr int value = base::value + increment; \
   };
#define UPDATE_CTC(name) UPDATE_CTC_(name, __COUNTER__)

#define GET_CTC(name) \
   name<__COUNTER__ - name<0>::counter_base>::value

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>
{
  //...
};