Come sbarazzarsi degli avvisi `conversione obsoleta da costante di stringa a 'char *'` in GCC?

Quindi sto lavorando su una base di codice estremamente grande e recentemente aggiornato a gcc 4.3, che ora attiva questo avviso:

avviso: conversione obsoleta dalla costante di stringa in 'char *'

Ovviamente, il modo corretto per risolvere questo problema è trovare ogni dichiarazione simile

char *s = "constant string";

o chiamata di funzione come:

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

e renderli const charpuntatori. Tuttavia, ciò significherebbe toccare almeno 564 file, il che non è un compito che desidero svolgere in questo momento. Il problema in questo momento è che sto correndo -werror, quindi ho bisogno di un modo per soffocare questi avvisi. Come lo posso fare?

Credo che passare -Wno-write-stringsa gcc eliminerà questo avviso.

Qualsiasi funzione in cui passi letterali stringa "I am a string literal"dovrebbe usare char const *come tipo anziché char*.

Se hai intenzione di riparare qualcosa, correggilo nel modo giusto.

Spiegazione:

Non è possibile utilizzare valori letterali di stringa per inizializzare le stringhe che verranno modificate, poiché sono di tipo const char*. Casting via la costanza per modificarle in seguito è un comportamento indefinito , quindi bisogna copiare i const char*fili charda charin allocati dinamicamente char*stringhe al fine di modificarli.

Esempio:

#include <iostream>

void print(char* ch);

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

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

Ho avuto un problema simile, l'ho risolto in questo modo:

#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);
}

È un modo appropriato di risolverlo? Non ho accesso ad fooadattarlo per accettarlo const char*, anche se sarebbe una soluzione migliore (perché foonon cambia m).

Controlla il supporto pragma diagnostico di gcc e l'elenco delle opzioni di avviso -W (modificato: nuovo collegamento alle opzioni di avviso ).

Per gcc, puoi usare le #pragma warningdirettive come spiegato qui .

Se è una base di codice attiva, potresti comunque voler aggiornare la base di codice. Ovviamente, eseguire le modifiche manualmente non è possibile, ma credo che questo problema possa essere risolto una volta per tutte con un singolo sedcomando. Non l'ho provato, comunque, quindi prendi quanto segue con un granello di sale.

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

Questo potrebbe non trovare tutti i posti (anche senza considerare le chiamate di funzione) ma alleverebbe il problema e consentirebbe di eseguire manualmente le poche modifiche rimanenti.

Non riesco a usare l'interruttore del compilatore. Quindi ho girato questo:

char *setf = tigetstr("setf");

a questo:

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

Ecco come farlo in linea in un file, quindi non devi modificare il tuo Makefile.

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

È quindi possibile in seguito ...

#pragma GCC diagnostic pop

Sostituire

char *str = "hello";

con

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

o se stai chiamando in funzione:

foo("hello");

sostituirlo con

foo((char*) "hello");

Invece di:

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

Questo funziona:

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

In C ++, utilizzare const_castcome di seguito

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

Test stringè una stringa const. Quindi puoi risolvere in questo modo:

char str[] = "Test string";

o:

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

Perché non usare solo il tipo casting?

(char*) "test"

Esegui la tipografia da stringa costante a puntatore char, ad es

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

In C ++, sostituisci:

char *str = "hello";

con:

std::string str ("hello");

E se vuoi confrontarlo:

str.compare("HALLO");

Non capisco come applicare la tua soluzione :( - kalmanIsAGameChanger

Lavorando con Arduino Sketch, avevo una funzione che causava i miei avvertimenti.

Funzione originale: char StrContains (char * str, char * sfind)

Per interrompere gli avvertimenti ho aggiunto la const davanti al carattere * str e al carattere * sfind.

Modificato: char StrContains (const char * str, const char * sfind).

Tutti gli avvertimenti sono andati via.

vedi questa situazione:

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
};

guarda il campo del nome, in gcc si compila senza preavviso, ma in g ++ lo farà, non so perché.

Puoi anche creare una stringa scrivibile da una costante di stringa chiamando strdup().

Ad esempio, questo codice genera un avviso:

putenv("DEBUG=1");

Tuttavia, il seguente codice non lo fa (crea una copia della stringa sull'heap prima di passarla a putenv):

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

In questo caso (e forse nella maggior parte degli altri), disattivare l'avviso è una cattiva idea: è lì per un motivo. L'altra alternativa (rendere tutte le stringhe scrivibili per impostazione predefinita) è potenzialmente inefficiente.

Ascolta cosa ti sta dicendo il compilatore!

basta usare l'opzione -w per g ++

esempio:

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

Ricorda che questo non evita la deprecazione, ma impedisce di mostrare messaggi di avviso sul terminale.

Ora se vuoi davvero evitare la deprecazione usa la parola chiave const in questo modo:

const char* s="constant string";  

Perché non usi l' -Wno-deprecatedopzione per ignorare i messaggi di avviso obsoleti?

Il problema in questo momento è che sto correndo con -Werror

Questo è il tuo vero problema, IMO. Puoi provare alcuni modi automatizzati di passare da (char *) a (const char *) ma vorrei mettere soldi su di loro non solo lavorando. Dovrai coinvolgere un essere umano per almeno parte del lavoro. A breve termine, basta ignorare l'avvertimento (ma l'IMO lo lascia attivo o non verrà mai risolto) e rimuovere semplicemente -Werror.

Grazie a tutti per l'aiuto. Scegliere da qui e là arriva questa soluzione. Questo compila pulito. Non ho ancora testato il codice. Forse domani...

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 }

Lo so, c'è solo 1 oggetto nell'array timeServer. Ma potrebbe essercene di più. Il resto è stato commentato per ora per risparmiare memoria.

PyTypeObject PyDict_Type=
{ ...

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

guarda il campo del nome, in gcc si compila senza preavviso, ma in g ++ lo farà, non so perché.

in gcc (Compiling C), -Wno-write-strings è attivo per impostazione predefinita.

in g++ (Compiling C++)-Wwrite-strings è attivo per impostazione predefinita

Questo è il motivo per cui esiste un comportamento diverso. Per noi l'utilizzo di macro di Boost_pythongenera tali avvisi. Quindi usiamo -Wno-write-stringsquando compiliamo C ++ poiché usiamo sempre-Werror

Dichiarare la stringa come constrisolverà il problema:

char const*s = "constant string";