J'ai une classe avec un private char str[256];

et pour cela j'ai un constructeur explicite:

explicit myClass(const char *func)
{
    strcpy(str,func);
}

Je l'appelle comme:

myClass obj("example");

Lorsque je compile ceci, je reçois l'avertissement suivant:

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

Pourquoi cela arrive-t-il?

Il s'agit d'un message d'erreur que vous voyez chaque fois que vous rencontrez une situation comme celle-ci:

char* pointer_to_nonconst = "string literal";

Pourquoi? Eh bien, C et C ++ diffèrent par le type de littéral de chaîne. En C, le type est un tableau de char et en C ++, c'est un tableau constant de char. Dans tous les cas, vous n'êtes pas autorisé à modifier les caractères du littéral de chaîne, donc le const en C ++ n'est pas vraiment une restriction mais plutôt une sécurité de type. Une conversion de const char*à char*n'est généralement pas possible sans un cast explicite pour des raisons de sécurité. Mais pour la compatibilité descendante avec C, le langage C ++ permet toujours d'attribuer un littéral de chaîne à a char*et vous avertit que cette conversion est obsolète.

Donc, quelque part, il vous manque un ou plusieurs consts dans votre programme pour la correction de const. Mais le code que vous nous avez montré n'est pas le problème car il n'effectue pas ce type de conversion obsolète. L'avertissement doit provenir d'un autre endroit.

L'avertissement:

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

est donné parce que vous faites quelque chose comme:

void foo(char* str);
foo("hello");

Le problème est que vous essayez de convertir une chaîne littérale (avec type const char[]) en char*.

Vous pouvez convertir un const char[]en const char*parce que le tableau se désintègre en pointeur, mais ce que vous faites est de faire d'une mutable une constante.

Cette conversion est probablement autorisée pour la compatibilité C et vous donne juste l'avertissement mentionné.

Comme réponse non. 2 par fnieto - Fernando Nieto décrit clairement et correctement que cet avertissement est donné parce que quelque part dans votre code vous faites (pas dans le code que vous avez posté) quelque chose comme:

void foo(char* str);
foo("hello");

Cependant, si vous souhaitez également garder votre code sans avertissement, effectuez simplement les modifications correspondantes dans votre code:

void foo(char* str);
foo((char *)"hello");

Autrement dit, lancez simplement la stringconstante sur (char *).

Il existe 3 solutions:

Solution 1:

const char *x = "foo bar";

Solution 2:

char *x = (char *)"foo bar";

Solution 3:

char* x = (char*) malloc(strlen("foo bar")+1); // +1 for the terminator
strcpy(x,"foo bar");

Les tableaux peuvent également être utilisés à la place des pointeurs car un tableau est déjà un pointeur constant.

En fait, un littéral de constante de chaîne n'est ni un const char * ni un char * mais un char []. C'est assez étrange mais écrit dans les spécifications c ++; Si vous le modifiez, le comportement n'est pas défini car le compilateur peut le stocker dans le segment de code.

Peut-être que vous pouvez essayer ceci:

void foo(const char* str) 
{
    // Do something
}

foo("Hello")

Ça marche pour moi

Je résous ce problème en ajoutant cette macro au début du code, quelque part. Ou ajoutez-le <iostream>, hehe.

 #define C_TEXT( text ) ((char*)std::string( text ).c_str())

Une raison de ce problème (qui est encore plus difficile à détecter que le problème avec char* str = "some string"- que d'autres ont expliqué) est lorsque vous utilisez constexpr.

constexpr char* str = "some string";

Il semble qu'il se comporterait de la même manière que const char* str, et ne provoquerait donc pas d'avertissement, comme auparavant char*, mais il se comporte plutôt comme char* const str.

Détails

Pointeur constant et pointeur vers une constante. La différence entre const char* stret char* const strpeut être expliquée comme suit.

1. const char* str: Déclare str comme pointeur vers un caractère const. Cela signifie que les données vers lesquelles ce pointeur pointe vers lui sont constantes. Le pointeur peut être modifié, mais toute tentative de modification des données lèverait une erreur de compilation.
   1. str++ ;: VALIDE . Nous modifions le pointeur, et non les données pointées.
   2. *str = 'a';: INVALIDE . Nous essayons de modifier les données pointées.
2. char* const str: Déclare str comme pointeur const vers char. Cela signifie que ce point est désormais constant, mais que les données pointées ne le sont pas non plus. Le pointeur ne peut pas être modifié mais nous pouvons modifier les données à l'aide du pointeur.
   1. str++ ;: INVALIDE . Nous essayons de modifier la variable du pointeur, qui est une constante.
   2. *str = 'a';: VALIDE . Nous essayons de modifier les données pointées. Dans notre cas, cela ne provoquera pas d'erreur de compilation, mais entraînera une erreur d'exécution , car la chaîne sera très probablement placée dans une section en lecture seule du binaire compilé. Cette déclaration aurait du sens si nous avions de la mémoire allouée dynamiquement, par exemple. char* const str = new char[5];.
3. const char* const str: Déclare str comme pointeur const vers un caractère const. Dans ce cas, nous ne pouvons ni modifier le pointeur, ni les données pointées.
   1. str++ ;: INVALIDE . Nous essayons de modifier la variable du pointeur, qui est une constante.
   2. *str = 'a';: INVALIDE . Nous essayons de modifier les données pointées par ce pointeur, qui est également constant.

Dans mon cas, le problème était que je m'attendais constexpr char* strà me comporter comme const char* str, et non char* const str, car visuellement, cela semble plus proche du premier.

De plus, l'avertissement généré pour constexpr char* str = "some string"est légèrement différent de char* str = "some string".

1. Avertissement du compilateur pour constexpr char* str = "some string":ISO C++11 does not allow conversion from string literal to 'char *const'
2. Avertissement du compilateur pour char* str = "some string": ISO C++11 does not allow conversion from string literal to 'char *'.

Pointe

Vous pouvez utiliser le convertisseur C gibberish ↔ anglais pour convertir les Cdéclarations en déclarations anglaises facilement compréhensibles, et vice versa. C'est un Coutil unique, et donc ne supporte pas les choses (comme constexpr) qui sont exclusives à C++.

J'ai aussi le même problème. Et ce que j'ai simplement fait, c'est simplement ajouter const char * au lieu de char *. Et le problème est résolu. Comme d'autres l'ont mentionné ci-dessus, c'est une erreur compatible. C traite les chaînes comme des tableaux de caractères tandis que C ++ les traite comme des tableaux de caractères const.

Pour ce que cela vaut, je trouve que cette classe wrapper simple est utile pour convertir des chaînes C ++ en char *:

class StringWrapper {
    std::vector<char> vec;
public:
    StringWrapper(const std::string &str) : vec(str.begin(), str.end()) {
    }

    char *getChars() {
        return &vec[0];
    }
};

Ce qui suit illustre la solution, affectez votre chaîne à un pointeur de variable vers un tableau constant de char (une chaîne est un pointeur constant vers un tableau constant de char - plus les informations de longueur):

#include <iostream>

void Swap(const char * & left, const char * & right) {
    const char *const temp = left;
    left = right;
    right = temp;
}

int main() {
    const char * x = "Hello"; // These works because you are making a variable
    const char * y = "World"; // pointer to a constant string
    std::cout << "x = " << x << ", y = " << y << '\n';
    Swap(x, y);
    std::cout << "x = " << x << ", y = " << y << '\n';
}