Warnung für Objective-C-Entwicklung klingeln

Als C & Objective-C-Programmierer bin ich ein bisschen paranoid mit den Compiler-Warnflags.
Normalerweise versuche ich, eine vollständige Liste der Warnflags für den von mir verwendeten Compiler zu finden und die meisten davon zu aktivieren, es sei denn, ich habe einen guten Grund, es nicht zu aktivieren.

Ich persönlich bin der Meinung, dass dies die Codierungsfähigkeiten und die potenzielle Portierbarkeit von Code verbessern und einige Probleme verhindern kann, da Sie gezwungen sind, sich über jedes Detail, potenzielle Implementierungs- und Architekturprobleme usw. im Klaren zu sein.

Meiner Meinung nach ist es auch ein gutes alltägliches Lernwerkzeug, selbst wenn Sie ein erfahrener Programmierer sind.

Für den subjektiven Teil dieser Frage bin ich daran interessiert, andere Entwickler (hauptsächlich C, Objective-C und C ++) zu diesem Thema zu hören.
Interessieren Sie sich tatsächlich für Dinge wie pedantische Warnungen usw.? Und wenn ja oder nein, warum?

Bei Objective-C bin ich kürzlich vollständig auf die LLVM- Toolchain (mit Clang) anstatt auf GCC umgestiegen.

In meinem Produktionscode setze ich normalerweise diese Warnflags (explizit, auch wenn einige von ihnen von -Wall abgedeckt werden):

• -Wand
• -Bad-Funktion-Besetzung
• - Broadcast ausrichten
• -Wandlung
• - Erklärung nach Aussage
• - Veraltete Implementierungen
• -Wextra
• -Flott gleich
• -Wformat = 2
• -Format-nonliteral
• - Vier-Zeichen-Konstanten
• - Implizite Atomeigenschaften
• -Werfende-Klammern
• - Abweisungserklärungen
• -Feldinitialisierer
• -Format-Attribut-missing
• -Norwendegang
• -Missing-Prototypen
• -Wested-externs
• -Newline-Eof
• -Wold-Style-Definition
• -Überlängen-Saiten
• - Klammern
• -Winter-Arith
• -Wredundant-decls
• -Wreturn-Typ
• -Sequenzpunkt
• - Schatten
• -Shorten-64-bis-32
• -Zeichen-vergleichen
• - Zeichenumwandlung
• - Strenge Prototypen
• -Strict-Selector-Match
• -Schalter
• -Schalter-Standard
• -Witch-enum
• -Hundeclared-Selector
• - Nicht initialisiert
• -Wunknown-Pragmas
• -Wunreachable-Code
• -Wunused-Funktion
• - Unbenutztes Etikett
• -Wunused-Parameter
• -Wunused-Wert
• -Wunused-Variable
• -Write-Strings

Ich bin daran interessiert zu hören, was andere Entwickler dazu sagen.

Denken Sie zum Beispiel, dass ich eine bestimmte Flagge für Clang (Objective-C) verpasst habe und warum?
Oder halten Sie eine bestimmte Flagge für nicht sinnvoll (oder gar nicht erwünscht) und warum?

BEARBEITEN

Beachten Sie zur Klärung der Frage, dass -Wallnur einige grundlegende Warnungen angezeigt werden.
Es sind viel mehr Warnflaggen, die nicht abgedeckt werden -Wall, daher die Frage und die Liste, die ich zur Verfügung stelle.

Ich bin ein Clang-Entwickler, der bei Google arbeitet. Bei Google haben wir die Diagnose von Clang (im Wesentlichen) allen unseren C ++ - Entwicklern zur Verfügung gestellt, und wir behandeln die Warnungen von Clang auch als Fehler. Als Clang-Entwickler und einer der größeren Benutzer von Clangs Diagnose werde ich versuchen, diese Flags zu beleuchten und zu erläutern, wie sie verwendet werden können. Beachten Sie, dass alles, was ich beschreibe, generisch für Clang gilt und nicht spezifisch für C, C ++ oder Objective-C.

