Como se livrar de avisos de `conversão obsoleta da constante de cadeia de caracteres para 'char *' 'no GCC?

Então, eu estou trabalhando em uma base de código extremamente grande e atualizei recentemente para o gcc 4.3, que agora aciona este aviso:

aviso: conversão descontinuada da constante de cadeia para 'char *'

Obviamente, a maneira correta de corrigir isso é encontrar todas as declarações como

char *s = "constant string";

ou chamada de função como:

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

e torná-los const charponteiros. No entanto, isso significaria tocar no mínimo 564 arquivos, o que não é uma tarefa que desejo executar neste momento. O problema agora é que estou enfrentando -werror, por isso preciso de alguma maneira de reprimir esses avisos. Como eu posso fazer isso?

Acredito que -Wno-write-stringsa passagem para o gcc suprimirá esse aviso.

Quaisquer funções nas quais você passa literais de seqüência de caracteres "I am a string literal"devem ser usadas char const *como o tipo em vez de char*.

Se você estiver consertando algo, conserte certo.

Explicação:

Você não pode usar literais de cadeia para inicializar cadeias que serão modificadas, porque são do tipo const char*. Erradicação dos constness para modificá-los mais tarde é um comportamento indefinido , então você tem que copiar suas const char*cordas charpor charem alocação dinâmica char*cordas, a fim de modificá-los.

Exemplo:

#include <iostream>

void print(char* ch);

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

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

Eu tive um problema semelhante, resolvi-o assim:

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

Esta é uma maneira apropriada de resolver isso? Não tenho acesso para fooadaptá-lo para aceitar const char*, embora isso seria uma solução melhor (porque foonão muda m).

Confira o suporte ao Diagnostic Pragma do gcc e a lista de opções de aviso -W (alterada: novo link para opções de aviso ).

Para o gcc, você pode usar #pragma warningdiretivas como explicadas aqui .

Se for uma base de código ativa, você ainda poderá atualizar a base de código. Obviamente, executar as alterações manualmente não é viável, mas acredito que esse problema possa ser resolvido de uma vez por todas por um único sedcomando. Eu não tentei, no entanto, então faça o seguinte com um grão de sal.

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

Isso pode não encontrar todos os locais (mesmo sem considerar as chamadas de função), mas aliviaria o problema e tornaria possível executar as poucas alterações restantes manualmente.

Não consigo usar a opção de compilador. Então eu virei isso:

char *setf = tigetstr("setf");

para isso:

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

Aqui está como fazer isso em linha em um arquivo, para que você não precise modificar o Makefile.

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

Você pode depois ...

#pragma GCC diagnostic pop

Substituir

char *str = "hello";

com

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

ou se você estiver chamando na função:

foo("hello");

substitua isso por

foo((char*) "hello");

Ao invés de:

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

Isso funciona:

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

Em C ++, use o const_castcomo abaixo

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

Test stringé const string. Então você pode resolver assim:

char str[] = "Test string";

ou:

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

Por que não usar apenas conversão de tipo?

(char*) "test"

Faça a conversão de tipos de letra constante para ponteiro char, ou seja,

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

Em C ++, substitua:

char *str = "hello";

com:

std::string str ("hello");

E se você quiser compará-lo:

str.compare("HALLO");

Não entendo como aplicar sua solução :( - kalmanIsAGameChanger

Trabalhando com o Arduino Sketch, eu tinha uma função causando meus avisos.

Função original: char StrContains (char * str, char * sfind)

Para interromper os avisos, adicionei o const na frente do char * str e do char * sfind.

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

Todos os avisos foram embora.

veja esta situação:

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

observe o campo name, no gcc ele compila sem aviso, mas no g ++ ele vai, não sei por quê.

Você também pode criar uma sequência de caracteres gravável a partir de uma constante de sequência chamando strdup().

Por exemplo, este código gera um aviso:

putenv("DEBUG=1");

No entanto, o código a seguir não faz (ele faz uma cópia da sequência na pilha antes de passá-la para putenv):

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

Nesse caso (e talvez na maioria dos outros), desligar o aviso é uma má idéia - existe por um motivo. A outra alternativa (tornar todas as seqüências de caracteres graváveis ​​por padrão) é potencialmente ineficiente.

Ouça o que o compilador está dizendo!

basta usar a opção -w para g ++

exemplo:

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

Lembre-se de que isso não evita a descontinuação, mas evita a exibição de uma mensagem de aviso no terminal.

Agora, se você realmente deseja evitar a descontinuação, use a palavra-chave const como esta:

const char* s="constant string";  

Por que você não usa a -Wno-deprecatedopção para ignorar mensagens de aviso obsoletas?

O problema agora é que estou executando com -Werror

Este é seu verdadeiro problema, IMO. Você pode tentar algumas maneiras automatizadas de passar de (char *) para (const char *), mas eu colocaria dinheiro nelas não apenas trabalhando. Você terá que ter um humano envolvido por pelo menos parte do trabalho. No curto prazo, ignore o aviso (mas o IMO o deixe ativado ou ele nunca será corrigido) e remova o erro -Werror.

Obrigado a todos pela ajuda. Escolhendo daqui e de lá vem esta solução. Isso compila limpo. Ainda não testei o código. Talvez amanhã...

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 }

Eu sei, há apenas 1 item na matriz timeServer. Mas poderia haver mais. O restante foi comentado por enquanto para economizar memória.

PyTypeObject PyDict_Type=
{ ...

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

observe o campo name, no gcc ele compila sem aviso, mas no g ++ ele vai, não sei por quê.

em gcc (Compiling C), -Wno-write-strings está ativo por padrão.

em g++ (Compiling C++)-Wwrite-strings está ativo por padrão

É por isso que existe um comportamento diferente. Para nós, usar macros de Boost_pythongera esses avisos. Então, usamos -Wno-write-stringsao compilar C ++, pois sempre usamos-Werror

Declare a string como a constresolverá o problema:

char const*s = "constant string";