Deaktivieren g++ "Hinweis: die Kandidaten.." compiler-Meldung

Viele Male, wenn ich zum Beispiel etwas mit einem Tippfehler oder eine andere Eingabe nicht übereinstimmen, ich bekomme die standard-Fehlermeldung "Fehler: no match for 'functionname' in ... " - Fehler. Das ist großartig. Dann, vor allem im Fall von überladen von Funktionen und Operatoren, g++ geht auf und Liste wie 10 Seiten von Kandidaten, die sind einfach nur scheusslich und massive template-Definitionen.

Die Fehlermeldung ist toll, aber gibt es eine Möglichkeit zum deaktivieren von darauf hindeutet, sonstige Funktionen Varianten?

Warten Sie, wollen Sie die Fehlermeldung an, die weniger Informationen?
Die Funktion Definitionen schlägt er versteckt hinter 10 Schichten templating (vor allem mit boost) und machen es sehr viel schwieriger zu finden, wo der compiler tatsächlich identifiziert die Zeile mit dem Fehler. Ich will es mir nicht sagen, wo der Fehler war und was falsch war, aber ich weiß nicht wirklich brauchen, es zu schlagen, wie es zu beheben.
Rohr es durch grep, nur Spiel auf Linien, die 'Fehler:' in Ihnen? FWIW meine Entwicklungsumgebung hat 'Sprung in die Zeile mit dem Fehler' als eine Funktion, die als zusätzlichen bonus lässt die Spitze der Liste der Kandidaten zeigt auf dem Bildschirm.
verwenden Sie klammerten. Es ist viel schöner Fehlermeldungen.
clang++ wird nicht helfen, hier bietet es -fshow-candidates=<value> aber das argument kann nur best oder all zB nicht none
Hilfreich können Informationen weniger hilfreich als keine Informationen, vor allem, wenn Sie brauchen, um einen Bildlauf durch Seiten von sich wiederholenden text, nur um zu versuchen, um herauszufinden, was der tatsächliche Fehler ist.
Wenn Sie möchten, um zu sehen, eine besonders tückische Instanz dieser, versuchen boost::variant<bool, int> value; std::ifstream input("filename.txt"); input >> value; Produziert über 50k der output des GCC 5.3.1.

InformationsquelleAutor sshannin | 2012-07-03

c++g++

14

Soweit ich weiß, gibt es keine compilation-flag im GCC zu deaktivieren, die vorgeschlagenen Kandidaten im Falle der mehrdeutigen Funktion aufruft.

Ihre einzige Hoffnung ist vielleicht der patch GCC Quellcode.

Graben in es (version: 4.7.1), ich habe gefunden, was erscheint in der entsprechenden Funktion im gcc/cp/pt.c:
```
void
print_candidates(tree fns)
{
  const char *str = NULL;
  print_candidates_1 (fns, false, &str);
  gcc_assert (str == NULL);
}
```
Als eine Vermutung, ich denke, dass Sie nur brauchen, um kommentieren Sie die Funktion Körper.
- +1 für den Doppel-LOL. ich dachte zuerst, es war nur eine Zunge-in-Wange Antworten. dann merkte ich, dass mit gcc-es ist gemeinsamen zu bauen, der compiler aus dem Quelltext, und auf einmal wusste ich, dass! das einzige, was, das verwirrt mich jetzt, ist die scheinbare moderne C/C++ - Funktion Kopf. soweit ich mich erinnere (aber ich kann falsch sein) es verwendet werden, um alte K&R C-syntax überall?
- Es war das erste mal schaute ich auf die GCC-Codebasis und es ist wahrscheinlich, zu reinigen, für ein Projekt dieser Größe. Für die K&R-C-syntax, ich bin 10 Jahre zu jung, um einmal wissen, was es ist 🙂
- ja! Der code entwickelt, eine Menge, einige C++ - features sind auch erlaubt seit Mai 2010. Und ich Stimme zu, dass die code-Basis ist eigentlich erstaunlich klar!
- Ja, ich dachte an patchen, und dann das Umschalten zwischen gepatchten und ungepatchten je nachdem, ob ich möchte, dass alle Durcheinander.
- Hmmm, warum nicht stattdessen fügen Sie einfach Ihre eigene option in der gepatchten version? Sollte nicht so schwer sein, und vermeiden Sie ständige Wechsel Compiler.
- Es ist machbar, aber der patch wird nicht 5 Zeilen lang mehr
- Wahr. vielleicht etwas mit der community teilen dann? Wenn ich einen moment Zeit haben, ich könnte selbst hinein schauen.
- Es scheint, dass es nur ein paar Zeilen, nachdem alle. Es erfordert lediglich Anpassungen an gcc/c-family/c.opt und print_candidates Funktion. Derzeit kann ich nicht bestätigen, dass es funktioniert, weil noch original-gcc compilieren zu auf meinem Rechner, und ich habe keine Zeit, es zu beheben.
- Sie wahrscheinlich wollen auch patch nennen.c für die nicht-Vorlage Fällen finden Sie unter meine Antwort für einen patch
InformationsquelleAutor Gigi
11

