Comment se débarrasser des avertissements `conversion obsolète de constante de chaîne en 'char *' 'dans GCC?

Je travaille donc sur une base de code extrêmement grande et récemment mise à niveau vers gcc 4.3, ce qui déclenche maintenant cet avertissement:

avertissement: conversion obsolète de la constante de chaîne en 'char *'

De toute évidence, la bonne façon de résoudre ce problème est de trouver chaque déclaration comme

char *s = "constant string";

ou appel de fonction comme:

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

et en faire des const charpointeurs. Cependant, cela signifierait toucher 564 fichiers, au minimum, ce qui n'est pas une tâche que je souhaite effectuer à ce stade. Le problème en ce moment est que je cours avec -werror, j'ai donc besoin d'un moyen d'étouffer ces avertissements. Comment puis je faire ça?

Je crois que passer -Wno-write-stringsà gcc supprimera cet avertissement.

Toutes les fonctions dans lesquelles vous passez des littéraux de chaîne "I am a string literal"doivent utiliser char const *comme type au lieu de char*.

Si vous voulez réparer quelque chose, corrigez-le correctement.

Explication:

Vous ne pouvez pas utiliser de littéraux de chaîne pour initialiser des chaînes qui seront modifiées, car elles sont de type const char*. A bas les constness pour modifier plus tard eux est un comportement non défini , vous devez copier vos const char*chaînes charpar charen alloués dynamiquement des char*chaînes afin de les modifier.

Exemple:

#include <iostream>

void print(char* ch);

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

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

J'ai eu un problème similaire, je l'ai résolu comme ceci:

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

Est-ce une façon appropriée de résoudre ce problème? Je n'ai pas accès àfoo adapter pour l'accepter const char*, même si ce serait une meilleure solution (car fooça ne change pas m).

Consultez le support Diagnostic Pragma de gcc et la liste des options d'avertissement -W (modifié: nouveau lien vers les options d'avertissement ).

Pour gcc, vous pouvez utiliser des #pragma warningdirectives comme expliqué ici .

S'il s'agit d'une base de code active, vous souhaiterez peut-être toujours mettre à niveau la base de code. Bien sûr, effectuer les modifications manuellement n'est pas possible mais je pense que ce problème pourrait être résolu une fois pour toutes par une seule sedcommande. Je ne l'ai pas encore essayé, alors prenez ce qui suit avec un grain de sel.

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

Cela pourrait ne pas trouver tous les emplacements (même en ne tenant pas compte des appels de fonction), mais cela atténuerait le problème et permettrait d'effectuer les quelques modifications restantes manuellement.

Je ne peux pas utiliser le commutateur du compilateur. J'ai donc tourné ceci:

char *setf = tigetstr("setf");

pour ça:

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

Voici comment le faire en ligne dans un fichier, vous n'avez donc pas à modifier votre Makefile.

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

Vous pourrez alors plus tard ...

#pragma GCC diagnostic pop

Remplacer

char *str = "hello";

avec

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

ou si vous appelez en fonction:

foo("hello");

remplacer cela par

foo((char*) "hello");

Au lieu de:

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

Cela marche:

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

En C ++, utilisez le const_castcomme ci-dessous

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

Test stringest une chaîne de const. Vous pouvez donc résoudre comme ceci:

char str[] = "Test string";

ou:

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

Pourquoi ne pas simplement utiliser la conversion de type?

(char*) "test"

Faire un transtypage de type chaîne constante vers un pointeur char

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

En C ++, remplacez:

char *str = "hello";

avec:

std::string str ("hello");

Et si vous voulez le comparer:

str.compare("HALLO");

Je ne comprends pas comment appliquer votre solution :( - kalmanIsAGameChanger

En travaillant avec Arduino Sketch, j'avais une fonction à l'origine de mes avertissements.

Fonction d'origine: char StrContains (char * str, char * sfind)

Pour arrêter les avertissements, j'ai ajouté le const devant le char * str et le char * sfind.

Modifié: char StrContains (const char * str, const char * sfind).

Tous les avertissements ont disparu.

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

regardez le champ du nom, dans gcc il compile sans avertissement, mais dans g ++ il le fera, je ne sais pas pourquoi.

Vous pouvez également créer une chaîne inscriptible à partir d'une constante de chaîne en appelant strdup() .

Par exemple, ce code génère un avertissement:

putenv("DEBUG=1");

Cependant, le code suivant ne fonctionne pas (il fait une copie de la chaîne sur le tas avant de la transmettre putenv):

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

Dans ce cas (et peut-être dans la plupart des autres), désactiver l'avertissement est une mauvaise idée - c'est là pour une raison. L'autre alternative (rendre toutes les chaînes accessibles en écriture par défaut) est potentiellement inefficace.

Écoutez ce que le compilateur vous dit!

utilisez simplement l'option -w pour g ++

exemple:

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

Rappelez-vous que cela n'évite pas la dépréciation, mais empêche d'afficher un message d'avertissement sur le terminal.

Maintenant, si vous voulez vraiment éviter la dépréciation, utilisez le mot-clé const comme ceci:

const char* s="constant string";  

Pourquoi n'utilisez-vous pas l' -Wno-deprecatedoption pour ignorer les messages d'avertissement obsolètes?

Le problème en ce moment est que je cours avec -Werror

C'est votre vrai problème, OMI. Vous pouvez essayer des moyens automatisés de passer de (char *) à (const char *) mais je mettrais de l'argent dessus non seulement en travaillant. Vous devrez impliquer un humain pour au moins une partie du travail. Pour le court terme, ignorez simplement l'avertissement (mais IMO laissez-le allumé, sinon il ne sera jamais corrigé) et supprimez simplement -Werror.

Merci à tous pour l'aide. Choisir ici et là vient cette solution. Cela compile propre. Je n'ai pas encore testé le code. Demain peut-être...

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 }

Je sais, il n'y a qu'un seul élément dans le tableau timeServer. Mais il pourrait y en avoir plus. Le reste a été commenté pour l'instant pour économiser de la mémoire.

PyTypeObject PyDict_Type=
{ ...

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

regardez le champ du nom, dans gcc il compile sans avertissement, mais dans g ++ il le fera, je ne sais pas pourquoi.

dans gcc (Compiling C) , -Wno-write-strings est actif par défaut.

dans g++ (Compiling C++) -Wwrite-strings est actif par défaut

C'est pourquoi il y a un comportement différent. Pour nous, l'utilisation de macros de Boost_pythongénère de tels avertissements. Nous utilisons donc -Wno-write-stringslors de la compilation C ++ puisque nous utilisons toujours-Werror

Déclarez une chaîne comme constrésoudra le problème:

char const*s = "constant string";