Следите за расширением макроса

Question

Я хочу отслеживать расширение макроса - сколько раз макрос расширены и какие args, когда произошло расширение.

Например,

У меня есть макрос может выглядеть так:

#define mymacro(x) int x

.

И в моем коде у меня есть что-то подобное:

mymacro(a);
mymacro(b);

.

В конце препроцессора расширения (о да, есть ли способ сделать определенный макрос, чтобы стать последним, чтобы расширить?), Я хотел бы знать, сколько раз использовалось MyMacro и какие ARGS пройденыОтказВ этом случае это было бы 2 раза, а args будет A и B.

Я был расследует Boost-Preprocessor lib.У них Boost_PP_Array, но я не знаю, как сделать это «статическим», чтобы я мог использовать его позже.

Я нашел что-то в Boost_PP_Counter.Похоже, что Boost_PP_Counter - это то, что может сохранить свое состояние в препроцессорной фразе.Но я все еще неясно, как сделать то, что я хотел.

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.