web-dev-qa-db-ja.com

C ++はコンパイル時カウンターをサポートしていますか？

イントロスペクションの目的で、シリアル番号をタイプなどに自動的に割り当てたい場合があります。

残念ながら、テンプレートメタプログラミングは本質的に関数型言語であり、そのため、そのようなカウンタを実装するグローバル変数または変更可能な状態がありません。

またはそれは？

リクエストによるコード例：

#include <iostream>

int const a = counter_read;
counter_inc;
counter_inc;
counter_inc;
counter_inc;
counter_inc;

int const b = counter_read;

int main() {
    std::cout << a << ' ' << b << '\n'; // print "0 5"

    counter_inc_t();
    counter_inc_t();
    counter_inc_t();

    std::cout << counter_read << '\n'; // print "8"

    struct {
        counter_inc_t d1;
        char x[ counter_read ];
        counter_inc_t d2;
        char y[ counter_read ];
    } ls;

    std::cout << sizeof ls.x << ' ' << sizeof ls.y << '\n'; // print "9 10"
}
c++templatesmetaprogrammingstate
58
Potatoswatter

ええ、はい、テンプレートメタプログラミングには意図したとおりの副作用がありません。古いバージョンのGCCのバグと、これらの機能がすべて可能であると信じるStandardの文言が少し不明瞭でした。

ただし、テンプレートをほとんど使用しなくても、少なくとも名前空間スコープ機能を実現できます。以下に示すように、関数ルックアップは宣言された関数のセットから数値状態を抽出できます。

ライブラリコード：

template< size_t n > // This type returns a number through function lookup.
struct cn // The function returns cn<n>.
    { char data[ n + 1 ]; }; // The caller uses (sizeof fn() - 1).

template< typename id, size_t n, size_t acc >
cn< acc > seen( id, cn< n >, cn< acc > ); // Default fallback case.

/* Evaluate the counter by finding the last defined overload.
   Each function, when defined, alters the lookup sequence for lower-order
   functions. */
#define counter_read( id ) \
( sizeof seen( id(), cn< 1 >(), cn< \
( sizeof seen( id(), cn< 2 >(), cn< \
( sizeof seen( id(), cn< 4 >(), cn< \
( sizeof seen( id(), cn< 8 >(), cn< \
( sizeof seen( id(), cn< 16 >(), cn< \
( sizeof seen( id(), cn< 32 >(), cn< 0 \
/* Add more as desired; trimmed for Stack Overflow code block. */ \
                      >() ).data - 1 ) \
                      >() ).data - 1 ) \
                      >() ).data - 1 ) \
                      >() ).data - 1 ) \
                      >() ).data - 1 ) \
                      >() ).data - 1 )

/* Define a single new function with place-value equal to the bit flipped to 1
   by the increment operation.
   This is the lowest-magnitude function yet undefined in the current context
   of defined higher-magnitude functions. */
#define counter_inc( id ) \
cn< counter_read( id ) + 1 > \
seen( id, cn< ( counter_read( id ) + 1 ) & ~ counter_read( id ) >, \
          cn< ( counter_read( id ) + 1 ) & counter_read( id ) > )

クイックデモ（ 実行を参照 ）：

struct my_cnt {};

int const a = counter_read( my_cnt );
counter_inc( my_cnt );
counter_inc( my_cnt );
counter_inc( my_cnt );
counter_inc( my_cnt );
counter_inc( my_cnt );

int const b = counter_read( my_cnt );

counter_inc( my_cnt );

#include <iostream>

int main() {
    std::cout << a << ' ' << b << '\n';

    std::cout << counter_read( my_cnt ) << '\n';
}

C++ 11アップデート

以下は、constexprの代わりにC++ 11 sizeofを使用した更新バージョンです。

#define COUNTER_READ_CRUMB( TAG, RANK, ACC ) counter_crumb( TAG(), constant_index< RANK >(), constant_index< ACC >() )
#define COUNTER_READ( TAG ) COUNTER_READ_CRUMB( TAG, 1, COUNTER_READ_CRUMB( TAG, 2, COUNTER_READ_CRUMB( TAG, 4, COUNTER_READ_CRUMB( TAG, 8, \
    COUNTER_READ_CRUMB( TAG, 16, COUNTER_READ_CRUMB( TAG, 32, COUNTER_READ_CRUMB( TAG, 64, COUNTER_READ_CRUMB( TAG, 128, 0 ) ) ) ) ) ) ) )

