In Visual C ++ ist die Verwendung möglich #pragma warning (disable: ...). Außerdem habe ich festgestellt, dass Sie in GCC die Compiler-Flags pro Datei überschreiben können . Wie kann ich dies für "nächste Zeile" oder mit Push / Pop-Semantik in Codebereichen mithilfe von GCC tun?

Es scheint, dass dies getan werden kann . Ich kann die hinzugefügte Version von GCC nicht bestimmen, aber es war einige Zeit vor Juni 2010.

Hier ist ein Beispiel:

#pragma GCC diagnostic error "-Wuninitialized"
    foo(a);         /* error is given for this one */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wuninitialized"
    foo(b);         /* no diagnostic for this one */
#pragma GCC diagnostic pop
    foo(c);         /* error is given for this one */
#pragma GCC diagnostic pop
    foo(d);         /* depends on command line options */

Dies ist ein Beispiel für die vorübergehende Deaktivierung einer Warnung:

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-result"
    write(foo, bar, baz);
#pragma GCC diagnostic pop

Weitere Informationen finden Sie in der GCC-Dokumentation zu diagnostischen Pragmas .

TL; DR : Wenn es funktioniert, vermeiden oder verwenden Sie __attribute__andere Bezeichner _Pragma.

Dies ist eine Kurzversion meines Blog-Artikels Unterdrückte Warnungen in GCC und Clang .

Folgendes berücksichtigen Makefile

CPPFLAGS:=-std=c11 -W -Wall -pedantic -Werror

.PHONY: all
all: puts

zum Erstellen des folgenden puts.cQuellcodes

#include <stdio.h>

int main(int argc, const char *argv[])
{
    while (*++argv) puts(*argv);
    return 0;
}

Es wird da nicht kompiliert argc es nicht verwendet wird und die Einstellungen hardcore sind (-W -Wall -pedantic -Werror ) sind.

Es gibt 5 Dinge, die Sie tun könnten:

• Verbessern Sie den Quellcode nach Möglichkeit
• Verwenden Sie einen Deklarationsspezifizierer wie __attribute__
• Verwenden _Pragma
• Verwenden #pragma
• Verwenden Sie eine Befehlszeilenoption.

Quelle verbessern

Der erste Versuch sollte darin bestehen, zu überprüfen, ob der Quellcode verbessert werden kann, um die Warnung zu entfernen. In diesem Fall möchten wir den Algorithmus nicht nur deswegen ändern, da er argcmit !*argv(NULL nach dem letzten Element) .

Verwenden eines Deklarationsspezifizierers wie __attribute__

#include <stdio.h>

int main(__attribute__((unused)) int argc, const char *argv[])
{
    while (*++argv) puts(*argv);
    return 0;
}

Wenn Sie Glück haben, bietet der Standard einen Spezifizierer für Ihre Situation, wie z _Noreturn.

__attribute__ist eine proprietäre GCC-Erweiterung (wird auch von Clang und einigen anderen Compilern unterstützt armcc) und wird von vielen anderen Compilern nicht verstanden. Fügen Sie __attribute__((unused))ein Makro ein, wenn Sie portablen Code möchten.

_Pragma Operator

_Pragmakann als Alternative zu verwendet werden #pragma.

#include <stdio.h>

_Pragma("GCC diagnostic push")
_Pragma("GCC diagnostic ignored \"-Wunused-parameter\"")

int main(int argc, const char *argv[])
{
    while (*++argv) puts(*argv);
    return 0;
}
_Pragma("GCC diagnostic pop")

Der Hauptvorteil des _PragmaOperators besteht darin, dass Sie ihn in Makros einfügen können, was mit der #pragmaDirektive nicht möglich ist .

Nachteil: Es ist fast ein taktischer Nuke, da es zeilenbasiert statt deklarationsbasiert funktioniert.

Der _PragmaBetreiber wurde in C99 eingeführt.

