Pedantic gcc Warnung: Typ Qualifier auf Funktion Rückgabetyp

Question

Als ich meinen C++ Code mit GCC 4.3 zum ersten Mal kompiliert habe (nachdem ich ihn ohne Warnungen auf 4.1, 4.0, 3.4 mit den -Wall -Wextra Optionen kompiliert habe), bin ich plötzlich gekommen eine Reihe von Fehlern der Form warning: type qualifiers ignored on function return type.

Betrachten temp.cpp:

class Something 
{ 
public: 
    const int getConstThing() const { 
     return _cMyInt; 
    } 
    const int getNonconstThing() const { 
     return _myInt; 
    } 

    const int& getConstReference() const { 
     return _myInt; 
    } 
    int& getNonconstReference() { 
     return _myInt; 
    } 

    void setInt(const int newValue) { 
     _myInt = newValue; 
    } 

    Something() : _cMyInt(3) { 
     _myInt = 2; 
    } 
private: 
    const int _cMyInt; 
    int _myInt; 
}; 

g++ temp.cpp -Wextra -c -o blah.o Laufen:

temp.cpp:4: warning: type qualifiers ignored on function return type 
temp.cpp:7: warning: type qualifiers ignored on function return type 

Kann mir jemand sagen, was ich falsch mache, dass die C++ Standard verletzt? Ich nehme an, dass bei der Rückgabe nach Wert der führende const überflüssig ist, aber ich habe Probleme zu verstehen, warum es notwendig ist, eine Warnung damit zu generieren. Gibt es noch andere Orte, wo ich die Const verlassen sollte?

Answer 1

Es verletzt nicht den Standard. Deshalb sind sie Warnungen und nicht Fehler.

Und in der Tat hast du Recht - die führende const ist überflüssig. Der Compiler warnt Sie, weil Sie Code hinzugefügt haben, der unter anderen Umständen etwas bedeuten könnte, aber unter diesen Umständen bedeutet das nichts, und er möchte sicherstellen, dass Sie später nicht enttäuscht werden, wenn sich Ihre Rückgabewerte als veränderbar herausstellen.

Answer 2

Ich habe diese Warnung beim Kompilieren von Code gefunden, der Boost.ProgramOptions verwendet. Ich benutze -Werror, so dass die Warnung mein Build tötete, aber weil die Quelle der Warnung in den Tiefen von Boost war, konnte ich sie nicht loswerden, indem ich meinen Code änderte.

Nach viel Graben fand ich die Compiler-Option, die die Warnung deaktiviert:

-Wno-ignored-qualifiers 

Hoffnung, das hilft.

Answer 3

Scott Meyers wies darauf hin, dass es ziemlich guten Grund gibt, warum jemand const Werte zurückgeben möchte. Hier ist ein Beispiel:

int some_calculation(int a, int b) { int res = 0; /* ... */ return res; } 

/* Test if the result of the calculation equals 40.*/ 
if (some_calculation(3,20) = 40) 
{ 

} 

Siehst du, was ich falsch gemacht habe? Dieser Code ist absolut korrekt und sollte kompiliert werden. Das Problem besteht darin, dass der Compiler nicht verstanden hat, dass Sie vergleichen möchten, anstatt den Wert 40 zuzuweisen.

Mit einem const Rückgabewert wird das obige Beispiel nicht kompiliert. Nun, zumindest wenn der Compiler das const Schlüsselwort nicht verwerfen wird.

Answer 4

Mit diesen

struct Foo { Foo(int) {} operator bool() { return true; } };

und dass

Foo some_calculation(int a, int b) { Foo result(a + b); /*...*/ return result; }

das Beispiel

if (some_calculation(3, 20) = 40) { /*...*/ }

ohne eine Warnung erstellt. Natürlich ist das selten. Aber ist es nicht richtig, Leuten die Möglichkeit zu geben, etwas falsch zu machen? Und mit der Erwartung, dass Menschen Dinge versuchen, die falsch sind, sollte der Rückgabetyp const genannt werden. Und: g ++ warnt davor, den Klassifikator zu ignorieren, ignoriert ihn aber nicht. Ich denke, die Warnung bezieht sich auf Benutzer, die die Kopie nehmen und die const-Klassifizierer auf ihrer Kopie ignorieren. Aber das sollte keine Warnung sein, denn das ist absolut korrektes Verhalten. Und es macht Sinn, dies zu tun.

Answer 5

Sollte -pedantisch nur die strikte Einhaltung des ISO-Standards erlauben? Je nach -std = natürlich ...

Answer 6

Diese Warnung ist auch nützlich, um Verwirrung zu vermeiden, wenn Funktionen erklären Zeiger auf Objekte zurückkehren, das modifiziert werden soll:

// "warning: type qualifiers ignored on function return type" 
// as the pointer is copied. 
Foo* const bar(); 

// correct: 
const Foo* bar(); 

Answer 7

nur einen konstanten Wert zurückkehrend Sinn macht, wenn Sie geben eine Referenz oder einen Zeiger zurück (in diesem Fall Zeiger auf Konstante und nicht auf einen konstanten Zeiger), da der Aufrufer den referenzierten (auf) Wert ändern kann.

Ein weiterer Kommentar über den Code nicht zu Ihrer Frage: Ich denke, es ist besser, statt

int& getNonconstReference() { 
    return _myInt; 
} 

einen Setter zu verwenden, die werden sollte:

void setMyInt(int n) { 
    _myInt = n; 
} 

Darüber hinaus ist es nutzlos zu Gibt einen const-Verweis auf einen int zurück. Es macht Sinn für ein größeres Objekt, dessen Kopie oder Umzug teurer ist.

Answer 8

Es gibt einen Unterschied zwischen const bei einem Basistyp-Ergebnis, bei dem es ignoriert wird, und const bei einem Klassentyp-Ergebnis, bei dem es im Allgemeinen Schaden anrichtet. Diese

namespace i { 
    auto f() -> int const { return 42; } 
    void g(int&&) {} 
} 

namespace s { 
    struct S {}; 
    auto f() -> S const { return {}; } 
    auto g(S&& ) {} 
} 

auto main() -> int 
{ 
    { using namespace i; g(f()); } // OK 
    { using namespace s; g(f()); } // !The `const` prevents this. 
} 

ist, warum die Compiler im ersten Fall warnen: es ist ein Sonderfall, die nicht tun, was man naiverweise erwarten konnte.

Für die moderne Programmierung wäre es IMHO nett auch mit einer Warnung über const auf Klassenergebnis, da es Bewegungssemantik verbietet; eine ziemlich hohe Kosten für den kleinen Vorteil, den man sich vorgestellt hatte.