TL; DR - Version: Bitte verwenden -Wallund -Werrorbei einem Minimum an jedem neuen Code Sie entwickeln. Wir (die Compiler-Entwickler) fügen hier aus guten Gründen Warnungen hinzu: Sie finden Fehler. Wenn Sie eine Warnung finden, die Fehler für Sie entdeckt, aktivieren Sie diese ebenfalls. Versuchen Sie es hier -Wextramit ein paar guten Kandidaten. Wenn einer von ihnen zu laut ist, als dass Sie ihn gewinnbringend einsetzen könnten, melden Sie einen Fehler . Wenn Sie Code schreiben, der einen "offensichtlichen" Fehler enthält, der vom Compiler jedoch nicht gemeldet wurde, melden Sie einen Fehler.

Nun zur langen Version. Zunächst einige Hintergrundinformationen zu Warnflaggruppierungen. In Clang (und in begrenztem Umfang auch im GCC) gibt es viele "Warnungsgruppen". Einige, die für diese Diskussion relevant sind:

• Standardmäßig aktiviert: Diese Warnungen sind immer aktiviert, sofern Sie sie nicht ausdrücklich deaktivieren.
• -Wall: Dies sind die Warnungen , dass die Entwickler haben hohe sowohl das Vertrauen in ihrem Wert und eine niedrige Rate falsch-positiver.
• -Wextra: Dies sind Warnungen, von denen angenommen wird, dass sie wertvoll und vernünftig sind (dh sie sind nicht fehlerhaft), aber sie können hohe falsch-positive Raten oder allgemeine philosophische Einwände haben.
• -Weverything: Dies ist eine verrückte Gruppe, die buchstäblich jede Warnung in Clang aktiviert. Verwenden Sie dies nicht für Ihren Code. Es ist ausschließlich für Clang-Entwickler gedacht oder um herauszufinden, welche Warnungen vorhanden sind .

Es gibt zwei Hauptkriterien, die oben erwähnt wurden und die Aufschluss darüber geben, welche Warnungen in Clang angezeigt werden. Der erste ist der potenzielle Wert eines bestimmten Auftretens der Warnung. Dies ist der erwartete Vorteil für den Benutzer (Entwickler), wenn die Warnung ausgelöst wird und ein Problem mit dem Code korrekt identifiziert wird.

Das zweite Kriterium ist die Idee von falsch positiven Berichten. Dies sind Situationen, in denen die Warnung im Code ausgelöst wird, das angegebene potenzielle Problem jedoch aufgrund des Kontexts oder einer anderen Einschränkung des Programms nicht auftritt. Der Code, über den gewarnt wurde, verhält sich tatsächlich korrekt. Dies ist besonders schlimm, wenn die Warnung niemals auf dieses Codemuster abfeuern sollte. Stattdessen führt ein Mangel an der Implementierung der Warnung dazu, dass sie dort ausgelöst wird.

Für Clang-Warnungen muss der Wert in Bezug auf die Korrektheit angegeben werden , nicht in Bezug auf Stil, Geschmack oder Kodierungskonventionen. Dies schränkt die Anzahl der verfügbaren Warnungen ein und schließt häufig angeforderte Warnungen aus, z. B. Warnungen, wenn {}s nicht im gesamten Text einer ifAnweisung verwendet werden. Clang ist auch sehr unverträglich gegenüber falsch positiven Ergebnissen . Im Gegensatz zu den meisten anderen Compilern wird eine unglaubliche Vielzahl von Informationsquellen verwendet, um falsch positive Ergebnisse zu bereinigen, einschließlich der genauen Schreibweise des Konstrukts, des Vorhandenseins oder Fehlens von zusätzlichen () -, Cast- oder sogar Präprozessor-Makros!

Nehmen wir nun einige Warnungen aus der Praxis von Clang und sehen uns an, wie sie kategorisiert sind. Zunächst eine Standard-Ein-Warnung:

% nl x.cc
     1  class C { const int x; };

