Wie kann ich eine Warnung vor nicht verwendeten Variablen am besten zum Schweigen bringen?

Ich habe eine plattformübergreifende Anwendung und in einigen meiner Funktionen werden nicht alle an Funktionen übergebenen Werte verwendet. Daher erhalte ich eine Warnung von GCC, dass es nicht verwendete Variablen gibt.

Was wäre der beste Weg, um die Warnung zu codieren?

Ein #ifdef um die Funktion?

#ifdef _MSC_VER
void ProcessOps::sendToExternalApp(QString sAppName, QString sImagePath, qreal qrLeft, qreal qrTop, qreal qrWidth, qreal qrHeight)
#else
void ProcessOps::sendToExternalApp(QString sAppName, QString sImagePath, qreal /*qrLeft*/, qreal /*qrTop*/, qreal /*qrWidth*/, qreal /*qrHeight*/)
#endif
{

Das ist so hässlich, scheint aber so, wie es der Compiler bevorzugen würde.

Oder weise ich der Variablen am Ende der Funktion Null zu? (was ich hasse, weil es etwas im Programmablauf ändert, um eine Compiler-Warnung zum Schweigen zu bringen).

Gibt es einen richtigen Weg?

Sie können es in den (void)var;Ausdruck " " setzen (tut nichts), damit ein Compiler sieht, dass es verwendet wird. Dies ist zwischen Compilern portierbar.

Z.B

void foo(int param1, int param2)
{
    (void)param2;
    bar(param1);
}

Oder,

#define UNUSED(expr) do { (void)(expr); } while (0)
...

void foo(int param1, int param2)
{
    UNUSED(param2);
    bar(param1);
}

In GCC und Clang können Sie die __attribute__((unused))Präprozessor-Direktive verwenden, um Ihr Ziel zu erreichen.
Beispielsweise:

int foo (__attribute__((unused)) int bar) {
   return 0;
}

C ++ 17 stellt jetzt das [[maybe_unused]]Attribut bereit .

http://en.cppreference.com/w/cpp/language/attributes

Ganz nett und normal.

Ihre aktuelle Lösung ist am besten - kommentieren Sie den Parameternamen aus, wenn Sie ihn nicht verwenden. Dies gilt für alle Compiler, sodass Sie den Vorprozessor nicht speziell für GCC verwenden müssen.

C ++ 17 Update

In C ++ 17 erhalten wir das Attribut [[vielleicht_unused]], das in [dcl.attr.unused] behandelt wird.

Das Attribut-Token Maybe_unused gibt an, dass ein Name oder eine Entität möglicherweise absichtlich nicht verwendet wird. Es darf höchstens einmal in jeder Attributliste erscheinen und es darf keine Attributargumentklausel vorhanden sein. ...

Beispiel:

 [[maybe_unused]] void f([[maybe_unused]] bool thing1,
                        [[maybe_unused]] bool thing2) {
  [[maybe_unused]] bool b = thing1 && thing2;
    assert(b);
 }

Implementierungen sollten nicht warnen, dass b nicht verwendet wird, unabhängig davon, ob NDEBUG definiert ist oder nicht. - Beispiel beenden]

Für das folgende Beispiel:

int foo ( int bar) {
    bool unused_bool ;
    return 0;
}

Sowohl clang als auch gcc generieren eine Diagnose mit -Wall -Wextra für bar und unused_bool ( Live anzeigen ).

Beim Hinzufügen von [[vielleicht_unused]] wird die Diagnose stummgeschaltet :

int foo ([[maybe_unused]] int bar) {
    [[maybe_unused]] bool unused_bool ;
    return 0;
}

sehe es live .

Vor C ++ 17

In C ++ 11 könnte eine alternative Form des UNUSEDMakros unter Verwendung eines Lambda-Ausdrucks ( über Ben Deane ) mit einer Erfassung der nicht verwendeten Variablen gebildet werden:

#define UNUSED(x) [&x]{}()

Der sofortige Aufruf des Lambda-Ausdrucks sollte anhand des folgenden Beispiels optimiert werden:

int foo (int bar) {
    UNUSED(bar) ;
    return 0;
}

wir können in godbolt sehen, dass der Anruf weg optimiert ist:

foo(int):
xorl    %eax, %eax
ret

