Variadic UNUSED-Funktion/Makro

Eine bekannte und portable Möglichkeit, C-Compiler-Warnungen über nicht verwendete Variablen zu unterdrücken, ist (siehe Warnungen zu nicht verwendeten Parametern in C-Code):

#define UNUSED(x) (void)(x)

Ich suche nach einer Möglichkeit, dies zu verallgemeinern, um mehrere Eingaben (unterschiedlicher Art) zu verwenden:

void foo(int a, long b, void* c){

   /* Want this: */
   ALL_UNUSED(a, b, c);

   /* instead of: */
   UNUSED(a);
   UNUSED(b);
   UNUSED(c);
}

Eine Möglichkeit, die den Trick zu machen scheint, ist die Verwendung einer variadischen Funktion

static inline void ALL_UNUSED(int dummy, ...) {}

Ich vermute jedoch, dass diese Lösung in Fachkreisen zu beanstanden ist.

Gibt es eine standardkonforme und portable (also nicht zu verwendende __attribute__((unused))) Möglichkeit, eine variadische UNUSED()-Funktion/Makro zu erstellen? Danke vielmals!

BEARBEITEN

Es scheint keinen sauberen Weg zu geben, das zu tun, worum ich im Zusammenhang mit C99 oder dem C-Präprozessor gebeten habe. So ist das Leben.

In seiner Antwort unten zeigt @Dabo eine ziemlich interessante Möglichkeit, das zu tun, worum ich gebeten habe, indem ich eine Reihe von Makros verwende. Das ist ordentlich und informativ (zumindest für mich), also akzeptiere ich diese Antwort. Das heißt, ich würde es nicht in einem großen Projekt einsetzen, weil es Tränen genug ist, um den Nutzen zu überwiegen, den es (in meinen Augen) bringt. Aber die Leute werden hier zu anderen Schlüssen kommen.

Wie unten angemerkt, ist der Ansatz, eine leere variadische Funktion zu verwenden, ebenfalls nicht perfekt. Obwohl es ein ziemlich eleganter Einzeiler ist, wird es Warnungen über unititialisierte Variablen provozieren (falls dies der Fall ist). Außerdem müssen Sie Ihrem Compiler vertrauen, dass er ihn vollständig wegoptimiert, was ich grundsätzlich ablehne, aber dass alle Compiler, mit denen ich es versucht habe, dies tatsächlich tun.

Ein relevanter Fall ist das Stubben von Funktionen nach einer frühen High-Level-Schnittstellendesignphase. Dann sind Ihre nicht verwendeten Variablen alle Funktionsargumente und per Definition initialisiert, und der folgende Ansatz funktioniert gut

static inline void UNUSED(int dummy, ...) {}

void foo(int a, long b, void* c){
    UNUSED(a, b, b); /* No warnings */
}

Basierend auf diesen beiden Beiträgen Variadic-Makro zum Zählen der Anzahl der Argumenteund Überladen von Makros ich habe folgendes gemacht

#define UNUSED1(x) (void)(x)
#define UNUSED2(x,y) (void)(x),(void)(y)
#define UNUSED3(x,y,z) (void)(x),(void)(y),(void)(z)
#define UNUSED4(a,x,y,z) (void)(a),(void)(x),(void)(y),(void)(z)
#define UNUSED5(a,b,x,y,z) (void)(a),(void)(b),(void)(x),(void)(y),(void)(z)

#define VA_NUM_ARGS_IMPL(_1,_2,_3,_4,_5, N,...) N
#define VA_NUM_ARGS(...) VA_NUM_ARGS_IMPL(__VA_ARGS__, 5, 4, 3, 2, 1)

#define ALL_UNUSED_IMPL_(nargs) UNUSED ## nargs
#define ALL_UNUSED_IMPL(nargs) ALL_UNUSED_IMPL_(nargs)
#define ALL_UNUSED(...) ALL_UNUSED_IMPL( VA_NUM_ARGS(__VA_ARGS__))(__VA_ARGS__ )

was kann wie folgt verwendet werden

 int main()
 {
    int a,b,c;
    long f,d;

    ALL_UNUSED(a,b,c,f,d);

    return 0;
  }

Eclipse-Makroerweiterung ergibt:

  (void)(a),(void)(b),(void)(c),(void)(f),(void)(d)

zusammengestellt mit gcc -Wall ohne Warnungen

BEARBEITEN:

#define UNUSED1(z) (void)(z)
#define UNUSED2(y,z) UNUSED1(y),UNUSED1(z)
#define UNUSED3(x,y,z) UNUSED1(x),UNUSED2(y,z)
#define UNUSED4(b,x,y,z) UNUSED2(b,x),UNUSED2(y,z)
#define UNUSED5(a,b,x,y,z) UNUSED2(a,b),UNUSED3(x,y,z)

EDIT2

Wie für inline Methode, die Sie gepostet haben, ein Schnelltest

int a=0;
long f,d;

ALL_UNUSEDINLINE(a,f,&d);

gibt ‘f’ is used uninitialized in this function [-Wuninitialized] Warnung. Hier also zumindest ein Anwendungsfall, der die Allgemeingültigkeit dieses Ansatzes bricht

