Gardez une trace de la macro expansion

Question

Je veux garder une trace de la macro expansion - combien de fois la macro a été développée et que sont les arguments lorsque l'expansion est arrivée.

Par exemple,

J'ai une macro pourrait ressembler à ceci:

#define mymacro(x) int x

et dans mon code, j'ai quelque chose comme ceci:

mymacro(a);
mymacro(b);

à la fin de l'expansion du préprocesseur (Oh oui, est là un moyen de faire une macro spécifique pour devenir le dernier à se développer?), j'aimerais savoir combien de fois mymacro a été utilisé et que les arguments sont passés.Dans ce cas, ce serait 2 fois et arguments serait A et B.

J'écoutais à Boost-Preprocessor Lib.Ils ont boost_pp_array, mais je ne sais pas comment le faire "statique", afin que je puisse l'utiliser plus tard.

J'ai trouvé quelque chose dans le boost_pp_counter.On dirait que le boost_pp_counter est quelque chose qui peut conserver son état dans la phrase du pré-processeur.Mais je suis toujours pas clair comment faire ce que je voulais.

Answer 1

How about something like this?

#include <iostream>

int m_counter = 0;
const char *m_arguments[32] = { 0 };

#define COUNT_M(a) m_arguments[m_counter++] = #a;
#define M(a) COUNT_M(a) int a

int main()
{
    M(x);
    M(y);

    for (int i = 0; i < m_counter; i++)
    {
        std::cout << "m_arguments[" << i << "] = \"" << m_arguments[i] << "\"\n";
    }
}

Answer 2

I'm not quite sure what your ultimate goal is, but you can track the number of scans(not the number of expansions) using an active argument. An active argument expands each time that it is scanned by the preprocessor. For example,

#define EMPTY()

#define A(n) \
    A_INDIRECT EMPTY()()(BOOST_PP_INC(n)) 

#define A_INDIRECT() A

#define X(arg) arg
#define Y(arg) X(arg)
#define Z(arg) Y(arg)

   A(0)   // A_INDIRECT()(1)
X( A(0) ) // A_INDIRECT()(2)
Y( A(0) ) // A_INDIRECT()(3)
Z( A(0) ) // A_INDIRECT()(4)

Each invocation of A is subjected to a different number of scans, which causes the results to be different each time.

Macros can't effect the global state. The only other way to achieve some sort of state is to use recursion. Remember, macros don't expand recursively, so the preprocessor keeps tracks of this state. Its the only "global" state that can be affected by macros. However, it can be difficult to control. Macros have to be forced to expand at a certain recursion level with a macro for each level, and some form of binary searching is required to read the "state" efficiently.