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

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

следующий код библиотеки обеспечивает функциональность уровня пространства имен. т. е. мне удалось реализовать 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__ макрос. Смотрите результат код из вашего ответа.

вы могли бы использовать BOOST_PP_COUNTER от наддува.Препроцессор.

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

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

вот еще одна альтернативная реализация. https://stackoverflow.com/a/6174263/1190123 вероятно, лучше, но даже после ручной работы через пару приращений на бумаге я все еще не совсем понимаю математику/фильтрацию.

это использует рекурсию функции constexpr для подсчета количества объявленных не-шаблонов Highest функции. __COUNTER__ используется в качестве механизма генерации для предотвращения новых объявлений Highest делать самостоятельно рекурсия.

это только компилируется на clang для меня (3.3). Я не уверен, что это соответствует, но я надеюсь. G++ 4.8 выходит из строя из-за какой-то нереализованной функции (согласно ошибке). Компилятор Intel 13 также терпит неудачу из-за ошибки constexpr.

256 уровень счетчика

максимальный отсчет в счетчик 250 (CounterLimit). CounterLimit может быть увеличен до 256, если вы не реализуете материал LCount под.

реализация

#include <iostream>
#include <type_traits>

constexpr unsigned int CounterLimit = 250;

template <unsigned int ValueArg> struct TemplateInt { constexpr static unsigned int Value = ValueArg; };

template <unsigned int GetID, typename, typename TagID>
constexpr unsigned int Highest(TagID, TemplateInt<0>)
{
    return 0;
}

template <unsigned int GetID, typename, typename TagID, unsigned int Index>
constexpr unsigned int Highest(TagID, TemplateInt<Index>)
{
    return Highest<GetID, void>(TagID(), TemplateInt<Index - 1>());
}

#define GetCount(...) \
Highest<__COUNTER__, void>(__VA_ARGS__(), TemplateInt<CounterLimit>())

#define IncrementCount(TagID) \
template <unsigned int GetID, typename = typename std::enable_if<(GetID > __COUNTER__ + 1)>::type> \
constexpr unsigned int Highest( \
    TagID, \
    TemplateInt<GetCount(TagID) + 1> Value) \
{ \
      return decltype(Value)::Value; \
}

тестирование

struct Counter1 {};
struct Counter2 {};
constexpr unsigned int Read0 = GetCount(Counter1);
constexpr unsigned int Read1 = GetCount(Counter1);
IncrementCount(Counter1);
constexpr unsigned int Read2 = GetCount(Counter1);
IncrementCount(Counter1);
constexpr unsigned int Read3 = GetCount(Counter1);
IncrementCount(Counter1);
constexpr unsigned int Read4 = GetCount(Counter1);
IncrementCount(Counter1);
IncrementCount(Counter2);
constexpr unsigned int Read5 = GetCount(Counter1);
constexpr unsigned int Read6 = GetCount(Counter2);

int main(int, char**)
{
    std::cout << "Ending state 0: " << Highest<__COUNTER__, void>(Counter1(), TemplateInt<0>()) << std::endl;
    std::cout << "Ending state 1: " << Highest<__COUNTER__, void>(Counter1(), TemplateInt<1>()) << std::endl;
    std::cout << "Ending state 2: " << Highest<__COUNTER__, void>(Counter1(), TemplateInt<2>()) << std::endl;
    std::cout << "Ending state 3: " << Highest<__COUNTER__, void>(Counter1(), TemplateInt<3>()) << std::endl;
    std::cout << "Ending state 4: " << Highest<__COUNTER__, void>(Counter1(), TemplateInt<4>()) << std::endl;
    std::cout << "Ending state 5: " << Highest<__COUNTER__, void>(Counter1(), TemplateInt<5>()) << std::endl;
    std::cout << Read0 << std::endl;
    std::cout << Read1 << std::endl;
    std::cout << Read2 << std::endl;
    std::cout << Read3 << std::endl;
    std::cout << Read4 << std::endl;
    std::cout << Read5 << std::endl;
    std::cout << Read6 << std::endl;

    return 0;
}

выход

Ending state 0: 0
Ending state 1: 1
Ending state 2: 2
Ending state 3: 3
Ending state 4: 4
Ending state 5: 4
0
0
1
2
3
4
1

250 * 250 уровень счетчика

если вы хотите более высокие значения, чем 256, я думаю, что вы можете объединить счетчики. Я сделал 250 * 250 (хотя я действительно не проверял подсчет после 2). CounterLimit должен быть снижен примерно до 250 для ограничений рекурсии времени компиляции компилятора. Просто чтобы отметить, это заняло значительно больше времени для компиляции мне.

реализация

template <typename, unsigned int> struct ExtraCounter { };

template <unsigned int GetID, typename, typename TagID>
constexpr unsigned int LHighest(TagID)
{
    return Highest<GetID, void>(ExtraCounter<TagID, CounterLimit>(), TemplateInt<CounterLimit>()) * CounterLimit +
        Highest<GetID, void>(
            ExtraCounter<TagID, Highest<GetID, void>(ExtraCounter<TagID , CounterLimit>(), TemplateInt<CounterLimit>())>(),
            TemplateInt<CounterLimit>());
}
#define GetLCount(TagID) \
LHighest<__COUNTER__, void>(TagID())

#define LIncrementTag_(TagID) \
typename std::conditional< \
    GetCount(ExtraCounter<TagID, GetCount(ExtraCounter<TagID, CounterLimit>)>) == CounterLimit - 1, \
    ExtraCounter<TagID, CounterLimit>, \
    ExtraCounter<TagID, GetCount(ExtraCounter<TagID, CounterLimit>)>>::type
#define IncrementLCount(TagID) \
template <unsigned int GetID, typename = typename std::enable_if<(GetID > __COUNTER__ + 7)>::type> \
constexpr unsigned int Highest( \
    LIncrementTag_(TagID), \
    TemplateInt<GetCount(LIncrementTag_(TagID)) + 1> Value) \
{ \
      return decltype(Value)::Value; \
}

тестирование

struct Counter3 {};
constexpr unsigned int Read7 = GetLCount(Counter3);
IncrementLCount(Counter3);
constexpr unsigned int Read8 = GetLCount(Counter3);

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

версия, связанная с этой статьей, имеет два основных недостатка. Максимальное число, которое он может посчитать, тоже очень низкое, из-за максимальной глубины рекурсии (обычно что-то около 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;
}

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

// 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 для второго варианта использования. Оба решения являются ответами для " как я могу генерировать плотные уникальные идентификаторы типов во время компиляции?". Но задача имеет важное требование о единственном распределителе идентификаторов.