Tieni traccia della macro espansione

Question

Voglio tenere traccia della macro espansione - quante volte la macro è stata espansa e quali sono gli argidi quando è successo l'espansione.

Ad esempio,

Ho una macro potrebbe sembrare così:

#define mymacro(x) int x

.

E nel mio codice ho qualcosa del genere:

mymacro(a);
mymacro(b);

.

Alla fine dell'espansione del preprocessore (oh sì, c'è un modo per fare una macro specifica per diventare l'ultimo ad espandersi?), Mi piacerebbe sapere quante volte è stato utilizzato Mymacro e quali sono passati le ARG.In questo caso, sarebbe 2 volte, e ARGS sarebbe A e B.

Stavo indagando su Boost-Preprocessor Lib.Hanno boost_pp_array, ma non so come renderlo "statico", in modo che io possa usarlo in un secondo momento.

Ho trovato qualcosa nel boost_pp_counter.Sembra che il boost_pp_counter sia qualcosa che può mantenere il suo stato nella frase preprocessore.Ma non sono ancora chiaro come fare ciò che volevo.

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.