Wie kann man die veraltete Konvertierung von Zeichenfolgenkonstanten in "char *" -Warnungen in GCC beseitigen?

Ich arbeite also an einer außerordentlich großen Codebasis und habe kürzlich ein Upgrade auf gcc 4.3 durchgeführt, das jetzt diese Warnung auslöst:

Warnung: Veraltete Konvertierung von Zeichenfolgenkonstante in 'char *'

Offensichtlich ist der richtige Weg, dies zu beheben, jede Erklärung wie zu finden

char *s = "constant string";

oder Funktionsaufruf wie:

void foo(char *s);
foo("constant string");

und machen sie const charZeiger. Dies würde jedoch bedeuten, mindestens 564 Dateien zu berühren, was zu diesem Zeitpunkt keine Aufgabe ist, die ich ausführen möchte. Das Problem im Moment ist, dass ich mit laufe -werror, also brauche ich eine Möglichkeit, diese Warnungen zu unterdrücken. Wie kann ich das machen?

Ich glaube, dass die Übergabe -Wno-write-stringsan gcc diese Warnung unterdrücken wird.

Alle Funktionen, an die Sie Zeichenfolgenliterale übergeben, "I am a string literal"sollten char const *anstelle von verwendet werden char*.

Wenn Sie etwas reparieren wollen, reparieren Sie es richtig.

Erläuterung:

Sie können keine Zeichenfolgenliterale verwenden, um Zeichenfolgen zu initialisieren, die geändert werden, da sie vom Typ sind const char*. Wegwerfen die Konstantheit , um sie dann zu ändern ist nicht definiertes Verhalten , so dass Sie Ihre kopieren const char*Strings charvon charin dynamisch zugewiesenen char*Strings , um sie zu ändern.

Beispiel:

#include <iostream>

void print(char* ch);

void print(const char* ch) {
    std::cout<<ch;
}

int main() {
    print("Hello");
    return 0;
}

Ich hatte ein ähnliches Problem, ich habe es so gelöst:

#include <string.h>

extern void foo(char* m);

int main() {
    // warning: deprecated conversion from string constant to ‘char*’
    //foo("Hello");

    // no more warning
    char msg[] = "Hello";
    foo(msg);
}

Ist dies ein geeigneter Weg, um dies zu lösen? Ich habe keinen Zugriff darauf foo, um es anzupassen const char*, obwohl das eine bessere Lösung wäre (weil foosich nichts ändert m).

Schauen Sie sich die Unterstützung von gcc für Diagnostic Pragma und die Liste der -W-Warnoptionen an (geändert: neuer Link zu Warnoptionen ).

Für gcc können Sie #pragma warningAnweisungen verwenden, wie hier erläutert .

Wenn es sich um eine aktive Codebasis handelt, möchten Sie die Codebasis möglicherweise trotzdem aktualisieren. Natürlich ist es nicht möglich, die Änderungen manuell durchzuführen, aber ich glaube, dass dieses Problem ein für alle Mal mit einem einzigen sedBefehl gelöst werden kann . Ich habe es jedoch nicht ausprobiert, also nimm das Folgende mit einem Körnchen Salz.

find . -exec sed -E -i .backup -n \
    -e 's/char\s*\*\s*(\w+)\s*= "/char const* \1 = "/g' {} \;

Dies findet möglicherweise nicht alle Stellen (auch wenn Funktionsaufrufe nicht berücksichtigt werden), lindert jedoch das Problem und ermöglicht es, die wenigen verbleibenden Änderungen manuell durchzuführen.

Ich kann den Compiler-Schalter nicht verwenden. Also habe ich das gedreht:

char *setf = tigetstr("setf");

dazu:

char *setf = tigetstr((char *)"setf");

Hier erfahren Sie, wie Sie dies in einer Datei inline tun, damit Sie Ihr Makefile nicht ändern müssen.

// gets rid of annoying "deprecated conversion from string constant blah blah" warning
#pragma GCC diagnostic ignored "-Wwrite-strings"

Sie können dann später ...

#pragma GCC diagnostic pop

Ersetzen

char *str = "hello";

mit

char *str = (char*)"hello";

oder wenn Sie die Funktion aufrufen:

foo("hello");

Ersetzen Sie dies durch

foo((char*) "hello");

Anstatt:

void foo(char *s);
foo("constant string");

Das funktioniert:

void foo(const char s[]);
foo("constant string");

Verwenden Sie in C ++ const_castwie folgt

char* str = const_cast<char*>("Test string");

Test stringist const string. So können Sie lösen:

char str[] = "Test string";

oder:

const char* str = "Test string";
printf(str);

Warum nicht einfach Typ Casting verwenden?

(char*) "test"

Führen Sie eine Typumwandlung von einer konstanten Zeichenfolge zu einem Zeichenzeiger durch, z

