So deaktivieren Sie GCC-Warnungen für einige Codezeilen

220

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?

Matt Joiner
quelle
1
Mögliches Duplikat der Deaktivierung bestimmter Warnungen in gcc - Hoppla, tatsächlich ist diese Frage selbst ein Betrug (aber nicht geschlossen). Das ist zufällig derjenige, der unter "Verwandte" aufgetaucht ist. Wie auch immer, dies wurde mehrmals auf SO gefragt und beantwortet.
Tyler McHenry
1
@paxdiablo: Ich mache das Gegenteil. Ich habe die Warnstufe sehr hoch angehoben und möchte Warnungen Zeile für Zeile unterdrücken, die ich als in Ordnung bestätigt habe.
Matt Joiner
4
@ Tyler McHenry: Wenn Sie genauer hinschauen, stellen Sie möglicherweise fest, dass die verknüpfte Frage eine Lösung pro Datei enthält, genau die, die ich in meiner eigenen Frage als unbefriedigend erwähnt habe (ich habe sogar den Link gestohlen).
Matt Joiner
6
@paxdiablo, Compiler geben falsch positive Ergebnisse aus. Manchmal möchten Sie mit -Werror kompilieren, aber diese falsch positiven Ergebnisse blockieren keinen Build. Daher ist es in einigen Fällen sinnvoll, bestimmte Fälle zu deaktivieren und zu kommentieren, warum. Es gibt auch andere Fälle, in denen dies nützlich sein könnte - wie das automatische Generieren von Code, der harmlose Warnungen erzeugt, die nicht so einfach einzugeben und zu ändern sind (da der Code generiert wird), obwohl in diesem Fall das Deaktivieren pro Datei wahrscheinlicher ist die Lösung.
ideasman42

Antworten:

221

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 */
Matt Joiner
quelle
14
ein pushund zwei pops - kann ein anderes pusham anfang fehlen?
Abyss.7
37
"#pragma GCC-Diagnose-Push #pragma GCC-Diagnose-Pop veranlasst GCC, sich bei jedem Push den Status der Diagnose zu merken und bei jedem Pop auf diesen Punkt wiederherzustellen. Wenn ein Pop keinen passenden Push hat, werden die Befehlszeilenoptionen wiederhergestellt. "" - Aus dem GCC-Handbuch: gcc.gnu.org/onlinedocs/gcc/Diagnostic-Pragmas.html
Bobpaul
11
Als Referenz unterstützt gcc Version 4.4.3 Fehler / Warnung / ignoriert, aber nicht Push / Pop
Frankster
12
Die erste Version von GCC mit diagnostischem Push / Pop ist GCC 4.6.4 . Ich habe dies anhand des Abschnitts Diagnostic-Pragmas.html # Diagnostic-Pragmas für jede GCC-Version in der GCC-Dokumentation festgestellt
Bitek
5
Es ist eine Schande, dass dies in der Praxis nicht funktioniert. In einigen Fällen werden mehr Warnungen ausgegeben. Oder, genauer gesagt, es funktioniert in der Praxis für GCC 4.7 bis 5.1 nicht. Siehe zum Beispiel, dass GCC die Pragma-GCC-Diagnose nicht berücksichtigt, um Warnungen zum Schweigen zu bringen .
JWW
108

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 .

Ian Pilcher
quelle
2
Sollte funktionieren, aber ich gcc-4.9ignoriere diese Zeile einfach komplett.
Aleksei Petrenko
31

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.

Christian Hujer
quelle
2
re: improving the sourceEs würde auch funktionieren, die Deklaration von main in zu ändern, int main(int, const char* argv[]) { ... }indem dem Argument kein Name gegeben wird. Sie teilen dem Compiler mit, dass es nicht verwendet wird.
Jesse Chisholm
1
@JesseChisholm Das Weglassen des Parameternamens bei der Funktionsdefinition ist nicht möglich. Siehe 6.9.1 Funktion definintions von ISO / IEC9899, §5 „Wenn der declarator eine Liste Parametertyp enthält, wird die Erklärung der einzelnen Parameter umfasst eine Kennung [...]“ Und richtig so würde der Code durch abgelehnt werden gccsowie clang.
Christian Hujer
1
Ein anderes Muster besteht darin, nur eine Umwandlung der Variablen in den Leerlauf durchzuführen. Tatsächlich habe ich in einem Projekt das folgende Makro gesehen: Wird #define UNUSED(x) ((void)x)verwendet, um Warnungen auszuschalten. Ich denke es war in ReactOS?
Paul Stelian
1
Ich glaube nicht, dass du danach den Backslash brauchst, nein? _Pragma("GCC diagnostic pop") \ sollte nur sein, _Pragma("GCC diagnostic pop")denke ich.
Gabriel Staples
1
@ GabrielStaples Das stimmt, danke, dass du es bemerkt hast. Ich habe die Antwort aktualisiert.
Christian Hujer
20
#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.

Martin Gerhardy
quelle
3
Sie da echte MVP
Zeboidlund
19
#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.

Joe D.
quelle
4
Es ist eine Schande, dass dies in der Praxis nicht funktioniert. In einigen Fällen werden mehr Warnungen ausgegeben. Oder, genauer gesagt, es funktioniert in der Praxis für GCC 4.7 bis 5.1 nicht. Siehe zum Beispiel, dass GCC die Pragma-GCC-Diagnose nicht berücksichtigt, um Warnungen zum Schweigen zu bringen .
JWW
6

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
Shital Shah
quelle
2
Sollte dies besser nicht mit gcc behandelt werden System - Verzeichnisse ?
Rot XIII
@RedXIII - Ja, das ist eine Option, wenn Sie eine Liste solcher Verzeichnisse erstellen und in der gcc-Befehlszeile angeben können. Der Compiler wird jedoch häufig tief in der Pipeline aufgerufen, oder Sie haben nicht viel Kontrolle darüber, wie jemand anderes Ihren Code kompilieren soll. In diesen Fällen ist oben wahrscheinlich eine bessere Lösung.
Shital Shah
5

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.

nemequ
quelle
3

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.

R .. GitHub HÖREN SIE AUF, EIS ZU HELFEN
quelle
2
Vielleicht so. Meine Absicht ist es nicht, ein allgemeines Fallmuster zu beweisen, sondern eine Beobachtung darüber, wie die Philosophie von gcc zur Unterdrückung von Warnungen zu sein scheint.
R .. GitHub STOP HELPING ICE
Der Compiler verhält sich anders mit Warnungen mit hinzugefügten Klammern?!?! ?? !!!! BEEINDRUCKEND! Das ist unerwartet.
Jason S
1
@JasonS the parens ändert das Verhalten des Compilers in Bezug auf Warnungen nicht. Es ändert lediglich die Semantik der Anweisung. Durch die zusätzlichen Parens beendet der Compiler die Zuweisung und behält seinen endgültigen Wert als Ausdruck bei, der keine Warnung verdient. Wenn Sie Klarheit wünschen, können Sie sagen if ((p=malloc(cnt)) != NULL) ..., dass der Compiler dies hinter den Kulissen tut.
Jesse Chisholm
@ JesseChisholm: Ich denke nicht, dass Ihre Erklärung korrekt ist.
R .. GitHub STOP HELPING ICE
3

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 .

Keron
quelle