Hat schon einmal jemand das Präprozessormakro __COUNTER__ verwendet?

Question

El __COUNTER__ Symbol wird bereitgestellt von VC++ und GCC und ergibt bei jeder Verwendung einen zunehmenden nicht-negativen Integralwert.

Ich bin daran interessiert, zu erfahren, ob jemand es jemals benutzt hat, und ob es etwas ist, das es wert wäre, standardisiert zu werden?

Answer 1

In diesem Blog-Beitrag Sie dient der Simulation der defer Anweisung von golang in C++11.

template <typename F>
struct privDefer {
    F f;
    privDefer(F f) : f(f) {}
    ~privDefer() { f(); }
};

template <typename F>
privDefer<F> defer_func(F f) {
    return privDefer<F>(f);
}

#define DEFER_1(x, y) x##y
#define DEFER_2(x, y) DEFER_1(x, y)
#define DEFER_3(x)    DEFER_2(x, __COUNTER__)
#define defer(code)   auto DEFER_3(_defer_) = defer_func([&](){code;})

Dann können Sie das tun:

int main()
{
    FILE* file = open("file.txt");
    defer(fclose(file));

    // use the file here
    // ....
}

Answer 2

Ich habe es verwendet, um einzigartige Typen in diesem Artikel zu erzeugen: http://www.codeproject.com/Articles/42021/Sealing-Classes-in-C

Answer 3

Es wird im Metriksystem von ClickHouse verwendet.

namespace CurrentMetrics
{
    #define M(NAME) extern const Metric NAME = __COUNTER__;
        APPLY_FOR_METRICS(M)
    #undef M
    constexpr Metric END = __COUNTER__;

    std::atomic<Value> values[END] {};    /// Global variable, initialized by zeros.

    const char * getDescription(Metric event)
    {
        static const char * descriptions[] =
        {
        #define M(NAME) #NAME,
            APPLY_FOR_METRICS(M)
        #undef M
        };

        return descriptions[event];
    }

    Metric end() { return END; }
}

Answer 4

Ich habe es als nützlich für die Anzeige von Schritten in einer Benutzeroberfläche empfunden. Auf diese Weise ist es wirklich einfach, Schritte hinzuzufügen, zu entfernen oder neu anzuordnen, ohne sich Gedanken darüber zu machen, dass die Schritte falsch beschriftet werden.

#include <iostream>

#define STR_IMPL(s)  #s
#define STR(s)  STR_IMPL(s)
#define STEP  STR(__COUNTER__) ": "

int main()
{
    std::cout 
        << STEP "foo\n"
        << STEP "bar\n"
        << STEP "qux\n"
        ;
}

Ausgabe:

0: foo
1: bar
2: qux

Dass er bei 1 statt bei 0 beginnt, bleibt als Übung übrig.

Answer 5

__COUNTER__ ist garantiert einzigartig im Gegensatz zu __LINE__ . Einige Compiler erlauben __LINE__ zurückgesetzt werden. #include-Dateien werden ebenfalls zurückgesetzt __LINE__ .