% clang -fsyntax-only x.cc
x.cc:1:7: warning: class 'C' does not declare any constructor to initialize its non-modifiable members
class C { const int x; };
      ^
x.cc:1:21: note: const member 'x' will never be initialized
class C { const int x; };
                    ^
1 warning generated.

Hier war keine Flagge erforderlich, um diese Warnung zu erhalten. Der Grund dafür ist, dass dieser Code niemals wirklich korrekt ist und der Warnung einen hohen Wert gibt. Die Warnung wird nur für Code ausgelöst, von dem Clang nachweisen kann, dass er in diesen Bereich fällt, und gibt ihm eine Null- Falsch-Positiv- Rate.

% nl x2.cc
     1  int f(int x_) {
     2    int x = x;
     3    return x;
     4  }

% clang -fsyntax-only -Wall x2.cc
x2.cc:2:11: warning: variable 'x' is uninitialized when used within its own initialization [-Wuninitialized]
  int x = x;
      ~   ^
1 warning generated.

Clang benötigt die -WallFlagge für diese Warnung. Der Grund dafür ist, dass es eine nicht triviale Menge an Code gibt, die (für gut oder schlecht) das Codemuster verwendet hat, vor dem wir warnen, um absichtlich einen nicht initialisierten Wert zu erzeugen. Philosophisch sehe ich darin keinen Grund, aber viele andere stimmen dem nicht zu, und die Realität dieses Meinungsunterschieds ist der Auslöser für die Warnung unter der -WallFlagge. Es hat immer noch einen sehr hohen Wert und eine sehr niedrige Falsch-Positiv- Rate, aber auf einigen Codebasen ist es kein Starter.

% nl x3.cc
     1  void g(int x);
     2  void f(int arr[], unsigned int size) {
     3    for (int i = 0; i < size; ++i)
     4      g(arr[i]);
     5  }

% clang -fsyntax-only -Wextra x3.cc
x3.cc:3:21: warning: comparison of integers of different signs: 'int' and 'unsigned int' [-Wsign-compare]
  for (int i = 0; i < size; ++i)
                  ~ ^ ~~~~
1 warning generated.

Diese Warnung erfordert die -WextraFlagge. Der Grund ist, dass es sehr große Codebasen gibt, in denen falsch zugeordnete Vorzeichen bei Vergleichen extrem häufig sind. Während diese Warnung einige Fehler findet, ist die Wahrscheinlichkeit, dass der Code ein Fehler ist, wenn der Benutzer ihn schreibt, im Durchschnitt ziemlich gering. Das Ergebnis ist eine extrem hohe Falsch-Positiv- Rate. Wenn jedoch aufgrund der seltsamen Regeln für die Werbung ein Fehler in einem Programm auftritt, ist es häufig äußerst subtil, diese Warnung zu erstellen, wenn ein Fehler mit einem relativ hohen Wert gekennzeichnet wird . Infolgedessen stellt Clang es zur Verfügung und macht es unter einer Flagge sichtbar.

In der Regel leben Warnungen nicht lange außerhalb der -WextraFlagge. Clang bemüht sich sehr, keine Warnungen zu implementieren, die nicht regelmäßig verwendet und getestet werden. Die zusätzlichen Warnungen, die von aktiviert werden, -Weverythingsind normalerweise Warnungen, die sich in der aktiven Entwicklung oder bei aktiven Fehlern befinden. Entweder werden sie repariert und unter entsprechende Flaggen gesetzt, oder sie sollten entfernt werden.

Nachdem wir nun verstanden haben, wie diese Dinge mit Clang funktionieren, wollen wir versuchen, auf die ursprüngliche Frage zurückzukommen: Welche Warnungen sollten Sie für Ihre Entwicklung aktivieren? Die Antwort ist leider, dass es darauf ankommt. Berücksichtigen Sie die folgenden Fragen, um herauszufinden, welche Warnungen für Ihre Situation am besten geeignet sind.