char *s = (char *) "constant string";

Ersetzen Sie in C ++:

char *str = "hello";

mit:

std::string str ("hello");

Und wenn Sie es vergleichen wollen:

str.compare("HALLO");

Ich verstehe nicht, wie Sie Ihre Lösung anwenden sollen :( - kalmanIsAGameChanger

Bei der Arbeit mit Arduino Sketch hatte ich eine Funktion, die meine Warnungen verursachte.

Ursprüngliche Funktion: char StrContains (char * str, char * sfind)

Um die Warnungen zu stoppen, habe ich die Konstante vor dem Zeichen und dem Zeichen hinzugefügt.

Geändert: char StrContains (const char * str, const char * sfind).

Alle Warnungen gingen weg.

siehe diese Situation:

typedef struct tagPyTypeObject
{
    PyObject_HEAD;
    char *name;
    PrintFun print;
    AddFun add;
    HashFun hash;
} PyTypeObject;

PyTypeObject PyDict_Type=
{
    PyObject_HEAD_INIT(&PyType_Type),
    "dict",
    dict_print,
    0,
    0
};

Beobachten Sie das Namensfeld, in gcc wird es ohne Vorwarnung kompiliert, aber in g ++ wird es, ich weiß nicht warum.

Sie können auch eine beschreibbare Zeichenfolge aus einer Zeichenfolgenkonstante erstellen, indem Sie aufrufen strdup().

Dieser Code generiert beispielsweise eine Warnung:

putenv("DEBUG=1");

Der folgende Code funktioniert jedoch nicht (er erstellt eine Kopie der Zeichenfolge auf dem Heap, bevor er an übergeben wird putenv):

putenv(strdup("DEBUG=1"));

In diesem Fall (und vielleicht in den meisten anderen Fällen) ist es eine schlechte Idee, die Warnung auszuschalten - sie hat einen Grund. Die andere Alternative (standardmäßig alle Zeichenfolgen beschreibbar zu machen) ist möglicherweise ineffizient.

Hören Sie, was der Compiler Ihnen sagt!

Verwenden Sie einfach die Option -w für g ++

Beispiel:

g ++ -w -o simple.o simple.cpp -lpthread

Denken Sie daran, dass dies nicht die Ablehnung verhindert, sondern das Anzeigen einer Warnmeldung auf dem Terminal verhindert.

Wenn Sie nun wirklich die Ablehnung vermeiden möchten, verwenden Sie das Schlüsselwort const wie folgt:

const char* s="constant string";  

Warum verwenden Sie die -Wno-deprecatedOption nicht, um veraltete Warnmeldungen zu ignorieren?

Das Problem im Moment ist, dass ich mit -Werror laufe

Das ist dein eigentliches Problem, IMO. Sie können einige automatisierte Methoden ausprobieren, um von (char *) zu (const char *) zu wechseln, aber ich würde Geld in sie stecken, nicht nur um zu funktionieren. Für mindestens einen Teil der Arbeit muss ein Mensch beteiligt sein. Ignorieren Sie kurzfristig einfach die Warnung (aber IMO lässt sie eingeschaltet, sonst wird sie nie behoben) und entfernen Sie einfach den Fehler.

Vielen Dank für die Hilfe. Von hier und da kommt diese Lösung. Dies kompiliert sauber. Habe den Code noch nicht getestet. Vielleicht morgen...

const char * timeServer[] = { "pool.ntp.org" }; // 0 - Worldwide 
#define WHICH_NTP            0 // Which NTP server name to use.
...
sendNTPpacket(const_cast<char*>(timeServer[WHICH_NTP])); // send an NTP packet to a server
...
void sendNTPpacket(char* address) { code }

Ich weiß, es gibt nur 1 Element im timeServer-Array. Aber es könnte noch mehr geben. Der Rest wurde vorerst auskommentiert, um Speicherplatz zu sparen.

PyTypeObject PyDict_Type=
{ ...

PyTypeObject PyDict_Type=
{
  PyObject_HEAD_INIT(&PyType_Type),
                     "dict",
                     dict_print,
                     0,
                     0
}; 

Beobachten Sie das Namensfeld, in gcc wird es ohne Vorwarnung kompiliert, aber in g ++ wird es, ich weiß nicht warum.

in gcc (Compiling C), -Wno-write-strings ist standardmäßig aktiv.

in g++ (Compiling C++)-Wwrite-Strings ist standardmäßig aktiv

Deshalb gibt es ein anderes Verhalten. Für uns erzeugt die Verwendung von Makros von Boost_pythonsolche Warnungen. Also verwenden wir -Wno-write-stringsbeim Kompilieren von C ++, da wir immer verwenden-Werror

Deklarieren Sie einen String const, um das Problem zu lösen:

char const*s = "constant string";