#pragma Richtlinie.

Wir könnten den Quellcode ändern, um die Warnung für einen Codebereich zu unterdrücken, normalerweise eine ganze Funktion:

#include <stdio.h>

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
int main(int argc, const char *argv[])
{
    while (*++argc) puts(*argv);
    return 0;
}
#pragma GCC diagnostic pop

Nachteil: Es ist fast ein taktischer Nuke, da es zeilenbasiert statt deklarationsbasiert funktioniert.

Beachten Sie, dass eine ähnliche Syntax in clang vorhanden ist .

Unterdrücken der Warnung in der Befehlszeile für eine einzelne Datei

Wir könnten die folgende Zeile hinzufügen Makefile, um die Warnung speziell für Puts zu unterdrücken:

CPPFLAGS:=-std=c11 -W -Wall -pedantic -Werror

.PHONY: all
all: puts

puts.o: CPPFLAGS+=-Wno-unused-parameter

Dies ist wahrscheinlich nicht erwünscht, was Sie in Ihrem speziellen Fall wollen, aber es kann anderen Lesungen helfen, die sich in ähnlichen Situationen befinden.

#define DIAG_STR(s) #s
#define DIAG_JOINSTR(x,y) DIAG_STR(x ## y)
#ifdef _MSC_VER
#define DIAG_DO_PRAGMA(x) __pragma (#x)
#define DIAG_PRAGMA(compiler,x) DIAG_DO_PRAGMA(warning(x))
#else
#define DIAG_DO_PRAGMA(x) _Pragma (#x)
#define DIAG_PRAGMA(compiler,x) DIAG_DO_PRAGMA(compiler diagnostic x)
#endif
#if defined(__clang__)
# define DISABLE_WARNING(gcc_unused,clang_option,msvc_unused) DIAG_PRAGMA(clang,push) DIAG_PRAGMA(clang,ignored DIAG_JOINSTR(-W,clang_option))
# define ENABLE_WARNING(gcc_unused,clang_option,msvc_unused) DIAG_PRAGMA(clang,pop)
#elif defined(_MSC_VER)
# define DISABLE_WARNING(gcc_unused,clang_unused,msvc_errorcode) DIAG_PRAGMA(msvc,push) DIAG_DO_PRAGMA(warning(disable:##msvc_errorcode))
# define ENABLE_WARNING(gcc_unused,clang_unused,msvc_errorcode) DIAG_PRAGMA(msvc,pop)
#elif defined(__GNUC__)
#if ((__GNUC__ * 100) + __GNUC_MINOR__) >= 406
# define DISABLE_WARNING(gcc_option,clang_unused,msvc_unused) DIAG_PRAGMA(GCC,push) DIAG_PRAGMA(GCC,ignored DIAG_JOINSTR(-W,gcc_option))
# define ENABLE_WARNING(gcc_option,clang_unused,msvc_unused) DIAG_PRAGMA(GCC,pop)
#else
# define DISABLE_WARNING(gcc_option,clang_unused,msvc_unused) DIAG_PRAGMA(GCC,ignored DIAG_JOINSTR(-W,gcc_option))
# define ENABLE_WARNING(gcc_option,clang_option,msvc_unused) DIAG_PRAGMA(GCC,warning DIAG_JOINSTR(-W,gcc_option))
#endif
#endif

Dies sollte den Trick für gcc, clang und msvc tun

Kann aufgerufen werden mit zB:

DISABLE_WARNING(unused-variable,unused-variable,42)
[.... some code with warnings in here ....]
ENABLE_WARNING(unused-variable,unused-variable,42)

Siehe https://gcc.gnu.org/onlinedocs/cpp/Pragmas.html , http://clang.llvm.org/docs/UsersManual.html#controlling-diagnostics-via-pragmas und https://msdn.microsoft Weitere Informationen finden Sie unter .com / de-DE / library / d9x1s805.aspx

