Ne support du C++ compiler-compteurs de temps?

Eh bien... oui, le modèle de la métaprogrammation manque d'effets secondaires car il est destiné. J'ai été induit en erreur par un bug dans les anciennes versions de GCC et un peu moins clair, le libellé de la Norme de croire que toutes ces fonctionnalités sont possibles.

Cependant, au moins l'espace de noms-la portée de la fonctionnalité peut être réalisé avec peu de modèles à tous. La fonction de recherche peut extraire numérique de l'état de l'ensemble des fonctions déclarées, comme illustré ci-dessous.

Bibliothèque de code:

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 ) > )

Démonstration rapide (voir courir):

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 Mise À Jour

Ici est une version mise à jour à l'aide de C++11 constexpr en place de 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

Les déclarations doivent être mis à l'intérieur d'un espace de noms, et tous les noms utilisés dans les macros à l'exception des counter_crumb doivent être qualifiés. Le counter_crumb modèle est disponible via l'ADL association avec le constant_index type.

La COUNTER_LINK_NAMESPACE macro peut être utilisée pour incrémenter un compteur dans le champ d'application de plusieurs espaces de noms.

Je pensais à résoudre ce problème depuis un certain temps, et ont abouti à un très court de solution propre. Au moins j'ai le mérite upvote pour essayer. :))

Suivants code de la bibliothèque réalise des fonctionnalités au niveau de l'espace de noms. c'est à dire, je réussis à mettre en œuvre counter_read et counter_inc; mais pas le counter_inc_t (qui est incrémenté à l'intérieur de la fonction, car template classes ne sont pas autorisés à l'intérieur de la fonction)

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}; }

Cette technique utilise modèle de méta-programmation et tire profit de l' __LINE__ macro.
Voir le résultat pour le code de votre réponse.

Car le partage est attentionné et j'ai passé quelques heures à bidouiller avec l'exemple de base cette côté offre, je vais les poster ma solution.

La version lié à l'article a deux inconvénients majeurs. Le nombre maximum qu'elle peut compter trop est très faible, en raison de max profondeur de récursion (généralement de l'ordre de 256). Et le temps qu'il faut pour compiler dès qu'un nombre de plus d'une centaine a été atteint est énorme.

Par la mise en œuvre de la recherche binaire pour détecter si un drapeau pour un compteur a déjà été définie ou pas, il est possible d'augmenter massivement le compte maximum (contrôlable par MAX_DEPTH) et également d'améliorer les temps de compilation en même temps. =)

Exemple d'utilisation:

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;
}

Entièrement code de travail avec exemple à la fin: (Sauf pour le bruit. Voir les commentaires.)

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

Malheureusement, le modèle de la métaprogrammation est essentiellement fonctionnelle
de la langue, et en tant que tel manque de variables globales ou modifiables de l'état qui
mettrait en place un tel compteur.

Ou est-il?

C++ permet de compiler des compteurs de temps (c'est à dire sans __COUNTER__, __LINE__ ou d'autres approches proposées ici plus tôt) ainsi que de l'allocation et de la définition interne int ID unique pour chaque modèle. Voir v1 solution pour le compteur mis en œuvre avec le modèle metaprograming en utilisant le chaînage attribué Id et v2 pour le deuxième cas d'utilisation. Ces deux solutions sont des réponses pour "Comment puis-je générer dense unique Id de type au moment de la compilation?". Mais la tâche est une condition essentielle à propos de l'ID de l'allocateur.