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

Question

así que estoy trabajando en una base de código excesivamente grande, y recientemente actualizado a gcc 4.3, que ahora activa esta advertencia:

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

obviamente, la forma correcta de solucionar este problema es encontrar cada declaración como

char *s = "constant string"; 

o llamada de función como:

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

y hacerlos const char punteros. Sin embargo, eso significaría tocar 564 archivos, como mínimo, lo cual no es una tarea que desee realizar en este momento. El problema ahora mismo es que me estoy ejecutando con -werror, así que necesito alguna manera de reprimir estas advertencias. ¿Cómo puedo hacer eso?

Answer 1

creo que pasa a -Wno-write-strings gcc suprimir esta advertencia.

Answer 2

Salida Diagnostic Pragma apoyo de gcc, y la lista de -W warning options (cambiado: new link to warning options).

Para gcc, puede usar las directivas #pragma warning como se explica en here.

Answer 3

Si se trata de una base de código activo, 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 único comando sed. No lo he probado, así que tome 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' {} \; 

Esto podría no encontrar todos los lugares (incluso sin considerar las llamadas de función), pero podría aliviar el problema y hacer posible la realización de los pocos cambios restantes manualmente.

Answer 4

El problema ahora es que estoy corriendo con -Werror

Este es el verdadero problema, la OMI. Puede probar algunas formas automáticas de pasar de (char *) a (const char *) pero les pondré dinero, no solo trabajando. Tendrás que involucrar a un ser humano para al menos parte del trabajo. A corto plazo, simplemente ignore la advertencia (pero IMO la deja encendida, o nunca se arreglará) y simplemente elimine el -Werror.

Answer 5

¿Por qué no se utiliza la opción -Wno-deprecated hacer caso omiso de los mensajes de advertencia en desuso?

Answer 6

tuve un problema similar, he resuelto de esta manera:

#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 adecuada de resolver esto? No tengo acceso a foo para adaptarla a aceptar const char*, aunque eso sería una mejor solución (porque no cambia foom).

Answer 7

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

Por ejemplo, este código genera una advertencia:

putenv("DEBUG=1"); 

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

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

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

¡Escucha lo que el compilador te está diciendo!

Answer 8

No puedo usar el interruptor del compilador. Así que me he convertido esta:

char *setf = tigetstr("setf"); 

a esto:

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

Answer 9

Test string es const string. Así se puede resolver de esta manera:

char str[] = "Test string"; 

o:

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

Answer 10

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

ver el campo de nombre, en gcc que compile sin previo aviso, pero en g ++ se lo haré, no sé por qué.

Answer 11

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

(char*) "test" 

Answer 12

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

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

Más tarde puede ...

#pragma GCC diagnostic pop 

Answer 13

PyTypeObject PyDict_Type= 
{ ... 

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

ver el campo de nombre, en gcc que compile sin previo aviso, pero en g ++ Será, yo no sé por qué.

en gcc (Compiling C), -Wno-write-strings está activo de forma predeterminada.

en g++ (Compiling C++) -Wwrite-secuencias se activa por defecto

Es por esto que hay un comportamiento diferente. Para nosotros el uso de macros de Boost_python genera tales advertencias. por lo que utilizar -Wno-write-strings al compilar C++ ya que siempre usamos -Werror

Answer 14

sólo tiene que utilizar la opción -w de g ++

ejemplo:

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

Recuerde que esto no evita la depreciación sino que evita que se muestre un mensaje de advertencia en el terminal.

Ahora si realmente quieren evitar el uso de palabras clave const desaprobación de esta manera:

const char* s="constant string"; 

Answer 15

Cualquier función en la que se pasan los literales de cadena "I am a string literal" deben utilizar char const * como el tipo de lugar de char*.

Si va a arreglar algo, corríjalo bien.

Explicación:

No se puede utilizar literales de cadena para inicializar cadenas que se van a modificar, debido a que son de tipo const char*. La eliminación de la constness para modificarlos más tarde es undefined behaviour, por lo que debe copiar sus cadenas const char*char por char en cadenas char* asignadas dinámicamente para modificarlas.

Ejemplo:

#include<iostream> 
using namespace std; 
void print(char *); 
void print(const char *ch) 
{ 
    cout<<ch; 
} 

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

Answer 16

respuesta de BlackShift es muy útil, y lo usó como:

extern string execute(char* cmd) { 
      FILE* pipe = popen(cmd, "r"); 
      if (!pipe) return "ERROR"; 
      char buffer[256]; 
      std::string result = " "; 
      while(!feof(pipe)) { 
        if(fgets(buffer, 128, pipe) != NULL) 
          result += buffer; 
      } 
      pclose(pipe); 
      return result; 
    } 
    int main(){ 
      char cmd[]="grep -A1 'xml' out1.txt | grep read|awk -F'=' 'BEGIN{sum=0}{sum=sum+$NF}END{print sum}'"; 
      string result=execute(cmd); 
      int numOfBytes= atoi(result.c_str()); 
      cout<<"Number of bytes = "<<numOfBytes<<endl; 
      return 0; 
    } 

Answer 17

Haz encasillamiento de cadena constante a char puntero es decir

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

Answer 18

En lugar de:

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

Esto funciona:

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

Answer 19

En C++, utilice el const_cast como, como a continuación

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

Answer 20

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"); 

Answer 21

Gracias, todos, por la ayuda. Escogiendo de aquí y 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é, sólo hay 1 elemento de la matriz del servidor de hora. Pero podría haber más. El resto se comentaron por ahora para ahorrar memoria.

Answer 22

En C++, reemplace:

char *str = "hello"; 

con:

std::string str ("hello"); 

Y si quieres compararlo:

str.compare("HALLO"); 

Answer 23

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: StrContains char (char * str, char * sfind)

Para detener las advertencias que añade el const frente al char * str y el carbón * sfind.

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

Todas las advertencias desaparecieron.