С как изменить const char
Перейти к содержимому

С как изменить const char

  • автор:

Указатели с ключевыми словами const и volatile

Константы и переменные ключевое слово изменяют способ обработки указателей. Ключевое слово const указывает, что указатель не может быть изменен после инициализации; указатель будет защищен от изменения.

Ключевое слово volatile указывает, что значение, связанное с именем, следующим образом, может быть изменено действиями, отличными от действий в пользовательском приложении. Таким образом, volatile ключевое слово полезно для объявления объектов в общей памяти, к которым можно обращаться с помощью нескольких процессов или глобальных областей данных, используемых для взаимодействия с подпрограммами службы прерываний.

Когда имя объявляется как volatile , компилятор перезагружает значение из памяти каждый раз, когда он обращается к программе. Это значительно сокращает возможности оптимизации. Однако если состояние объекта может неожиданно изменяться, то это единственный способ гарантировать предсказуемую производительность программы.

Чтобы объявить объект, на который указывает указатель, или const volatile используйте объявление формы:

const char *cpch; volatile char *vpch; 

Чтобы объявить значение указателя , то есть фактический адрес, хранящийся в указателе, как const или volatile используйте объявление формы:

char * const pchc; char * volatile pchv; 

Язык C++ запрещает назначения, позволяющие изменять объект или указатель, объявленный как const . Такие присваивания могут удалить информацию, с которой был объявлен объект или указатель, и тем самым подменить смысл исходного объявления. Рассмотрим следующее объявление:

const char cch = 'A'; char ch = 'B'; 

Учитывая предыдущие объявления двух объектов ( cch типа const char и ch типа char), допустимы следующие объявления и инициализации:

const char *pch1 = &cch; const char *const pch4 = &cch; const char *pch5 = &ch; char *pch6 = &ch; char *const pch7 = &ch; const char *const pch8 = &ch; 

Следующие объявления и инициализации вызывают ошибки.

char *pch2 = &cch; // Error char *const pch3 = &cch; // Error 

В объявлении pch2 задается указатель, при помощи которого может быть изменен постоянный объект, поэтому это объявление запрещено. Объявление pch3 указывает, что указатель является константой, а не объектом; объявление запрещено по той же причине pch2 , что объявление запрещено.

В следующих восьми примерах демонстрируется присваивание через указатель и изменение значения указателя для приведенных выше объявлений. Здесь мы предполагаем, что инициализация указателей pch1 – pch8 была выполнена без ошибок.

*pch1 = 'A'; // Error: object declared const pch1 = &ch; // OK: pointer not declared const *pch2 = 'A'; // OK: normal pointer pch2 = &ch; // OK: normal pointer *pch3 = 'A'; // OK: object not declared const pch3 = &ch; // Error: pointer declared const *pch4 = 'A'; // Error: object declared const pch4 = &ch; // Error: pointer declared const 

Указатели, объявленные как volatile или как смесь const и volatile , подчиняются тем же правилам.

Указатели на const объекты часто используются в объявлениях функций следующим образом:

errno_t strcpy_s( char *strDestination, size_t numberOfElements, const char *strSource ); 

Предыдущая инструкция объявляет функцию, strcpy_s, где два из трех аргументов имеют указатель char типа. Так как аргументы передаются по ссылке, а не по значению, функция может быть свободна для изменения обоих strDestination и strSource , если strSource они не были объявлены как const . Объявление как const гарантирует вызывающий strSource объект, который strSource не может быть изменен вызываемой функцией.

Так как существует стандартное преобразование из имени типа в имя* типа* const , оно является законным для передачи аргумента типа char * в strcpy_s. Однако обратное не верно; для удаления атрибута const из объекта или указателя не существует неявного преобразования.

const Указатель заданного типа можно назначить указателю того же типа. Однако указатель, который не const может быть назначен указателю const . В следующем коде показано одно верное и одно неверное присваивание.

// const_pointer.cpp int *const cpObject = 0; int *pObject; int main() < pObject = cpObject; cpObject = pObject; // C3892 >

В следующем примере показано, как объявить объект как const, когда имеется указатель на указатель на объект.

