Jak pozbyć się ostrzeżeń 'deprecated conversion z ciągów znaków na' char*" w GCC?

Wszelkie funkcje, do których przekazujesz literały łańcuchowe "I am a string literal" powinny używać char const * jako typu zamiast char*.

Explanation:

Nie można używać literałów łańcuchowych do inicjalizacji łańcuchów, które zostaną zmodyfikowane, ponieważ są typu const char*. Odrzucenie konsternacji, aby później je zmodyfikować, jest niezdefiniowanym zachowaniem, więc musisz skopiować swoje const char* ciągi char przez char do dynamicznie przydzielanych char* łańcuchy w celu ich modyfikacji.

Przykład:

#include <iostream>

void print(char* ch);

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

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

Sprawdź obsługę GCC Diagnostic Pragma oraz listę - w warning options (zmieniony: nowy link do warning options).

Dla gcc, możesz użyć #pragma warning dyrektyw jak wyjaśniono tutaj .

Miałem podobny problem, rozwiązałem go tak:

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

Czy to jest odpowiedni sposób na rozwiązanie tego problemu? Nie mam dostępu do foo, aby dostosować go do accept const char*, chociaż byłoby to lepsze rozwiązanie (ponieważ foo nie zmienia się m).

Jeśli jest to aktywna baza kodu, nadal możesz chcieć ją uaktualnić. Oczywiście ręczne wykonanie zmian nie jest możliwe, ale uważam, że ten problem można rozwiązać raz na zawsze za pomocą jednego polecenia sed. Nie próbowałem tego, jednak, więc weź następujące z przymrużeniem oka.

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

Może to nie znaleźć wszystkich miejsc (nawet nie biorąc pod uwagę wywołań funkcji), ale złagodziłoby problem i umożliwiłoby wykonanie kilku pozostałych zmian ręcznie.

Nie mogę użyć przełącznika kompilatora. Więc to przemieniłem:

char *setf = tigetstr("setf");

Do tego:

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

Oto Jak to zrobić inline w pliku, więc nie musisz modyfikować swojego pliku Makefile.

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

#pragma GCC diagnostic pop

Zastąp

char *str = "hello";

Z

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

Lub jeśli wywołujesz funkcję:

foo("hello");

Zastąp to przez

foo((char*) "hello");

Zamiast:

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

To działa:

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

W C++ użyj const_cast Jak poniżej

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

Test string jest ciągiem konst. Więc możesz rozwiązać tak:

char str[] = "Test string";

Lub:

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

Dlaczego po prostu nie użyć odlewania typu?

(char*) "test"

Czy typecasting ze stałego łańcucha znaków do wskaźnika znakowego, tzn.

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

Można również utworzyć zapisywalny ciąg znaków ze stałej łańcuchowej, wywołując strdup().

Na przykład, ten kod generuje ostrzeżenie:

putenv("DEBUG=1");

Jednak poniższy kod nie (robi kopię łańcucha na stercie przed przekazaniem go do putenv):

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

W tym przypadku (i być może w większości innych) wyłączenie ostrzeżenia jest złym pomysłem - jest tam nie bez powodu. Inną alternatywą (domyślnie zapisywalną dla wszystkich łańcuchów) jest potencjalnie nieefektywne.

Posłuchaj, co mówi kompilator!

Zobacz tę sytuację:

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

Obserwuj pole nazwa, w gcc kompiluje się bez ostrzeżenia, ale w g++ będzie, nie wiem dlaczego.

W C++ Zastąp:

char *str = "hello";

Z:

std::string str ("hello");

A jeśli chcesz to porównać:

str.compare("HALLO");

Nie rozumiem jak zastosować rozwiązanie: (- kalmanIsAGameChanger

Pracując z Arduino Sketch, miałem funkcję powodującą moje Ostrzeżenia.

Oryginalna funkcja: Char StrContains (char *str, char * sfind)

Aby zatrzymać Ostrzeżenia dodałem const przed char *str i char *sfind.

Modified: Char StrContains (const char *str, const char *sfind).

Wystarczy użyć opcji-w dla g++

Przykład:

G++ -W-O proste.o proste.cpp-lpthread

Pamiętaj, że nie pozwala to uniknąć deprecjacji, a raczej zapobiega wyświetlaniu komunikatu ostrzegawczego na terminalu.

Teraz, jeśli naprawdę chcesz uniknąć deprecjacji, użyj słowa kluczowego const w ten sposób:

const char* s="constant string";  

Dlaczego nie użyjesz opcji -Wno-deprecated, aby zignorować przestarzałe komunikaty ostrzegawcze?

ODPOWIEDŹ BlackShift jest bardzo pomocna, a ja użyłem jej tak:

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

Problem polega na tym, że uruchamiam się z-Werror

Dzięki wszystkim za pomoc. Wybierając stąd i tam pojawia się takie rozwiązanie. To jest czyste. Nie testowałem jeszcze kodu. Jutro... może...

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 }

Wiem, że jest tylko 1 pozycja w tablicy timeServer. Ale może być więcej. Reszta została na razie skomentowana, aby zachować pamięć.

PyTypeObject PyDict_Type=
{ ...

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

Obserwuj pole nazwa, w gcc kompiluje się bez ostrzeżenia, ale w g++ będzie, nie wiem dlaczego.

W gcc (Compiling C),- Wno-write-strings jest domyślnie aktywne.

In g++ (Compiling C++) - Wwrite-strings jest domyślnie aktywne

Dlatego istnieje inne zachowanie. Dla nas używanie makr Boost_python generuje takie ostrzeżenia. Więc używamy -Wno-write-strings podczas kompilacji C++, ponieważ zawsze używamy -Werror