Meine Antwort ist nicht so cool wie ein patch. Wenn Sie möchten, eine weniger ausführliche Fehlermeldung, das script wird entfernen Sie die hässlichen code, und lassen Sie einfach die Nummer der Zeile, für die Kandidaten.
```
g++ test.cc 2>&1 | sed 's/^$[^ ]*:[0-9]*: note$:.*/\1/'
```
So, es kann eingesetzt werden in ein Skript wie dieses:
```
#!/bin/bash
GXX=/usr/bin/g++
ARGS=()
i=0
show_notes=yes
for arg in "$@" ; do
    if [ "$arg" = "-fterse-notes" ] ; then
        show_notes=no
    elif [ "$arg" = "-fno-terse-notes" ] ; then
        show_notes=yes
    else
        ARGS[$i]="$arg"
    fi
    i=$[i+1]
done
if [ $show_notes = yes ] ; then
    exec ${GXX} "${ARGS[@]}"
else
    exec ${GXX} "${ARGS[@]}" 2>&1 | sed 's/^$[^ ]*:[0-9]*: note$:.*/\1/'
fi
```
Wenn der name dieses Skript ist g++ und in Ihrem Weg, es sollte so arbeiten, als ob Sie Hinzugefügt haben, eine Kommandozeilen-option namens -fterse-notes.
- Sicherlich möchten Sie nur Inkrement $i in dem ersten 'else'?
- Ich bin eigentlich der Bildung einer neuen argument-Liste ablegen vorkommen -fterse-notes und -fno-terse-notes. bash scheint zu behandeln, was ich schrieb, okay, aber vielleicht die, die technisch korrekte Umsetzung wäre nur Inkrement innerhalb else Klausel, nach der ARGS[$i]="$arg" - Anweisung.
InformationsquelleAutor jxh

Tut -Wfatal-errors tun, was Sie wollen?

Hört es alle Fehler nach der ersten, welche ist nicht das gleiche wie einfach unterdrückt Kandidat-Funktion-Notizen, aber es reduziert die Produktion deutlich:

$ cat a.cc
void f() { }
void f(int) { }
void f(char) { }

int main()
{
  f((void*)0);
}
$ g++ a.cc
a.cc: In function ‘int main()’:
a.cc:7: error: call of overloaded ‘f(void*)’ is ambiguous
a.cc:2: note: candidates are: void f(int) <near match>
a.cc:3: note:                 void f(char) <near match>
$ g++ a.cc -Wfatal-errors
a.cc: In function ‘int main()’:
a.cc:7: error: call of overloaded ‘f(void*)’ is ambiguous
compilation terminated due to -Wfatal-errors.

Oder, wenn Sie wollte, patch, GCC, fügt diese ein -fno-candidate-functions Schalter:

--- gcc/c-family/c.opt.orig 2012-07-11 16:37:29.373417154 +0000
+++ gcc/c-family/c.opt      2012-07-11 17:09:47.340418384 +0000
@@ -752,6 +752,10 @@
 fbuiltin-
 C ObjC C++ ObjC++ Joined

+fcandidate-functions
+C++ ObjC++ Var(flag_candidates) Init(1)
+-fno-candidate-functions Do not print candidate functions when overload resolution fails
+
 fcheck-new
 C++ ObjC++ Var(flag_check_new)
 Check the return value of new
--- gcc/cp/call.c.orig      2012-07-11 17:08:34.186424089 +0000
+++ gcc/cp/call.c   2012-07-11 17:09:51.843444951 +0000
@@ -3317,6 +3317,9 @@
   for (n_candidates = 0, cand1 = candidates; cand1; cand1 = cand1->next)
     n_candidates++;

+  if (!flag_candidates)
+    return;
+
   inform_n (loc, n_candidates, "candidate is:", "candidates are:");
   for (; candidates; candidates = candidates->next)
     print_z_candidate (loc, NULL, candidates);
--- gcc/cp/pt.c.orig        2012-07-11 16:37:35.658636650 +0000
+++ gcc/cp/pt.c     2012-07-11 17:10:20.910435942 +0000
@@ -1751,9 +1751,12 @@
 void
 print_candidates (tree fns)
 {
-  const char *str = NULL;
-  print_candidates_1 (fns, false, &str);
-  gcc_assert (str == NULL);
+  if (flag_candidates)
+    {
+      const char *str = NULL;
+      print_candidates_1 (fns, false, &str);
+      gcc_assert (str == NULL);
+    }
 }

 /* Returns the template (one of the functions given by TEMPLATE_ID)

InformationsquelleAutor Jonathan Wakely

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.