// const_pointer2.cpp struct X < X(int i) : m_i(i) < >int m_i; >; int main() < // correct const X cx(10); const X * pcx = &cx; const X ** ppcx = &pcx; // also correct X const cx2(20); X const * pcx2 = &cx2; X const ** ppcx2 = &pcx2; >

Как перевести из const char* в char*?

Author24 — интернет-сервис помощи студентам

Как сравнить char и const char?
Очередной раз столкнулся с проблемкой, сравнивая объекты из массива (char) нужно сравнить с const.

Чем отличаются объявления const char* и const* char
Прошу объяснить мне, чем отличаются объявления const char* и const* char и как объявить: указатель.

6578 / 4563 / 1843
Регистрация: 07.05.2019
Сообщений: 13,726

Лучший ответ

Сообщение было отмечено dasdada как решение

Решение

ЦитатаСообщение от dasdada Посмотреть сообщение

Как перевести из const char* в char*? Или как записать char* в виде строки(принимаемое значение в функции SetName — char*)

char sss[] = "fdf"; s.SetName(sss);

1352 / 851 / 365
Регистрация: 26.02.2015
Сообщений: 3,799

ЦитатаСообщение от dasdada Посмотреть сообщение

Как перевести из const char* в char*?

Пользуйтесь std::string, а при необходимости перевести в char* используйте метод std::string:data или std::string::c_str (для вызовов функций сторонних библиотек, где не предусмотрено использование std::string). А свой код пишите с использованием std::string и std::string_view.

18756 / 9769 / 2392
Регистрация: 30.01.2014
Сообщений: 17,133

Лучший ответ

Сообщение было отмечено Avazart как решение

Решение

ЦитатаСообщение от dasdada Посмотреть сообщение

Здесь же появляется ошибка, т.к. «fdf» — const char*

Лечить надо причину.
Начать с вопроса — почему это вообще Set-метод принимает не const char*? Он что, собрался, менять переданное? Тогда почему он Set?
Короче говоря, исправлять надо не константность, а сам метод.

87844 / 49110 / 22898
Регистрация: 17.06.2006
Сообщений: 92,604
Помогаю со студенческими работами здесь

Проблема с несовместимостью типов параметров char, const char, STRSAFE_LPWSTR, STRSAFE_LPCWSTR
Проблемные вопросы отражены на скрине Программа написана к заданию: 1. Разработать прикладной.

Error C2664: sprintf: невозможно преобразовать параметр 1 из ‘const char *’ в ‘char *’
error C2664: sprintf: невозможно преобразовать параметр 1 из ‘const char *’ в ‘char *’ void.

Строки: почему компилятор пишет , что переменная типа char несовместима с const char?
char pass; int password( int d) < int m; char p; cout << "Введите пароль для доступа к.

Printf: невозможно преобразовать параметр 1 из ‘char’ в ‘const char *’
Здравствуйте, подскажите как исправить? "printf: невозможно преобразовать параметр 1 из ‘char’ в.

[Ошибка] invalid conversion from ‘const char*’ to ‘char*’ [-fpermissive]
Решал задачи сам по себе, наткнулся на очень интересную. Вот сама задача: Вы оператор пуска .

Или воспользуйтесь поиском по форуму:

С как изменить const char

В действительности, в соответствии со стандартом на языки C и C++ (правило чтения операторов «Read Declarations Right-to-Left«, т. е. надо читать всегда оператор справа налево), модификатор const влияет на элемент, слева от которого стоит const. Поэтому если использовать const перед типом, то это фактически ничего не значит, и используется просто для удобства запоминания.

К примеру, следующие два оператора совершенно эквивалентны:

char const * УказательНаНЕизменяемоеСодержимое1;
const char * УказательНаНЕизменяемоеСодержимое2;

Оба указателя УказательНаНеизменяемоеСодержимое1 и УказательНаНеизменяемоеСодержимое2 указывают на строку, являющуюся константой, и оба эти указателя можно модифицировать runtime в коде программы.

Примечание: в какой реально памяти находится константа — зависит от платформы, для которой компилируется код. Например, для процессоров ARM встраиваемых систем константа может находиться в памяти программ FLASH, а для процессоров PC константы, как и обычные переменные, хранятся в памяти RAM.