Ich habe die großartige Lösung von Dabo (https://stackoverflow.com/a/23238813/5126486) genommen und ein wenig verbessert, damit es einfacher ist, sie auf mehr als 5 zu erweitern:

#define UNUSED0()
#define UNUSED1(a)                  (void)(a)
#define UNUSED2(a,b)                (void)(a),UNUSED1(b)
#define UNUSED3(a,b,c)              (void)(a),UNUSED2(b,c)
#define UNUSED4(a,b,c,d)            (void)(a),UNUSED3(b,c,d)
#define UNUSED5(a,b,c,d,e)          (void)(a),UNUSED4(b,c,d,e)

#define VA_NUM_ARGS_IMPL(_0,_1,_2,_3,_4,_5, N,...) N
#define VA_NUM_ARGS(...) VA_NUM_ARGS_IMPL(100, ##__VA_ARGS__, 5, 4, 3, 2, 1, 0 )

#define ALL_UNUSED_IMPL_(nargs) UNUSED ## nargs
#define ALL_UNUSED_IMPL(nargs) ALL_UNUSED_IMPL_(nargs)
#define ALL_UNUSED(...) ALL_UNUSED_IMPL( VA_NUM_ARGS(__VA_ARGS__))(__VA_ARGS__ )

Was denkst du darüber:

#define UNUSED(...) [__VA_ARGS__](){};

Beispiel:

void f(int a, char* b, long d)
{
    UNUSED(a, b, d);
}

Sollte zu einer Lambdas-Definition erweitert werden:

[a,b,d](){}; //optimized by compiler (I hope!)

===== Getestet mit http://gcc.godbolt.org ===== Ich habe es mit diesem Code versucht:

#define UNUSED(...) [__VA_ARGS__](){};

int square(int num, float a) {
  UNUSED(a);
  return num * num;
}

Die resultierende Ausgabe (kompiliert mit -O0 -Wall) ist:

square(int, float):
    pushq   %rbp
    movq    %rsp, %rbp
    movl    %edi, -4(%rbp)
    movss   %xmm0, -8(%rbp)
    movl    -4(%rbp), %eax
    imull   -4(%rbp), %eax
    popq    %rbp
    ret

BEARBEITEN:

Wenn Sie C ++ 11 verwenden können, könnte dies eine bessere Lösung sein:

template <typename ...Args>
void UNUSED(Args&& ...args)
{
    (void)(sizeof...(args));
}

Hier ist ein sehr einfacher Ansatz, der keine besonderen Tricks erfordert und auch keinen Laufzeit-Overhead verursacht.

Ursprüngliche Antwort (nur C++)

#define UNUSED(...) (void)sizeof(__VA_ARGS__)

https://godbolt.org/z/Gz8MfvaTz

Aktualisierte Antwort (C und C++)

Ich hatte vergessen, den Compiler von C++ auf C umzustellen, und daher die überarbeitete Antwort.

int main(int argc, char ** argv)
{
    /* different types */
    UNUSED(argc, argv);

    /* many variables */
    int w, x, y, z;
    UNUSED(w, x, y, z);

    /* single variable */
    void * ptr;
    UNUSED(ptr);
}

MSVC

/O2 /W4
Keine Warnungen von C- und C++-Compilern.

Klirren

-O3 -Wand -Wextra
Keine Warnungen von C- und C++-Compilern.

GCC

-O3 -Wand -Wextra
Keine Warnungen nur vom C++-Compiler. Beim C-Compiler wird nur der letzte Parameter ohne Warnung ignoriert. Also im schlimmsten Fall diese Version von UNUSED ist dem traditionellen ebenbürtig #define UNUSED(x) ((void)x).

Das Folgende verursacht keine Warnungen mit -Wall -Wextra auf GCC und Clang, funktioniert aber nur für C11 und höher:

#define UNUSED(...) ((void)sizeof((_Bool[]){__VA_ARGS__}))

Eine etwas verfeinerte Version der Lösung in der Frage, die jede Art von Argumenten akzeptiert:

static inline void UNUSED2(int dummy, ...)
{
    (void)dummy;
}
#define UNUSED(...) UNUSED2(0, __VA_ARGS__)

Scheint mit mehreren Compilern zu arbeiten, nicht nur mit GCC.

Sie können die Kompilierzeit verwenden __VA_ARGS__ Makro.

#define UNUSED(...) (void)(__VA_ARGS__)

AKTUALISIEREN: Nach vielen Versuchen bin ich zu einer optimierten Lösung gekommen:

#define UNUSED(...)  __VA_ARGS__

int main()
{
    int e, x;
    char **a, **b, *c, d[45];
    x = x, UNUSED(a, b, c, d, e), x; 

    return 0;
}

ANMERKUNGEN:

1. Es eliminiert Warnungen nicht vollständig, aber reduziert sie nur 3 Gleiche Art von Warnungen:
   warning: value computed is not used

2. Der erste und der letzte x Zuweisung gleicher Datentypen sicherstellen.

3. Ich werde sagen, es ist optimiert, weil es für eine beliebige Anzahl von unbenutzten Variablen gibt 3 Warnungen (ich kann mich irren, bitte testen Sie es selbst und melden Sie mich, wenn Sie mehr erhalten) und die Menge an Code (MACRO-Manipulationen), die erforderlich ist, um dies zu erreichen, ist geringer.

4. Ich arbeite noch daran, werde posten, wenn ich zu einer besseren Lösung komme.