Noch sauberer ist es, nur Variablennamen auskommentieren:

int main(int /* argc */, char const** /* argv */) {
  return 0;
}

Ein Mitarbeiter hat mich gerade auf dieses nette kleine Makro hier hingewiesen

Der Einfachheit halber werde ich das Makro unten einfügen.

#ifdef UNUSED
#elif defined(__GNUC__) 
# define UNUSED(x) UNUSED_ ## x __attribute__((unused)) 
#elif defined(__LCLINT__) 
# define UNUSED(x) /*@unused@*/ x 
#else 
# define UNUSED(x) x 
#endif

void dcc_mon_siginfo_handler(int UNUSED(whatsig))

gcckennzeichnet diese Warnungen standardmäßig nicht. Diese Warnung muss entweder explizit durch Übergabe -Wunused-parameteran den Compiler oder implizit durch Übergabe -Wall -Wextra(oder möglicherweise eine andere Kombination von Flags) aktiviert worden sein.

Nicht verwendete Parameterwarnungen können einfach durch Übergabe -Wno-unused-parameteran den Compiler unterdrückt werden. Beachten Sie jedoch, dass dieses Deaktivierungsflag nach möglichen Aktivierungsflags für diese Warnung in der Compiler-Befehlszeile stehen muss, damit es wirksam wird.

makellose und tragbare Methode, um einen oder mehrere Parameter als nicht verwendet zu deklarieren :

template <typename... Args> inline void unused(Args&&...) {}

int main(int argc, char* argv[])
{
    unused(argc, argv);
    return 0;
}

Die Verwendung von Präprozessor-Direktiven wird die meiste Zeit als böse angesehen. Idealerweise möchten Sie sie wie die Pest vermeiden. Denken Sie daran, dass es einfach ist, den Compiler dazu zu bringen, Ihren Code zu verstehen, und dass es für andere Programmierer viel schwieriger ist, Ihren Code zu verstehen. Ein paar Dutzend solcher Fälle hier und da machen es sehr schwer, später für sich selbst oder für andere zu lesen.

Eine Möglichkeit könnte darin bestehen, Ihre Parameter in einer Art Argumentklasse zusammenzufassen. Sie können dann nur eine Teilmenge der Variablen verwenden (entspricht wirklich Ihrer Zuweisung von 0) oder für jede Plattform unterschiedliche Spezialisierungen dieser Argumentklasse haben. Dies lohnt sich jedoch möglicherweise nicht. Sie müssen analysieren, ob es passt.

Wenn Sie unmögliche Vorlagen lesen können, finden Sie möglicherweise erweiterte Tipps im Buch "Außergewöhnliches C ++". Wenn die Leute, die Ihren Code lesen würden, ihre Fähigkeiten dazu bringen könnten, die verrückten Dinge zu erfassen, die in diesem Buch gelehrt werden, dann hätten Sie einen schönen Code, der auch leicht zu lesen ist. Der Compiler weiß auch genau, was Sie tun (anstatt alles durch Vorverarbeitung auszublenden).

Zunächst wird die Warnung durch die Variablendefinition in der Quelldatei und nicht durch die Headerdatei generiert. Der Header kann makellos bleiben und sollte, da Sie möglicherweise etwas wie Sauerstoff verwenden, um die API-Dokumentation zu generieren.

Ich gehe davon aus, dass Sie eine völlig andere Implementierung in Quelldateien haben. In diesen Fällen können Sie entweder den fehlerhaften Parameter auskommentieren oder einfach den Parameter schreiben.

Beispiel:

func(int a, int b)
{
    b;
    foo(a);
}

Dies mag kryptisch erscheinen, also definiert man ein Makro wie UNUSED. MFC hat es so gemacht:

#ifdef _DEBUG
#define UNUSED(x)
#else
#define UNUSED(x) x
#endif

So sehen Sie die Warnung noch in Debug-Builds, könnte hilfreich sein.

Ist es nicht sicher, Parameternamen immer auskommentieren? Wenn nicht, können Sie so etwas tun

#ifdef _MSC_VER
# define P_(n) n
#else
# define P_(n)
#endif

void ProcessOps::sendToExternalApp(
    QString sAppName, QString sImagePath,
    qreal P_(qrLeft), qreal P_(qrTop), qreal P_(qrWidth), qreal P_(qrHeight))