• Haben Sie die Kontrolle über Ihren gesamten Code oder ist ein Teil davon extern?
• Was sind deine Ziele? Fehler abfangen oder besseren Code schreiben?
• Was ist Ihre falsch-positive Toleranz? Sind Sie bereit, zusätzlichen Code zu schreiben, um Warnungen regelmäßig auszuschalten?

Versuchen Sie in erster Linie nicht, zusätzliche Warnungen einzuschalten, wenn Sie den Code nicht kontrollieren. Seien Sie bereit, einige auszuschalten. Es gibt eine Menge schlechten Codes auf der Welt, und Sie können möglicherweise nicht alles reparieren. Das ist ok. Arbeiten Sie daran, wie Sie sich auf den Code konzentrieren können, den Sie steuern.

Finden Sie als Nächstes heraus, was Sie von Ihren Warnungen erwarten. Dies ist für verschiedene Menschen unterschiedlich. Clang wird versuchen, zu warnen, ohne Optionen für ungeheure Fehler oder Codemuster zu haben, für die wir einen langjährigen Präzedenzfall haben, der darauf hinweist, dass die Fehlerrate extrem hoch ist. Wenn -WallSie diese Option aktivieren, erhalten Sie eine viel aggressivere Reihe von Warnungen, die darauf abzielen, die häufigsten Fehler abzufangen, die Clang-Entwickler im C ++ - Code beobachtet haben. Bei beiden sollte die Falsch-Positiv- Rate jedoch recht niedrig bleiben.

Schließlich, wenn Sie vollkommen bereit sind, * falsch-positive * s an jeder Ecke zum Schweigen zu bringen, dann machen Sie mit -Wextra. Melden Sie Fehler an, wenn Sie Warnungen bemerken, die viele echte Fehler enthalten, die aber dumme oder sinnlose Fehlalarme enthalten. Wir arbeiten ständig daran, Wege zu finden, um mehr und mehr von der vorhandenen Fehlerfindungslogik -Wextrain -Walluns zu bringen, um Fehlalarme zu vermeiden.

Viele werden feststellen, dass keine dieser Optionen für sie genau richtig ist. Bei Google haben wir einige Warnungen -Walldeaktiviert, da ein Großteil des vorhandenen Codes gegen die Warnung verstoßen hat. Wir haben auch einige Warnungen explizit aktiviert, obwohl sie von nicht aktiviert wurden -Wall, da sie für uns einen besonders hohen Wert haben. Ihr Kilometerstand wird variieren, aber wahrscheinlich in ähnlicher Weise variieren. Es kann oft viel besser sein, ein paar wichtige Warnungen zu aktivieren, als alle -Wextra.

Ich würde jeden ermutigen , sich -Wallfür jeden Nicht-Legacy-Code einzuschalten. Für neuen Code sind die Warnungen hier fast immer wertvoll und verbessern die Erfahrung beim Entwickeln von Code. Umgekehrt würde ich jeden ermutigen, keine Flaggen darüber hinaus zu aktivieren -Wextra. Wenn Sie eine Clang Warnung finden , das -Wextra nicht enthalten ist , aber das erweist sich als überhaupt wertvoll für Sie, einfach Fehler melden , und wir können es wahrscheinlich unter setzen -Wextra. Ob Sie eine Teilmenge der Warnungen in explizit aktivieren, -Wextrahängt stark von Ihrem Code, Ihrem Codierungsstil und davon ab, ob es einfacher ist, diese Liste zu pflegen, als alles zu reparieren, was nicht von abgedeckt wird -Wextra.

Von der Liste der Warnungen des OP (die sowohl -Wallals auch enthielten -Wextra) werden nur die folgenden Warnungen von diesen beiden Gruppen nicht abgedeckt (oder standardmäßig aktiviert). Die erste Gruppe hebt hervor, warum es schlecht sein kann, sich zu sehr auf explizite Warnflags zu verlassen: Keine davon ist sogar in Clang implementiert ! Sie werden in der Befehlszeile nur aus Gründen der GCC-Kompatibilität akzeptiert.

