Conversione deprecata C ++ dalla costante di stringa a ‘char *’

Ho una class con un private char str[256];

e per questo ho un costruttore esplicito:

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

Lo chiamo come:

 myClass obj("example"); 

Quando lo compilo ricevo il seguente avviso:

conversione deprecata dalla costante di stringa a ‘char *’

Perché sta succedendo?

Questo è un messaggio di errore che vedi ogni volta che hai una situazione simile alla seguente:

 char* pointer_to_nonconst = "string literal"; 

Perché? Bene, C e C ++ differiscono nel tipo di stringa letterale. In C il tipo è array di char e in C ++ è una costante array di caratteri. In ogni caso, non ti è permesso di cambiare i caratteri della stringa letterale, quindi il const in C ++ non è in realtà una restrizione ma più di un tipo di sicurezza. Generalmente una conversione da const char* a char* non è ansible senza un cast esplicito per motivi di sicurezza. Ma per la retrocompatibilità con C il linguaggio C ++ consente comunque di assegnare una stringa letterale a un char* e ti dà un avvertimento su questa conversione deprecata.

Quindi, da qualche parte ti manca uno o più const nel tuo programma per la correttezza costante. Ma il codice che ci hai mostrato non è il problema in quanto non fa questo tipo di conversione deprecata. L’avvertimento deve provenire da qualche altro posto.

L’avviso:

conversione deprecata dalla costante di stringa a ‘char *’

è dato perché stai facendo da qualche parte (non nel codice che hai postato) qualcosa come:

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

Il problema è che stai provando a convertire una stringa letterale (con tipo const char[] ) in char* .

È ansible convertire un const char[] in const char* perché l’array decade al puntatore, ma ciò che si sta facendo è rendere una costante mutabile.

Questa conversione è probabilmente consentita per la compatibilità con C e ti dà solo l’avviso menzionato.

Come risposta n. 2 di fnieto – Fernando Nieto descrive chiaramente e correttamente che questo avviso è dato perché qualcosa nel codice che stai facendo (non nel codice che hai postato) qualcosa del genere:

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

Tuttavia, se si desidera mantenere il proprio codice privo di avvertimenti, è sufficiente apportare le rispettive modifiche al codice:

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

Cioè, basta lanciare la costante di string su (char *) .

Ci sono 3 soluzioni:

Soluzione 1:

 const char *x = "foo bar"; 

Soluzione 2:

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

Soluzione 3:

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

Gli array possono anche essere utilizzati al posto dei puntatori perché un array è già un puntatore costante.

Infatti una stringa costante letterale non è né un const char * né un char * ma un char []. È piuttosto strano ma scritto nelle specifiche del c ++; Se lo modifichi, il comportamento non è definito perché il compilatore può memorizzarlo nel segmento di codice.

Risolvo questo problema aggiungendo questa macro all’inizio del codice, da qualche parte. Oppure aggiungilo in , hehe.

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

Ho anche avuto lo stesso problema. E quello che ho fatto è semplicemente aggiungendo const char * invece di char *. E il problema risolto. Come altri hanno menzionato sopra è un errore compatibile. C considera le stringhe come array di caratteri mentre C ++ li considera come array di cost-char.

Per quanto vale, trovo che questa semplice class wrapper sia utile per convertire le stringhe C ++ in char * :

 class StringWrapper { std::vector vec; public: StringWrapper(const std::string &str) : vec(str.begin(), str.end()) { } char *getChars() { return &vec[0]; } }; 

Quanto segue illustra la soluzione, assegna la stringa a un puntatore variabile a una matrice costante di caratteri (una stringa è un puntatore costante a un array costante di caratteri, oltre a informazioni sulla lunghezza):

 #include  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'; }