Sie benötigen mindestens Version 4.02, um diese Art von Pragmas für gcc zu verwenden. Sie sind sich nicht sicher über msvc und klirren über die Versionen.

Es sieht so aus, als ob das Push-Pop-Pragma-Handling für gcc etwas kaputt ist. Wenn Sie die Warnung erneut aktivieren, wird weiterhin die Warnung für den Block angezeigt, der sich im Block DISABLE_WARNING / ENABLE_WARNING befand. Für einige Versionen von gcc funktioniert es, für andere nicht.

#pragma GCC diagnostic ignored "-Wformat"

Ersetzen Sie "-Wformat" durch den Namen Ihres Warnflags.

AFAIK Es gibt keine Möglichkeit, die Push / Pop-Semantik für diese Option zu verwenden.

Ich hatte das gleiche Problem mit externen Bibliotheken wie ROS-Headern. Ich verwende gerne die folgenden Optionen in CMakeLists.txt für eine strengere Kompilierung:

set(CMAKE_CXX_FLAGS "-std=c++0x -Wall -Wextra -Wstrict-aliasing -pedantic -Werror -Wunreachable-code ${CMAKE_CXX_FLAGS}")

Dies führt jedoch auch in extern eingeschlossenen Bibliotheken zu allen Arten von pedantischen Fehlern. Die Lösung besteht darin, alle pedantischen Warnungen zu deaktivieren, bevor Sie externe Bibliotheken einschließen, und diese wie folgt erneut zu aktivieren:

//save compiler switches
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpedantic"

//Bad headers with problem goes here
#include <ros/ros.h>
#include <sensor_msgs/LaserScan.h>

//restore compiler switches
#pragma GCC diagnostic pop

Ich weiß, die Frage bezieht sich auf GCC, aber für Leute, die suchen, wie dies in anderen und / oder mehreren Compilern gemacht werden kann ...

TL; DR

Vielleicht möchten Sie einen Blick auf Hedley werfen , einen gemeinfreien C / C ++ - Header, den ich geschrieben habe und der viel bewirkt für Sie . Ich werde am Ende dieses Beitrags einen kurzen Abschnitt über die Verwendung von Hedley für all dies einfügen.

Warnung deaktivieren

#pragma warning (disable: …) hat Äquivalente in den meisten Compilern:

• MSVC: #pragma warning(disable:4996)
• GCC: #pragma GCC diagnostic ignored "-W…"wobei die Ellipse der Name der Warnung ist; zB , #pragma GCC diagnostic ignored "-Wdeprecated-declarations.
• klirren: #pragma clang diagnostic ignored "-W…" . Die Syntax ist im Grunde die gleiche wie bei GCC, und viele der Warnnamen sind gleich (obwohl viele nicht).
• Intel C Compiler: Verwenden Sie die MSVC-Syntax, beachten Sie jedoch, dass die Warnnummern völlig unterschiedlich sind. Beispiel:#pragma warning(disable:1478 1786) .
• GgA: Es gibt ein diag_suppressPragma:#pragma diag_suppress 1215,1444
• TI: Es gibt ein diag_suppressPragma mit derselben Syntax (aber unterschiedlichen Warnnummern!) Wie PGI:pragma diag_suppress 1291,1718
• Oracle Developer Studio (suncc): Es gibt ein error_messagesPragma. Ärgerlicherweise unterscheiden sich die Warnungen für die C- und C ++ - Compiler. Beide deaktivieren im Grunde die gleichen Warnungen:
  • C: #pragma error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)
  • C ++: #pragma error_messages(off,symdeprecated,symdeprecated2)
• IAR: Verwendet auch diag_suppresswie PGI und TI, aber die Syntax ist unterschiedlich. Einige der Warnnummern sind die gleichen, aber ich andere sind auseinander gegangen:#pragma diag_suppress=Pe1444,Pe1215
• Pelles C: ähnlich wie MSVC, auch hier sind die Zahlen unterschiedlich #pragma warn(disable:2241)

