У меня есть класс с private char str[256];

и для этого у меня есть явный конструктор:

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

Я называю это так:

myClass obj("example");

Когда я компилирую это, я получаю следующее предупреждение:

устаревшее преобразование из строковой константы в 'char *'

Почему это происходит?

Это сообщение об ошибке вы видите всякий раз, когда у вас возникает такая ситуация:

char* pointer_to_nonconst = "string literal";

Зачем? Ну, C и C ++ различаются по типу строкового литерала. В C тип является массивом char, а в C ++ - постоянным массивом char. В любом случае вам не разрешено изменять символы строкового литерала, поэтому const в C ++ на самом деле не ограничение, а скорее вопрос безопасности типов. Преобразование из const char*в char*обычно невозможно без явного приведения по соображениям безопасности. Но для обратной совместимости с C язык C ++ все еще позволяет присваивать строковый литерал a char*и выдает предупреждение о том, что это преобразование не рекомендуется.

Таким образом, где-то вам не хватает одного или нескольких constсимволов в вашей программе для правильности констант. Но код, который вы показали нам, не является проблемой, так как он не делает такого рода устаревшее преобразование. Предупреждение, должно быть, пришло из другого места.

Предупреждение:

устаревшее преобразование из строковой константы в 'char *'

дается, потому что вы делаете где-то (не в коде, который вы опубликовали) что-то вроде:

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

Проблема в том, что вы пытаетесь преобразовать строковый литерал (с типом const char[]) в char*.

Вы можете преобразовать const char[]в, const char*потому что массив распадается на указатель, но то, что вы делаете, делает изменяемый константу.

Это преобразование, вероятно, разрешено для совместимости с C и дает вам упомянутое предупреждение.

Как ответа нет. 2 by fnieto - Фернандо Ньето ясно и правильно описывает, что это предупреждение выдается, потому что где-то в вашем коде вы делаете (не в коде, который вы опубликовали) что-то вроде:

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

Однако, если вы хотите, чтобы ваш код также не содержал предупреждений, просто внесите соответствующие изменения в свой код:

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

То есть просто приведите stringконстанту к (char *).

Есть 3 решения:

Решение 1:

const char *x = "foo bar";

Решение 2:

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

Решение 3:

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

Массивы также можно использовать вместо указателей, поскольку массив уже является постоянным указателем.

Фактически строковая константа-литерал не является ни const char *, ни char *, а char []. Это довольно странно, но записано в спецификациях c ++; Если вы измените его, поведение не определено, потому что компилятор может сохранить его в сегменте кода.

Может быть, вы можете попробовать это:

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

foo("Hello")

Меня устраивает

Я решаю эту проблему, добавив этот макрос в начале кода, где-то. Или добавь это <iostream>, хе-хе.

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

Причиной этой проблемы (которую еще сложнее обнаружить, чем проблему, char* str = "some string"которую объяснили другие) является то, что вы используете constexpr.

constexpr char* str = "some string";

Кажется, что он будет вести себя подобно const char* str, и поэтому не будет вызывать предупреждение, как это происходит раньше char*, но вместо этого он ведет себя как char* const str.

подробности

Указатель константы и указатель на константу. Разницу между const char* strи char* const strможно объяснить следующим образом.

1. const char* str: Объявить str указателем на const char. Это означает, что данные, на которые этот указатель указывает на него, постоянны. Указатель можно изменить, но любая попытка изменить данные приведет к ошибке компиляции.
   1. str++ ;: ДЕЙСТВИТЕЛЬНО . Мы модифицируем указатель, а не данные, на которые указывают.
   2. *str = 'a';: Недействительно . Мы пытаемся изменить данные, на которые указывают.
2. char* const str: Объявляем str константным указателем на char. Это означает, что точка теперь постоянна, но данные, на которые указывают, тоже нет. Указатель нельзя изменить, но мы можем изменить данные, используя указатель.
   1. str++ ;: Недействительно . Мы пытаемся изменить указатель переменной, которая является константой.
   2. *str = 'a';: ДЕЙСТВИТЕЛЬНО . Мы пытаемся изменить данные, на которые указывают. В нашем случае это не вызовет ошибки компиляции, но вызовет ошибку времени выполнения , поскольку строка, скорее всего, попадет в секцию только для чтения скомпилированного двоичного файла. Это утверждение имело бы смысл, если бы у нас была динамически распределенная память, например. char* const str = new char[5];,
3. const char* const str: Объявляем str константным указателем на константный символ. В этом случае мы не можем ни изменить указатель, ни данные, на которые он указывает.
   1. str++ ;: Недействительно . Мы пытаемся изменить указатель переменной, которая является константой.
   2. *str = 'a';: Недействительно . Мы пытаемся изменить данные, указанные этим указателем, который также является постоянным.

В моем случае проблема заключалась в том, что я ожидал, что буду constexpr char* strвести себя так const char* str, а не так char* const str, поскольку визуально он кажется ближе к первому.

Кроме того, предупреждение, сгенерированное для constexpr char* str = "some string", немного отличается от char* str = "some string".

1. Предупреждение компилятора для constexpr char* str = "some string":ISO C++11 does not allow conversion from string literal to 'char *const'
2. Предупреждение компилятора для char* str = "some string": ISO C++11 does not allow conversion from string literal to 'char *'.

Наконечник

Вы можете использовать C gibberish ↔ английский конвертер для преобразования Cобъявлений в легко понятные английские выражения, и наоборот. Это Cединственный инструмент, и поэтому он не будет поддерживать вещи (например, constexpr), которые являются эксклюзивными для C++.

У меня тоже такая же проблема. Я просто добавил const char * вместо char *. И проблема решена. Как уже упоминалось выше, это совместимая ошибка. C рассматривает строки как массивы символов, а C ++ обрабатывает их как массивы const.

Я считаю, что этот простой класс-обертка полезен для преобразования строк C ++ в char *:

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

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

Следующее иллюстрирует решение, назначьте вашу строку указателю переменной на постоянный массив символов char (строка является постоянным указателем на постоянный массив символов char + plus length):

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