Если же Вы хотели получить от указателя другое, чтобы это был постоянный указатель, который нельзя модифицировать, то нужно поместить const после звездочки (тогда получится наоборот, строка может быть изменяемой, а сам указатель изменить нельзя):

char * const НЕизменяемыйУказательНаИзменяемоеСодержимое;

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

char const * const НЕизменяемыйУказательНаНЕизменяемоеСодержимое;

[Примеры ключевого слова const при использовании с указателями]

Ключевое слово const используется, когда мы хотим сделать что-то — наподобие переменной — доступным только для чтения. При этом это что-то совсем не обязательно может храниться в памяти ROM, данные объекта «только для чтения» могут храниться и в RAM (зависит от используемой платформы, для которой компилируется код). Ниже приведено несколько примеров использования ключевого слова const.

const int j = 10;

В этом простом примере если мы попробуем в коде присвоить значение переменной j, то это будет обнаружено на этапе компиляции программы, компилятор выдаст ошибку.

Указатель на константу. Когда ключевое слово const используется с указателями, то важно помнить, что реальный смысл определения зависит от положения ключевого слова const.

Указатель на константу указывает на данные, которые должны быть постоянными. Это просто означает, что мы не можем поменять данные, на которые ссылается указатель. Вот несколько примеров кода, иллюстрирущие то, что мы подразумеваем указателем на константу:

// Создание указателя на константу:
const char* pntr = "не изменяемые данные";
// Это тоже создает указатель на константу. Хотя здесь синтаксис
// отличается от приведенного выше, это в сущности одно и то же.
char const* pntr = "не изменяемые данные";
// Этот код приведет к ошибке, потому что данные не могут быть
// изменены.
*pntr = "проверка";
// Но этот код считается безошибочным, потому что адрес указателя
// можно поменять (сам указатель не константа). pntr = "проверка";

Постоянный указатель. В таком указателе находящийся в нем адрес является константой. Но сама переменная, на которую ссылается указатель может быть изменена, т. е. она может не являться константой. Вот несколько примеров:

// Это определение const-указателя, хранящийся в нем
// адрес поменять нельзя, но сами данные поменять можно.
char* const pntr = "какие-то данные";
// Этот код корректен и допустим, потому что данные менять можно:
*pntr = "проверка";
// Но этот код приведет к ошибке, потому что адрес
// постоянного указателя поменять нельзя: pntr = "проверка";

Постоянный указатель на константу. Можно думать об этом случае как о комбинации двух примеров выше. Т. е. нельзя поменять ни сам адрес (значение указателя), ни данные, на которые он указывает. Пример:

// Это const-указатель на константу.
const char* const pntr = "Это поменять нельзя";

[Ссылки]

1. const char* and char const* — are they the same? site:stackoverflow.com .
2. Барт Симпсон Генератор картинок онлайн site:advice-dog.ru .
3. Использование описателя const в C.
4. Как читать сложные декларации C/C++.

Комментарии

+6 #1 Ruslan 22.04.2020 19:03

Но позвольте, вы же говорите что const влияет только на содержимое слева от const, а сами используете const самым левым (т.е. не влияющим ни на что).

/*const int j = 10;
В этом простом примере если мы попробуем в коде присвоить значение переменной j, то это будет обнаружено на этапе компиляции программы, компилятор выдаст ошибку.» */

const (C++)

При изменении объявления данных ключевое слово указывает, const что объект или переменная не изменяются.

Синтаксис

declarator :
ptr-declarator
noptr-declarator parameters-and-qualifiers trailing-return-type
ptr-declarator :
noptr-declarator
ptr-operator ptr-declarator
noptr-declarator :
declarator-id attribute-specifier-seq необ.
noptr-declarator parameters-and-qualifiers
noptr-declarator [ constant-expression opt ] attribute-specifier-seq opt
( ptr-declarator )
parameters-and-qualifiers :
( parameter-declaration-clause ) cv-qualifier-seq необ.
ref-qualifier opt noexcept-specifier opt attribute-specifier-seq opt
trailing-return-type :
-> type-id
ptr-operator :
* attribute-specifier-seq opt cv-qualifier-seq opt
& attribute-specifier-seq необ.
&& attribute-specifier-seq необ.
nested-name-specifier * attribute-specifier-seq opt cv-qualifier-seq opt
cv-qualifier-seq :
cv-qualifier cv-qualifier-seq необ.
cv-qualifier :
const
volatile
ref-qualifier :
&
&&
declarator-id :
. необ. id-expression