#define COUNTER_INC( TAG ) \
constexpr \
constant_index< COUNTER_READ( TAG ) + 1 > \
counter_crumb( TAG, constant_index< ( COUNTER_READ( TAG ) + 1 ) & ~ COUNTER_READ( TAG ) >, \
                                                constant_index< ( COUNTER_READ( TAG ) + 1 ) & COUNTER_READ( TAG ) > ) { return {}; }

#define COUNTER_LINK_NAMESPACE( NS ) using NS::counter_crumb;

template< std::size_t n >
struct constant_index : std::integral_constant< std::size_t, n > {};

template< typename id, std::size_t rank, std::size_t acc >
constexpr constant_index< acc > counter_crumb( id, constant_index< rank >, constant_index< acc > ) { return {}; } // found by ADL via constant_index

http://ideone.com/yp19oo

宣言はネームスペース内に配置する必要があり、counter_crumbを除くマクロで使用されるすべての名前は完全に修飾する必要があります。 counter_crumbテンプレートは、constant_indexタイプとのADL関連付けを介して検出されます。

COUNTER_LINK_NAMESPACEマクロを使用して、複数の名前空間のスコープ内の1つのカウンターをインクリメントできます。

45
Potatoswatter

MSVCとGCCは両方とも__COUNTER__代わりに単調に増加する値が代入されるプリプロセッサトークン。

21
Josh Matthews

私はこの問題をかなり長い間解決しようと考えていましたが、非常に簡潔な解決策を思いつきました。少なくとも、これを試してみる価値があります。 :)）

次のライブラリコードは、名前空間レベルの機能を実現します。つまり、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}; }

この手法では、template meta-programmingを使用し、__LINE__ 大きい。回答のコードについては、 結果 をご覧ください。

18
iammilind

共有は思いやりがあり、基本の例をいじるのに数時間費やしたので、 this sideは私もソリューションを投稿するつもりです。

この記事でリンクされているバージョンには、2つの大きな欠点があります。カウントできる最大数は、最大再帰深度（通常は約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;
}
6
Chartas

BOOST_PP_COUNTER Boost.Preprocessorから。

利点：マクロでも機能します

短所：プログラム全体に「カウンターの種類」は1つしかありませんが、メカニズムは専用カウンター用に再実装される場合があります

6
Matthieu M.

別の代替実装を次に示します。 https://stackoverflow.com/a/6174263/119012 はおそらく優れていますが、紙の上でいくつかの増分を手動で処理した後でも、数学/フィルタリングがまだよくわかりません。

これはconstexpr関数の再帰を使用して、非テンプレート宣言Highest関数の数をカウントします。 __COUNTER__は、Highestの新しい宣言が自己再帰を行わないようにする世代別メカニズムとして使用されます。

これはclangでのみコンパイルされます（3.3）。準拠しているかどうかはわかりませんが、期待しています。 g ++ 4.8は、実装されていない機能が原因で失敗します（エラーによる）。 constexprのバグが原因で、Intelコンパイラ13も失敗します。

256レベルカウンター

カウンターごとの最大カウントは250（CounterLimit）です。以下のLCountを実装しない限り、CounterLimitは256に増やすことができます。

実装

#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);
4
rendaw

残念ながら、テンプレートメタプログラミングは本質的に関数型言語であり、そのため、そのようなカウンタを実装するグローバル変数または変更可能な状態がありません。

またはそれは？

C++では、コンパイル時カウンターを使用できます（つまり、__COUNTER__、__LINE__またはここで先に提案した他のアプローチ）、および各テンプレートインスタンスの内部int固有IDの割り当てと定義。 v1 割り当てられたIDの連鎖を使用したテンプレートメタプログラミングで実装されたカウンターのソリューションと、2番目のユースケースの v2 を参照してください。両方のソリューションが 「コンパイル時に高密度の一意のタイプIDを生成するにはどうすればよいですか？」 に対する答えです。ただし、タスクには、唯一のIDアロケーターに関する重要な要件があります。

1
Aleksey F.