Für die meisten Compiler ist es oft eine gute Idee, die Compilerversion zu überprüfen, bevor Sie versuchen, sie zu deaktivieren. Andernfalls wird nur eine weitere Warnung ausgelöst. Zum Beispiel hat GCC 7 Unterstützung für die -Wimplicit-fallthroughWarnung hinzugefügt. Wenn Sie sich also für GCC vor 7 interessieren, sollten Sie so etwas tun

#if defined(__GNUC__) && (__GNUC__ >= 7)
#  pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
#endif

Bei Clang und Compilern, die auf Clang basieren, wie z. B. neueren Versionen von XL C / C ++ und Armclang, können Sie mithilfe des __has_warning()Makros überprüfen, ob der Compiler über eine bestimmte Warnung informiert ist .

#if __has_warning("-Wimplicit-fallthrough")
#  pragma clang diagnostic ignored "-Wimplicit-fallthrough"
#endif

Natürlich müssen Sie auch überprüfen, ob das __has_warning()Makro vorhanden ist:

#if defined(__has_warning)
#  if __has_warning("-Wimplicit-fallthrough")
#    pragma clang diagnostic ignored "-Wimplicit-fallthrough"
#  endif
#endif

Sie könnten versucht sein, so etwas zu tun

#if !defined(__has_warning)
#  define __has_warning(warning)
#endif

So können Sie __has_warningetwas einfacher verwenden. Clang schlägt __has_builtin()in ihrem Handbuch sogar etwas Ähnliches für das Makro vor. Tu das nicht . Andere Codes suchen möglicherweise nach __has_warningCompilerversionen und greifen auf diese zurück, wenn sie nicht vorhanden sind. Wenn Sie definieren __has_warning, wird der Code beschädigt. Der richtige Weg, dies zu tun, besteht darin, ein Makro in Ihrem Namespace zu erstellen. Beispielsweise:

#if defined(__has_warning)
#  define MY_HAS_WARNING(warning) __has_warning(warning)
#else
#  define MY_HAS_WARNING(warning) (0)
#endif

Dann kannst du Sachen wie machen

#if MY_HAS_WARNING(warning)
#  pragma clang diagnostic ignored "-Wimplicit-fallthrough"
#elif defined(__GNUC__) && (__GNUC__ >= 7)
#  pragma GCC diagnostic ignored "-Wimplicit-fallthrough"
#endif

Schieben und knallen

Viele Compiler unterstützen auch die Möglichkeit, Warnungen auf einen Stapel zu übertragen. Dadurch wird beispielsweise eine Warnung in GCC für eine Codezeile deaktiviert und anschließend in den vorherigen Status zurückgesetzt:

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated"
call_deprecated_function();
#pragma GCC diagnostic pop

Natürlich gibt es zwischen den Compilern keine große Übereinstimmung hinsichtlich der Syntax:

• GCC 4.6+: #pragma GCC diagnostic push/#pragma GCC diagnostic pop
• klirren: #pragma clang diagnostic push/#pragma diagnostic pop
• Intel 13+ (und wahrscheinlich früher): #pragma warning(push)/#pragma warning(pop)
• MSVC 15+ (VS 9.0 / 2008): #pragma warning(push)/#pragma warning(pop)
• ARM 5.6+: #pragma push/#pragma pop
• TI 8.1+: #pragma diag_push/#pragma diag_pop
• Pelles C 2.90+ (und wahrscheinlich früher): #pragma warning(push)/#pragma warning(pop)

Wenn Speicher dient, mussten für einige sehr alte Versionen von GCC (wie 3.x, IIRC) die Push / Pop-Pragmas außerhalb der Funktion liegen.

Versteckt die blutigen Details

