Указатели. Константный указатель и указатель на константу
Освоение указателей обычно сложно даётся новичкам-программистам. Хотя указатель — это только-лишь тип, а указательная переменная только-лишь адрес памяти.
Одной из наиболее запутывающей составляющей оказывается обозначение неизменяемости, применяемое либо к адресу, на который указатель указывает, либо к значению, находящемуся в том адресе.
Выглядит подобное безобразие приблизительно вот так:
Одной из наиболее запутывающей составляющей оказывается обозначение неизменяемости, применяемое либо к адресу, на который указатель указывает, либо к значению, находящемуся в том адресе.
Выглядит подобное безобразие приблизительно вот так:
|
1 |
const int * const* *const* * * x; |
Что же это такое? Чтобы разобраться с подобными пакостями, нужно начать с малого.
- Указатель — это тип.
- Указательная переменная — это адрес.
- В адресе есть значение.
Это три кита
- Прямое значение указательной переменной — это адрес.
- Косвенное значение указательной переменной — это значение из адреса.
Бывает, что нужно обозначить неизменяемость переменной. В случае с обычными переменными используется квалификатор const или volatile. Новичками в основном используется const. Указательная переменная может изменять непосредственное своё состояние и состояние косвенного своего значения. Изменяющаяся указательная переменная — это бегающий и прыгающий по памяти курсор. Не всегда нужно, чтобы этот курсор мог прыгать и бегать. В таких случаях нужно зафиксировать в указательной переменной адрес.
|
1 2 3 4 5 |
int main() { int value = 100; //обычная переменная для взятия адреса int * const p = &value; //Указательная переменная зафиксировала сохранённый в себя адрес } |
Такая фиксация адреса делает указательную переменную неподвижной. Т. е. в неё нельзя присваивать никакие адреса.
|
1 2 3 4 5 6 7 8 |
int main() { int value = 100; //обычная переменная для взятия адреса int * const p = &value; //Указательная переменная зафиксировала сохранённый в себя адрес int y; p = &y; //Нельзя изменить указательную переменную } |
Указательная переменная помогает читать и изменять значения из хранимого в себе адреса. Т. е. когда указательная переменная указывает на какой-то адрес, то значение из того адреса можно прочитать и изменить. Не всегда нужно, чтобы значения могли изменяться, а иногда нужно просто обозначить, что значения не должны изменяться. В случае использования указательной переменной этого можно добиться вот так:
|
1 2 3 4 5 6 7 |
int main() { int y = 200; int const *p = &y; (*p) = 300; //Нельзя изменить косвенное значение "руками" указательной переменной } |
Простыми словами "Вы используете указательную переменную или как курсор, или используете свойство косвенности указательной переменной для работы со значением, подбирающимся из адреса. Можно зафиксировать или курсор, или значение под курсором. ".
Оба случая можно совместить: зафиксировать адрес в указательной переменной и обозначить запрет на изменение вытаскиваемого из сохранённого адреса значения .
|
1 2 3 4 5 6 7 8 9 10 |
int main() { int a = 100; int const * const p = &a; //Запрет изменять и хранимый в указателе "p" адрес, //и значение в том адресе разыменованным указателем a++; //напряму значение можно менять (*p)++; //изменять разыменованным указателем нельзя p++; //переназначить адрес, хранимый в указательной переменной, нельзя } |
Кто-то может поторопиться и подумать, что всё понятно. Но не тут-то было. Эта тема константых указателей и указателей на константу доставляет определённых проблем. Вы можете сейчас сказать, что такое указатель на константу и что такое константный указатель? Можете распознать в коде, что есть что?
|
1 2 3 4 5 6 7 8 9 |
int main() { int a = 200; const int *p1 = &a; //Что есть что? int const *p2 = &a; //Как читается? const int *p3 = &a; //Что можно менять, что нельзя? int const * const p4 = &a; const int * const p5 = &a; } |
Вы можете сказать, что где? Как читается, что обозначает?
const int мало отличается от int const, это эквивалентны, поэтому p1, p2 и p3 будут вести себя одинаково, p4 и p5 будут вести себя одинаково.
Об остальном уже говорилось в начале статьи.
Сложно, должно быть. Запутывающе. Но не переживайте, здесь легко разрулить ситуацию. Существует особый способ, который помогает правильно воспринимать каждую такую "странную" строчку кода.
- Читайте справа налево, начиная от имени указательной переменной.
- const int и int const — эквивалентные способы обозначить int-константу
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
int main() { int a = 200; const int *p1 = &a; //p1 - указатель на int-константу, //разыменованным указателем значение изменять нельзя. //*p1 = 300; //Это будет ошибкой. int const *p2 = &a; //p2 - указатель на int-константу, //разыменованным указателем значение изменять нельзя. //*p2 = 300; //Это будет ошибкой. const int *p3 = &a; //p3 - указатель на int-константу, //разыменованным указателем значение изменять нельзя //*p3 = 300; //Это будет ошибкой. int const * const p4 = &a; //p4 - константный указатель на int-константу. //Нельзя записать в p4 никакие иные адреса, кроме сейчас записываемого. //разыменованным указателем значения изменять нельзя. int b = 100; // p4 = &b; //Это будет ошибкой. Нельзя изменить адрес внутри указательной переменной. //*p4 = 100; //Это будет ошибкой. Нельзя изменить значение разыменованным указателем. const int * const p5 = &a; //Попробуйте сами } |
Обозначение важности неизменяемости, применяемое к указательным переменным, не влияет на переменные, с которыми связан указатель. Т. е. если переменная не обозначена как неизменяемая, то она, логично, сможет меняться.
|
1 2 3 4 5 6 7 8 |
int main() { int a = 200; int const * p = &a; //читайте справа налево, от имени указательной переменной a++; //Сама переменная легко изменяется (*p)++; //Но не разыменованным указателем } |
- Чтобы меньше путаться, вы можете подменять слово "указатель" словом "адрес"
- Константный указатель — это когда адрес, хранимый внутри указательной переменной, изменять не положено.
- Указатель на константу — это когда значение, вытаскиваемое из адреса, воздействием указательной переменной изменять не положено.
- Константный указатель на константу — это когда нельзя изменить адрес, хранимый в указательной переменной, и нельзя повлиять разыменованной указательной переменной на значение, лежащее в том адресе.
Завершающий пример, показывающий различие использование константного указателя и указателя на константу:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
//Borland C++3.1 Указатели и константы Листинг #1 #include <iostream.h> int main() { int a = 100; //Два обычных объекта типа int int b = 222; int *const P2 = &a; //Константный указатель {P2} указывает на переменную {a}, тип которой int. *P2 = 987; //Менять значение разрешено. //P2 = &b; //Но изменять адрес не разрешается. const int *P1 = &a; //Указатель на константу int. //*P1 = 110; //Менять значение нельзя. P1 = &b; //Но менять адрес разрешено. const int *const P3 = &a; //Константный указатель на константу int. //*P3=155; //Изменять нельзя ни значение, //P3=&b; //ни адрес, к которому такой указатель привязан. cin.get(); } } |
Все три случая бывают нужны. (Указатель на константу, константный указатель и константный указатель на константу)
Если я не смог хорошо объяснить тему, то попробуйте прочитать здесь:
Да, в начале темы был приведён устрашающий пример:
|
1 |
const int * const* *const* * * x; |
Такие страшные штуки писать едва ли нужно. Но, возможно, какой-нибудь вредный соискатель любит задавать заковыристые вопросы, среди которых может оказаться похожий. Просто читайте справа налево:
x — это указатель на указатель на указатель, на константный указатель на указатель на константный указатель на целое.
x — это указатель на указатель на указатель, на константный указатель на указатель на константный указатель на целое.
Надеюсь, что научились уже различать константные указатели и указатели на константу. В одном случае нельзя менять адрес, в другом значение, вытаскиваемое из адреса.
По количеству звёздочек вы можете определить какому массиву подобна эта страшная штука: звёздочек 6, значит всё это дело похоже на шестимерный массив.
По количеству звёздочек вы можете определить какому массиву подобна эта страшная штука: звёздочек 6, значит всё это дело похоже на шестимерный массив.
|
1 2 3 4 5 |
int main(){ const int * const* *const* * * x; x [0][0][0][0][0][0]; x [0][0][0][0][0][0][0]; //Работать как с более чем шестимерным массивом не выйдет } |
Указатели не массивы, поэтому присвоить в такой сложный указатель шестимерный массив у вас не получится. Важнее, что в отличие от обычных массивов, в которых адреса начал зафиксированы, в этом массивоподобном создании адрес сдвигать можно, хотя непонятно, зачем и кому это нужно.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
int main(){ //Любой многомерный массив - это ни что иное как массив массивов. //Имя массива умеет неявно приводиться к указателю на первый свой элемент. //В обычных условиях имя массива неподвижно: нельзя имени массива переназначить используемый адрес. //В случае использования указателей и констант можно получить необычную чехарду массивов: //часть массивов будут неподвижными массивами, //а часть сможет бегать по памяти. const int * const* *const* * * x; //Подобие шестимерного массива. x[0]++; //Неконстантные указатели сдвинуть можно x[0]--; //Константные указатели сдвинуть нельзя x[0][0][0]++; //Нельзя сдвинуть адрес x[0][0][0][0][0]++; //Нельзя сдвинуть адрес //Конечное значение не указательного типа x[0][0][0][0][0][0]++; //Нельзя изменить конечное значение } |
То же самое можно посмотреть на уровне указателей:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
int main(){ const int * const* *const* * * x; x++; //Неконстантные указатели сдвинуть можно x--; //Константные указатели сдвинуть нельзя ***(***x)++; //Нельзя сдвинуть адрес *(*****x)++; //Нельзя сдвинуть адрес //Конечное значение не указательного типа (******x)++; //Нельзя изменить конечное значение } |
Чем больше звёздочек у вашей переменной, тем сложнее с ней работать, поэтому такие штуки не стоит использовать в ваших кодах. Приведено это только для того, чтобы вы познакомились с указателями на константы и константными указателями. Чтобы увидели, какие извращения в С++ возможны.
10 комментариев на «“Указатели. Константный указатель и указатель на константу”»
Добавить комментарий
Случайная книга в электронном формате
Когда-то где-то вычитал (у Страуструпа может, не помню) чтобы легче читать код и определятся с синтаксисом при написании (запомнить в общем), нужно читать конструкцию справа налево:
const int* — указатель(*) на целую(int) константу(const)
int *const — константный(const) указатель(*) на целое(int)
как-то так 🙂
ресурсу и авторам +
«Каждый из трех описанных описанных вариантов » — 2 раза слово «описанных») не по теме с++, но все же (=
Значение константного указателя на константу можно изменить с помощью другого указателя
Ваш пример в упрощённом варианте выглядит так:
Разумеется, можно изменять переменную, которая не константная, используя указатель.
Чтобы её не изменять, например случайно, нужно использовать ту самую переменную, которая константный указатель на константу.
Маша какого хрена я этого не знаю.
дык в конце то указатель не на целое, а на константное целое
На неконстантное целое.
Здраствуйте.Посмотрите.Почему нельзя создать массив так?
Это компилируется, только размер массива будет неопределён, использование неицианилизорванных своими значениями переменных — есть непрогнозируемое поведение программы.
Поскольку в указатель, который используется для описания размера массива, не записано никакого значения, то по сути в указателе лежит только-лишь неопределённое значение, использование которого даёт непрогнозируемый эффект.
Порядок нарушен. Сначала надо задать любое значение в адрес, на который ссылается указатель. И только потом на основании этого значения делать массив, а не сначала делать массив, чтобы потом говорить ему о его размере. Поменяйте 9-ю и 10-ю строчки местами и всё будет ОК.