• -Wbad-function-cast
• -Wdeclaration-after-statement
• -Wmissing-format-attribute
• -Wmissing-noreturn
• -Wnested-externs
• -Wnewline-eof
• -Wold-style-definition
• -Wredundant-decls
• -Wsequence-point
• -Wstrict-prototypes
• -Wswitch-default

Die nächsten unnötigen Warnungen in der ursprünglichen Liste sind solche, die mit anderen in dieser Liste überflüssig sind:

• -Wformat-nonliteral - Teilmenge von -Wformat=2
• -Wshorten-64-to-32 - Teilmenge von -Wconversion
• -Wsign-conversion - Teilmenge von -Wconversion

Es gibt auch eine Auswahl von Warnungen, die sich kategorisch unterscheiden. Diese befassen sich eher mit Sprachdialektvarianten als mit fehlerhaftem oder nicht fehlerhaftem Code. Mit Ausnahme von -Wwrite-stringssind dies alle Warnungen für von Clang bereitgestellte Spracherweiterungen. Ob Clang vor ihrer Verwendung warnt, hängt von der Verbreitung der Erweiterung ab. Clang strebt die Kompatibilität mit GCC an und erleichtert dies in vielen Fällen durch implizite Spracherweiterungen, die häufig verwendet werden. -Wwrite-stringsWie auf dem OP kommentiert, handelt es sich um ein Kompatibilitätsflag von GCC, das die Programmsemantik tatsächlich ändert. Ich bedaure diese Flagge zutiefst, aber wir müssen sie aufgrund ihres Erbes unterstützen.

• -Wfour-char-constants
• -Wpointer-arith
• -Wwrite-strings

Die verbleibenden Optionen, die potenziell interessante Warnungen ermöglichen, sind folgende:

• -Wcast-align
• -Wconversion
• -Wfloat-equal
• -Wformat=2
• -Wimplicit-atomic-properties
• -Wmissing-declarations
• -Wmissing-prototypes
• -Woverlength-strings
• -Wshadow
• -Wstrict-selector-match
• -Wundeclared-selector
• -Wunreachable-code

Der Grund , dass diese nicht in -Walloder -Wextraist nicht immer klar. Für viele von ihnen, werden sie auf GCC Warnungen tatsächlich basiert ( -Wconversion, -Wshadowusw.) und als solcher Clang versucht GCC Verhalten zu imitieren. Wir zerlegen einige davon langsam in feinkörnigere und nützlichere Warnungen. Diese haben dann eine höhere Wahrscheinlichkeit, es in eine der Warnungsgruppen der obersten Ebene zu schaffen. Dies -Wconversionist jedoch so weit gefasst, dass es auf absehbare Zeit wahrscheinlich seine eigene "oberste" Kategorie bleiben wird. Einige andere Warnungen, die der GCC hat, die aber einen geringen Wert und hohe falsch-positive Quoten haben, könnten in ein ähnliches Niemandsland verbannt werden.

Andere Gründe, warum diese nicht in einem der größeren Buckets enthalten sind, sind einfache Fehler, sehr signifikante falsch-positive Probleme und Warnungen während der Entwicklung. Ich werde nach Fehlern suchen, die ich identifizieren kann. Sie sollten alle irgendwann in eine richtige große Eimerfahne migrieren oder aus Clang entfernt werden.

Ich hoffe, dies verdeutlicht die Warnsituation mit Clang und gibt einen Einblick für diejenigen, die versuchen, eine Reihe von Warnungen für ihre Verwendung oder die Verwendung durch ihr Unternehmen auszuwählen.

