Behalten Sie den Überblick über die Makro-Erweiterung

Question

Ich möchte die Makro-Erweiterung überraschen - wie oft das Makro erweitert wurde und was die Args sind, wenn die Expansion stattgefunden hat.

zum Beispiel,

Ich habe ein Makro, könnte so aussehen: generasacodicetagpre.

Und in meinem Code habe ich so etwas wie folgt: generasacodicetagpre.

ist am Ende der Präprozessor-Expansion (oh ja eine Möglichkeit, ein bestimmtes Makro zu machen, um das letzte zu werden, um sich zu erweitern?), ich möchte wissen, wie oft MyMacro verwendet wurde und was die Args bestanden haben.In diesem Fall wäre es zweimal und args wäre a und b.

Ich untersuchte den Boost-Preprocessor Lib.Sie haben Boost_pp_Array, aber ich weiß nicht, wie er es "statisch" machen soll, damit ich es später verwenden kann.

Ich habe etwas in der Boost_pp_Counter gefunden.Es sieht so aus, als ob der Boost_pp_Counter etwas ist, das seinen Zustand in der Präprozessorphrase aufrechterhalten kann.Aber ich bin immer noch unklar, wie ich tun soll, was ich wollte.

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.