¿Cómo deshacerse de las advertencias de conversión obsoleta de constante de cadena a 'char *' en GCC?

Así que estoy trabajando en una base de código extremadamente grande, y recientemente me actualicé a gcc 4.3, que ahora activa esta advertencia:

advertencia: conversión obsoleta de constante de cadena a 'char *'

Obviamente, la forma correcta de solucionar esto es encontrar cada declaración como

char *s = "constant string";

o llamada de función como:

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

y hazlos const charpunteros. Sin embargo, eso significaría tocar 564 archivos, como mínimo, que no es una tarea que deseo realizar en este momento. El problema en este momento es que estoy corriendo -werror, así que necesito alguna forma de sofocar estas advertencias. ¿Cómo puedo hacer eso?

Creo que pasar -Wno-write-stringsa gcc suprimirá esta advertencia.

Cualquier función en la que pase literales de cadena "I am a string literal"debe usar char const *como tipo en lugar de char*.

Si vas a arreglar algo, arréglalo bien.

Explicación:

No puede usar literales de cadena para inicializar cadenas que se modificarán, porque son de tipo const char*. Desechar los constness modificar más adelante ellos es un comportamiento indefinido , por lo que tiene que copiar sus const char*cadenas charpor chardentro asignados dinámicamente char*las cadenas con el fin de modificarlos.

Ejemplo:

#include <iostream>

void print(char* ch);

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

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

Tuve un problema similar, lo resolví así:

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

¿Es esta una forma apropiada de resolver esto? No tengo acceso para fooadaptarlo para aceptar const char*, aunque esa sería una mejor solución (porque foono cambia m).

Consulte el soporte de pragma de diagnóstico de gcc y la lista de opciones de advertencia -W (modificado: nuevo enlace a opciones de advertencia ).

Para gcc, puede usar #pragma warningdirectivas como se explica aquí .

Si se trata de una base de código activa, es posible que aún desee actualizar la base de código. Por supuesto, realizar los cambios manualmente no es factible, pero creo que este problema podría resolverse de una vez por todas con un solo sedcomando. Sin embargo, no lo he probado, así que toma lo siguiente con un grano de sal.

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

Es posible que esto no encuentre todos los lugares (incluso sin considerar las llamadas a funciones), pero aliviará el problema y permitirá realizar los pocos cambios restantes manualmente.

No puedo usar el interruptor del compilador. Entonces he convertido esto:

char *setf = tigetstr("setf");

a esto:

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

Aquí se explica cómo hacerlo en línea en un archivo, para que no tenga que modificar su Makefile.

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

Luego puedes ...

#pragma GCC diagnostic pop

Reemplazar

char *str = "hello";

con

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

o si está llamando a la función:

foo("hello");

reemplazar esto con

foo((char*) "hello");

En vez de:

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

Esto funciona:

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

En C ++, use lo const_castque se muestra a continuación

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

Test stringes una cadena constante. Entonces puedes resolver así:

char str[] = "Test string";

o:

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

¿Por qué no solo usar el tipo de fundición?

(char*) "test"

Realice la conversión de texto de cadena constante a puntero de caracteres, es decir

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

En C ++, Reemplace:

char *str = "hello";

con:

std::string str ("hello");

Y si quieres compararlo:

str.compare("HALLO");

No entiendo cómo aplicar su solución :( - kalmanIsAGameChanger

Trabajando con Arduino Sketch, tenía una función que causaba mis advertencias.

Función original: char StrContains (char * str, char * sfind)

Para detener las advertencias, agregué el const delante del char * str y el char * sfind.

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

Todas las advertencias se fueron.

ver esta situación:

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

mire el campo de nombre, en gcc se compila sin advertencia, pero en g ++ lo hará, no sé por qué.

También puede crear una cadena de escritura desde una constante de cadena llamando strdup().

Por ejemplo, este código genera una advertencia:

putenv("DEBUG=1");

Sin embargo, el siguiente código no lo hace (hace una copia de la cadena en el montón antes de pasarlo putenv):

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

En este caso (y quizás en la mayoría de los demás), desactivar la advertencia es una mala idea, está ahí por una razón. La otra alternativa (hacer que todas las cadenas se puedan escribir de manera predeterminada) es potencialmente ineficiente.

¡Escucha lo que te dice el compilador!

solo usa la opción -w para g ++

ejemplo:

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

Recuerde que esto no evita la desaprobación, sino que evita mostrar mensajes de advertencia en el terminal.

Ahora, si realmente desea evitar la degradación, use la palabra clave const como esta:

const char* s="constant string";  

¿Por qué no utiliza la -Wno-deprecatedopción para ignorar los mensajes de advertencia obsoletos?

El problema ahora es que estoy ejecutando con -Werror

Este es tu verdadero problema, OMI. Puede probar algunas formas automatizadas de pasar de (char *) a (const char *), pero yo pondría dinero en ellas no solo trabajando. Tendrá que involucrar a un humano para al menos parte del trabajo. A corto plazo, simplemente ignore la advertencia (pero IMO la deja activada, o nunca se solucionará) y simplemente elimine -Werror.

Gracias por toda la ayuda. Escogiendo de aquí para allá viene esta solución. Esto compila limpio. No he probado el código todavía. Mañana tal vez...

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 sé, solo hay 1 elemento en la matriz timeServer. Pero podría haber más. El resto fueron comentados por ahora para ahorrar memoria.

PyTypeObject PyDict_Type=
{ ...

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

mire el campo de nombre, en gcc se compila sin advertencia, pero en g ++ lo hará, no sé por qué.

en gcc (Compiling C), -Wno-write-strings está activo por defecto.

en g++ (Compiling C++)-Wwrite-strings está activo por defecto

Por eso hay un comportamiento diferente. Para nosotros, el uso de macros de Boost_pythongenera tales advertencias. Entonces usamos -Wno-write-stringscuando compilamos C ++ ya que siempre usamos-Werror

Declarar cadena como a constresolverá el problema:

char const*s = "constant string";