Es ist ein bisschen weniger hässlich.

Mit einem UNREFERENCED_PARAMETER(p)könnte funktionieren. Ich weiß, dass es in WinNT.h für Windows-Systeme definiert ist und auch für gcc leicht definiert werden kann (falls es noch nicht vorhanden ist).

UNREFERENCED PARAMETER(p) ist definiert als

#define UNREFERENCED_PARAMETER(P)          (P)

in WinNT.h.

Ich habe dies gesehen, anstatt (void)param2die Warnung zum Schweigen zu bringen:

void foo(int param1, int param2)
{
    std::ignore = param2;
    bar(param1);
}

Sieht so aus, als wäre dies in C ++ 11 hinzugefügt worden

Verwenden Sie das Compiler-Flag, z. B. das Flag für GCC: -Wno-unused-variable

Sie können __unuseddem Compiler mitteilen, dass die Variable möglicherweise nicht verwendet wird.

- (void)myMethod:(__unused NSObject *)theObject    
{
    // there will be no warning about `theObject`, because you wrote `__unused`

    __unused int theInt = 0;
    // there will be no warning, but you are still able to use `theInt` in the future
}

In C ++ 11 ist dies die Lösung, die ich verwende:

template<typename... Ts> inline void Unreferenced(Ts&&...) {}

int Foo(int bar) 
{
    Unreferenced(bar);
    return 0;
}

int Foo2(int bar1, int bar2) 
{
    Unreferenced(bar1, bar2);
    return 0;
}

Es wurde bestätigt, dass es portabel ist (zumindest auf modernen MSVC-, Clang- und GCC-Geräten) und keinen zusätzlichen Code erzeugt, wenn Optimierungen aktiviert sind. Ohne Optimierung wird der zusätzliche Funktionsaufruf ausgeführt und Verweise auf die Parameter werden in den Stapel kopiert, es sind jedoch keine Makros beteiligt.

Wenn der zusätzliche Code ein Problem darstellt, können Sie stattdessen diese Deklaration verwenden:

(decltype(Unreferenced(bar1, bar2)))0;

Zu diesem Zeitpunkt bietet ein Makro jedoch eine bessere Lesbarkeit:

#define UNREFERENCED(...) { (decltype(Unreferenced(__VA_ARGS__)))0; }

Dies funktioniert gut, erfordert jedoch C ++ 11

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

Ich habe festgestellt, dass die meisten der vorgestellten Antworten nur für lokale nicht verwendete Variablen funktionieren und Kompilierungsfehler für nicht verwendete statische globale Variablen verursachen.

Ein weiteres Makro musste die Warnung vor nicht verwendeten statischen globalen Variablen unterdrücken.

template <typename T>
const T* UNUSED_VARIABLE(const T& dummy) { 
    return &dummy;
}
#define UNUSED_GLOBAL_VARIABLE(x) namespace {\
    const auto dummy = UNUSED_VARIABLE(x);\
}

static int a = 0;
UNUSED_GLOBAL_VARIABLE(a);

int main ()
{
    int b = 3;
    UNUSED_VARIABLE(b);
    return 0;
}

Dies funktioniert, da für nicht statische globale Variablen im anonymen Namespace keine Warnung gemeldet wird.

C ++ 11 ist jedoch erforderlich

 g++  -Wall -O3  -std=c++11 test.cpp

Lol! Ich glaube nicht, dass es auf SO eine andere Frage gibt, die alle vom Chaos korrumpierten Ketzer besser enthüllt als diese!

Bei allem Respekt vor C ++ 17 gibt es in den C ++ - Kernrichtlinien eine klare Richtlinie . AFAIR, im Jahr 2009 war diese Option genauso verfügbar wie heute. Und wenn jemand sagt, dass es in Doxygen als Fehler angesehen wird, dann gibt es in Doxygen einen Fehler

Ich sehe Ihr Problem mit der Warnung nicht. Dokumentieren Sie im Methoden- / Funktionsheader, dass der Compiler xy hier eine (korrekte) Warnung ausgibt, diese Variablen jedoch für die Plattform z benötigt werden.

Die Warnung ist korrekt und muss nicht ausgeschaltet werden. Es macht das Programm nicht ungültig - aber es sollte dokumentiert werden, dass es einen Grund gibt.