Für die meisten Compiler ist es möglich, die Logik hinter Makros mit zu verbergen _Pragma, die in C99 eingeführt wurde. Selbst im Nicht-C99-Modus unterstützen die meisten Compiler _Pragma. Die große Ausnahme ist MSVC, das ein eigenes __pragmaSchlüsselwort mit einer anderen Syntax hat. Der Standard verwendet _Pragmaeine Zeichenfolge, die Microsoft-Version nicht:

#if defined(_MSC_VER)
#  define PRAGMA_FOO __pragma(foo)
#else
#  define PRAGMA_FOO _Pragma("foo")
#endif
PRAGMA_FOO

Ist ungefähr gleichbedeutend mit einmal vorverarbeitet zu

#pragma foo

Auf diese Weise können wir Makros erstellen, damit wir Code wie schreiben können

MY_DIAGNOSTIC_PUSH
MY_DIAGNOSTIC_DISABLE_DEPRECATED
call_deprecated_function();
MY_DIAGNOSTIC_POP

Und verstecken Sie alle hässlichen Versionsprüfungen in den Makrodefinitionen.

Der einfache Weg: Hedley

Jetzt, da Sie die Mechanik verstehen, wie man solche Dinge portabel macht, während Sie Ihren Code sauber halten, verstehen Sie, was eines meiner Projekte ist, Hedley . Anstatt Tonnen von Dokumentation zu durchsuchen und / oder so viele Versionen von so vielen Compilern wie möglich zu installieren, können Sie einfach Hedley (es ist ein einzelner gemeinfreier C / C ++ - Header) einbinden und damit fertig sein. Beispielsweise:

#include "hedley.h"

HEDLEY_DIAGNOSTIC_PUSH
HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
call_deprecated();
HEDLEY_DIAGNOSTIC_POP

Deaktiviert die Warnung zum Aufrufen einer veralteten Funktion für GCC, Clang, ICC, PGI, MSVC, TI, IAR, ODS, Pelles und möglicherweise andere (ich werde diese Antwort wahrscheinlich nicht aktualisieren, wenn ich Hedley aktualisiere). Und auf Compilern, von denen nicht bekannt ist, dass sie funktionieren, werden die Makros zu nichts vorverarbeitet, sodass Ihr Code weiterhin mit jedem Compiler funktioniert. Natürlich HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATEDist Hedley nicht die einzige Warnung, von der Hedley weiß, und das Deaktivieren von Warnungen ist nicht alles, was Hedley tun kann, aber hoffentlich haben Sie die Idee.

Anstatt die Warnungen zum Schweigen zu bringen, verwendet der gcc-Stil normalerweise entweder Standard-C-Konstrukte oder die __attribute__Erweiterung, um dem Compiler mehr über Ihre Absicht zu erzählen. Zum Beispiel wird die Warnung über die als Bedingung verwendete Zuweisung unterdrückt, indem die Zuweisung in Klammern gesetzt wird, dh if ((p=malloc(cnt)))anstelle von if (p=malloc(cnt)). Warnungen vor nicht verwendeten Funktionsargumenten können durch seltsame Ereignisse, an die __attribute__ich mich nie erinnern kann, oder durch Selbstzuweisung usw. unterdrückt werden . Im Allgemeinen ziehe ich es jedoch vor, Warnoptionen, die Warnungen für Dinge generieren, die im richtigen Code auftreten, nur global zu deaktivieren.

Wenn Sie diese Seite gefunden haben und nach einer Möglichkeit suchen, dies in IAR zu tun, versuchen Sie Folgendes:

#pragma diag_suppress=Pe177
void foo1( void )
{
   /* The following line of code would normally provoke diagnostic 
      message #177-D: variable "x" was declared but never referenced.
      Instead, we have suppressed this warning throughout the entire 
      scope of foo1(). 
   */
   int x;
}
#pragma diag_default=Pe177

Weitere Informationen finden Sie unter http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0472m/chr1359124244797.html .