Ich benutze Clang nicht, aber ich hoffe, dass es Ihnen nichts ausmacht, auch meine Meinung zu sagen. Ich gehe auch von der maximalen Warnstufe aus (ich nehme an, das ist, was -Wall bedeutet) und behandle Warnungen als Fehler (ich nehme an, das ist, was -Werror bedeutet) und deaktiviere nur die wenigen Warnungen, die nicht viel Sinn machen. Eigentlich ärgere ich mich ziemlich darüber, dass der C # -Compiler bestimmte sehr nützliche Warnungen nicht ausgibt und man spezielle Codeanalyse-Tools ausführen muss, um sie anzuzeigen. Ich mag Warnungen, weil sie mir helfen, kleine Fehler und Bugs in meinem Code zu finden. Ich mag sie so sehr, dass ich, wenn eine Warnung für einen Code ausgegeben wird, von dem ich weiß, dass er korrekt ist, diesen Code ohnehin umgestalte, sodass die Warnung nicht ausgegeben wird, anstatt die Warnung zu deaktivieren, oder --even Schlimmer - lass es erscheinen und ignoriere es. Ich finde Warnungen großartig,

Ich verwende normalerweise die Standardeinstellungen von Xcode für ein neues Projekt. Es bietet eine gute Balance zwischen hilfreich und ärgerlich. Jede spezifische Liste von Warnungen und anderen Compiler-Optionen basiert größtenteils entweder auf persönlichen Vorlieben oder auf den Projektanforderungen. Daher halte ich es nicht für sinnvoll, Ihre Liste zu durchsuchen und für oder gegen bestimmte Warnungen zu argumentieren. Wenn es bei Ihnen funktioniert, großartig. Wenn Sie feststellen, dass ein Fehler aufgetreten ist, den der Compiler möglicherweise erkennt, und Sie in Zukunft Hilfe benötigen, suchen Sie nach einer Compileroption, die Sie davor warnen und aktivieren kann.

Eine Sache, die viele Programmierer befürworten, ist das Aktivieren der Option "Warnungen als Fehler behandeln" (-Werror), um zu verhindern, dass Builds erfolgreich abgeschlossen werden, wenn Warnungen vorliegen.

Ich denke, der beste Beweis dafür, dass die Menschen sich für Warnungen interessieren, ist die Tatsache, dass sie existieren und weit verbreitet sind. Ich bin der festen Überzeugung, dass je mehr Fehler während der Kompilierungszeit abgefangen wurden, desto besser. Wenn dies nicht weit verbreitet wäre, würden alle schwach dynamisch getippte Sprachen verwenden, da ihre Compiler oder Dolmetscher Ihnen viel mehr Spielraum geben. Im Gegenteil, auch in Skriptsprachen ist die Verwendung von strictFlags beliebt. In stark typisierten statischen Sprachen werden -Wall -WerrorWarnungen nicht nur häufig verwendet, sondern häufig auch als so wertvoll empfunden, dass sie noch mehr verlangen. Daher zahlen sie für statische Analysewerkzeuge wie Coverity, deren einziger Zweck darin besteht, Warnungen bereitzustellen .

Das heißt nicht, dass es keine Kritiker gibt. Viele Entwickler sehen Warnungen eher als kurzfristig als als langfristig und versuchen nicht, das zugrunde liegende Problem zu beheben. Daher sehen Sie schönen Code wie diesen Ausschnitt, den ich gestern gefunden habe:

node = node; // Shut up compiler warning

Im Allgemeinen neige ich eher zu -Wall und glaube definitiv daran, auch -Werror mit einzubeziehen. Ein Modul sollte niemals Warnungen erwartet haben. Sie werden schließlich eine weitere Warnung erhalten und diese verpassen. Und das wird derjenige sein, der tatsächlich ein Problem ist.

Es hängt auch davon ab, ob Sie einem neuen oder alten Projekt "-Wall -Werror" hinzufügen. Wenn es neu ist, probieren Sie es aus und fordern Sie Perfektion. Andernfalls werden Sie wahrscheinlich Tage oder Wochen mit Änderungen und Tests verbringen. Ich habe das gerade bei einem älteren, etwas kleinen Projekt gemacht und zwei oder drei Tage damit verbracht, die Warnungen zu entfernen. Ich denke, der Code ist jetzt sauberer.

Mit anderen Worten, probieren Sie es aus und sehen Sie.

Geil