Поскольку совместная работа ухаживает, и я провел несколько часов, играя с базовым примером , это сторона, я также опубликую свое решение.

Связанная версия в статье есть два основных недостатка. Максимальное количество, которое он может подсчитать, очень низкое, из-за малой глубины рекурсии (обычно около 256). И время, затрачиваемое на компиляцию, как только подсчет более нескольких сотен был достигнут, огромен.

Реализовав двоичный поиск, чтобы определить, установлен ли флаг для счетчика или нет, можно увеличить максимальное количество (контролируемое через MAX_DEPTH), а также улучшить время компиляции одновременно. =)

Пример использования:

static constexpr int a = counter_id();
static constexpr int b = counter_id();
static constexpr int c = counter_id();

#include <iostream>

int main () {
    std::cout << "Value a: " << a << std::endl;
    std::cout << "Value b: " << b << std::endl;
    std::cout << "Value c: " << c << std::endl;
}

Полностью рабочий код с примером в конце: (За исключением clang. См. комментарии.)

// Number of Bits our counter is using. Lower number faster compile time,
// but less distinct values. With 16 we have 2^16 distinct values.
#define MAX_DEPTH 16

// Used for counting.
template<int N>
struct flag {
    friend constexpr int adl_flag(flag<N>);
};

// Used for noting how far down in the binary tree we are.
// depth<0> equales leaf nodes. depth<MAX_DEPTH> equals root node.
template<int N> struct depth {};

// Creating an instance of this struct marks the flag<N> as used.
template<int N>
struct mark {
    friend constexpr int adl_flag (flag<N>) {
        return N;
    }

    static constexpr int value = N;
};

// Heart of the expression. The first two functions are for inner nodes and
// the next two for termination at leaf nodes.

// char[noexcept( adl_flag(flag<N>()) ) ? +1 : -1] is valid if flag<N> exists.
template <int D, int N, class = char[noexcept( adl_flag(flag<N>()) ) ? +1 : -1]>
int constexpr binary_search_flag(int,  depth<D>, flag<N>,
        int next_flag = binary_search_flag(0, depth<D-1>(), flag<N + (1 << (D - 1))>())) {
    return next_flag;
}

template <int D, int N>
int constexpr binary_search_flag(float, depth<D>, flag<N>,
        int next_flag = binary_search_flag(0, depth<D-1>(), flag<N - (1 << (D - 1))>())) {
    return next_flag;
}

template <int N, class = char[noexcept( adl_flag(flag<N>()) ) ? +1 : -1]>
int constexpr binary_search_flag(int,   depth<0>, flag<N>) {
    return N + 1;
}

template <int N>
int constexpr binary_search_flag(float, depth<0>, flag<N>) {
    return N;
}

// The actual expression to call for increasing the count.
template<int next_flag = binary_search_flag(0, depth<MAX_DEPTH-1>(),
        flag<(1 << (MAX_DEPTH-1))>())>
int constexpr counter_id(int value = mark<next_flag>::value) {
    return value;
}

static constexpr int a = counter_id();
static constexpr int b = counter_id();
static constexpr int c = counter_id();

#include <iostream>

int main () {
    std::cout << "Value a: " << a << std::endl;
    std::cout << "Value b: " << b << std::endl;
    std::cout << "Value c: " << c << std::endl;
}

К сожалению, метапрограммирование шаблонов по существу является функциональным языком, и в этом виде отсутствуют глобальные переменные или изменяемое состояние, которое могло бы реализовать такой счетчик.

Или это?

C ++ позволяет скомпилировать счетчики времени (т. е. без __COUNTER__, __LINE__ или других подходов, предложенных здесь ранее), а также для выделения и определения внутреннего уникального идентификатора int для каждого экземпляра шаблона. См. Решение v1 для счетчика, реализованного с метапрограммой шаблона с использованием цепочки выделенных идентификаторов и v2 для второго варианта использования. Оба решения являются ответами на «Как я могу генерировать плотные уникальные идентификаторы типов во время компиляции?» . Но задача имеет важное требование к единственному идентификатору.

Я собирался решить эту проблему довольно давно и придумал очень короткое чистое решение. По крайней мере, я заслужил один взлет, чтобы попробовать это. :))

После кода библиотеки достигается функциональность уровня пространства имен. то есть мне удастся реализовать counter_read и counter_inc; но не counter_inc_t (который добавляется внутри функции, потому что классы template не допускаются внутри функции)

template<unsigned int NUM> struct Counter { enum { value = Counter<NUM-1>::value }; };
template<> struct Counter<0> { enum { value = 0 }; };

#define counter_read Counter<__LINE__>::value
#define counter_inc template<> struct Counter<__LINE__> { enum { value = Counter<__LINE__-1>::value + 1}; }

Этот метод использует метапрограммирование шаблона и использует макрос __LINE__. См. результат для кода из вашего ответа.

Я считаю, что как MSVC, так и GCC поддерживают токен препроцессора __COUNTER__, который на его месте заменяет монотонно увеличивающееся значение.

Вы можете использовать BOOST_PP_COUNTER из Boost.Preprocessor.

Преимущество: он работает даже для макросов

Недостаток: есть только один счетчик вид "для всей программы, но механизм может быть переопределен для выделенных счетчиков