Значения const

Ключевое слово const указывает, что значение переменной является константой и сообщает компилятору, чтобы предотвратить изменение программистом.

// constant_values1.cpp int main() < const int i = 5; i = 10; // C3892 i++; // C2105 >

В C++можно использовать const ключевое слово вместо #define директивы препроцессора для определения константных значений. Значения, определенные с const помощью, подвергаются типу проверка и могут использоваться вместо константных выражений. В C++можно указать размер массива с переменной const следующим образом:

// constant_values2.cpp // compile with: /c const int maxarray = 255; char store_char[maxarray]; // allowed in C++; not allowed in C 

В языке C константные значения по умолчанию имеют внешнюю компоновку, поэтому они могут использоваться только в файлах исходного кода. В языке C++ константные значения по умолчанию имеют внутреннюю компоновку, которая позволяет использовать их в файлах заголовков.

Ключевое слово const также можно использовать в объявлениях указателя.

// constant_values3.cpp int main() < char this_char, that_char; char *mybuf = &this_char, *yourbuf = &that_char; char *const aptr = mybuf; *aptr = 'c'; // OK aptr = yourbuf; // C3892 > 

Указатель на переменную, объявленную как const можно назначить только указателю, который также объявлен как const .

// constant_values4.cpp #include int main() < const char *mybuf = "test"; char *yourbuf = "test2"; printf_s("%s\n", mybuf); const char *bptr = mybuf; // Pointer to constant data printf_s("%s\n", bptr); // *bptr = 'a'; // Error >

Указатели на данные-константы можно использовать в качестве параметров функций, чтобы функция не могла изменять параметр, переданный посредством указателя.

Для объектов, объявленных как const , можно вызывать только функции-члены констант. Компилятор гарантирует, что объект константы никогда не изменяется.

birthday.getMonth(); // Okay birthday.setMonth( 4 ); // Error 

Можно вызывать функции-члены констант или неконстантных для неконстантного объекта. Можно также перегрузить функцию-член с помощью const ключевое слово; эта функция позволяет вызывать другую версию функции для постоянных и неконстантных объектов.

Вы не можете объявлять конструкторы или деструкторы с const помощью ключевое слово.

const функции-члены

Объявление функции-члена с const помощью ключевое слово указывает, что функция является функцией только для чтения, которая не изменяет объект, для которого он вызывается. Функция-член констант не может изменять нестатические элементы данных или вызывать какие-либо функции-члены, которые не являются константами. Чтобы объявить функцию-член константы, поместите const ключевое слово после закрывающей скобки списка аргументов. В const объявлении и определении требуется ключевое слово.

// constant_member_function.cpp class Date < public: Date( int mn, int dy, int yr ); int getMonth() const; // A read-only function void setMonth( int mn ); // A write function; can't be const private: int month; >; int Date::getMonth() const < return month; // Doesn't modify anything >void Date::setMonth( int mn ) < month = mn; // Modifies data member >int main() < Date MyDate( 7, 4, 1998 ); const Date BirthDate( 1, 18, 1953 ); MyDate.setMonth( 4 ); // Okay BirthDate.getMonth(); // Okay BirthDate.setMonth( 4 ); // C2662 Error >

Различия C и C++ const

При определении переменной const в файле исходного кода C это делается так:

const int i = 2; 

Затем эту переменную можно использовать в другом модуле следующим образом:

extern const int i; 

Но чтобы получить такое же поведение в C++, необходимо определить const переменную следующим образом:

extern const int i = 2; 

Как и в C, эту переменную можно использовать в другом модуле следующим образом:

extern const int i; 

Если вы хотите определить extern переменную в файле исходного кода C++ для использования в файле исходного кода C, используйте следующее:

extern "C" const int x=10; 

для предотвращения изменения имени компилятором C++.

Замечания

При выполнении списка параметров функции-члена ключевое слово указывает, const что функция не изменяет объект, для которого он вызывается.

Дополнительные сведения const см. в следующих статьях:

  • const указатели и volatile указатели
  • Квалификаторы типов (справочник по языку C)
  • volatile
  • #define

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *