Я всегда беспорядок , как использовать const int*, const int * constи int const *правильно. Существует ли набор правил, определяющих, что вы можете и не можете делать?

Я хочу знать все, что можно и чего нельзя делать с точки зрения назначений, передачи функций и т. Д.

Прочитайте это в обратном направлении (как управляется по часовой стрелке / правилу спирали ):

• int* - указатель на int
• int const * - указатель на const int
• int * const - константный указатель на int
• int const * const константный указатель на const int

Теперь первый constможет быть с любой стороны типа так:

• const int * == int const *
• const int * const == int const * const

Если вы хотите сойти с ума, вы можете сделать что-то вроде этого:

• int ** - указатель на указатель на int
• int ** const - константный указатель на указатель на int
• int * const * - указатель на константный указатель на int
• int const ** - указатель на указатель на const int
• int * const * const - константный указатель на константный указатель на int
• ...

И чтобы убедиться, что мы ясно понимаем значение const:

int a = 5, b = 10, c = 15;

const int* foo;     // pointer to constant int.
foo = &a;           // assignment to where foo points to.

/* dummy statement*/
*foo = 6;           // the value of a can´t get changed through the pointer.

foo = &b;           // the pointer foo can be changed.



int *const bar = &c;  // constant pointer to int 
                      // note, you actually need to set the pointer 
                      // here because you can't change it later ;)

*bar = 16;            // the value of c can be changed through the pointer.    

/* dummy statement*/
bar = &a;             // not possible because bar is a constant pointer.           

fooпеременный указатель на постоянное целое число Это позволяет вам изменить то, на что вы указываете, но не значение, на которое вы указываете. Чаще всего это наблюдается в строках в стиле C, где у вас есть указатель на a const char. Вы можете изменить строку, на которую вы указываете, но вы не можете изменить содержимое этих строк. Это важно, когда сама строка находится в сегменте данных программы и не должна изменяться.

barпостоянный или фиксированный указатель на значение, которое можно изменить. Это как ссылка без лишнего синтаксического сахара. Из-за этого обычно вы используете ссылку, в которой вы используете T* constуказатель, если вам не нужно разрешать NULLуказатели.

Для тех, кто не знает о правиле по часовой стрелке / по спирали: начните с имени переменной, двигайтесь по часовой стрелке (в данном случае назад) к следующему указателю или типу . Повторяйте, пока не закончится выражение.

Вот демо:

Я думаю, что все уже здесь ответили, но я просто хочу добавить, что вы должны остерегаться typedefs! Они НЕ просто текстовые замены.

Например:

typedef char *ASTRING;
const ASTRING astring;

Тип astringесть char * const, нет const char *. Это одна из причин, которую я всегда склоняю constсправа от шрифта, и никогда в начале.

Как почти все отметили:

В чем разница const X* p, X* const pа const X* const p?

Вы должны прочитать объявления указателя справа налево.

• const X* p означает «p указывает на X, который является константой»: объект X нельзя изменить с помощью p.

• X* const p означает «p является константным указателем на X, который не является константным»: вы не можете изменить сам указатель p, но вы можете изменить X-объект через p.

• const X* const p означает «p - это константный указатель на X, который является константой»: вы не можете изменить сам указатель p, а также не можете изменить объект X с помощью p.

1. Постоянная ссылка:

   Ссылка на переменную (здесь int), которая является постоянной. Мы передаем переменную в основном как ссылку, потому что ссылки меньше по размеру, чем фактическое значение, но есть побочный эффект, и это потому, что это похоже на псевдоним реальной переменной. Мы можем случайно изменить основную переменную через наш полный доступ к псевдониму, поэтому мы устанавливаем ее постоянной, чтобы предотвратить этот побочный эффект.

   int var0 = 0;
   const int &ptr1 = var0;
   ptr1 = 8; // Error
   var0 = 6; // OK
   

2. Постоянные указатели

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

   int var1 = 1;
   int var2 = 0;
   
   int *const ptr2 = &var1;
   ptr2 = &var2; // Error
   

3. Указатель на постоянную

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

   int const * ptr3 = &var2;
   *ptr3 = 4; // Error
   

4. Постоянный указатель на постоянную

   Постоянный указатель на константу - это указатель, который не может изменить адрес, на который он указывает, и не может изменить значение, хранящееся по этому адресу.

   int var3 = 0;
   int var4 = 0;
   const int * const ptr4 = &var3;
   *ptr4 = 1;     // Error
    ptr4 = &var4; // Error
   

Общее правило заключается в том, что constключевое слово относится к тому, что ему предшествует. Исключение, начало constотносится к тому, что следует.

• const int*то же, что int const*и означает «указатель на константу int» .
• const int* constэто то же самое, что int const* constи означает «постоянный указатель на константу int» .

Редактировать: Для того, что можно и чего нельзя делать, если этого ответа недостаточно, не могли бы вы быть более точным относительно того, что вы хотите?

Этот вопрос показывает , именно поэтому мне нравится делать вещи так , как я уже упоминал в моем вопросе является сопзЬ после типа ид приемлемым?

Короче говоря, я считаю, что самый простой способ запомнить правило - это то, что «const» идет после того, к чему оно относится. Итак, в вашем вопросе «int const *» означает, что int является константой, а «int * const» будет означать, что указатель является константой.

Если кто-то решит поместить его на передний план (например, «const int *»), в качестве особого исключения в этом случае он применяется к предмету после него.

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

Простое использование const.

Самое простое использование - объявить именованную константу. Для этого нужно объявить константу, как если бы она была переменной, но добавить constперед ней. Нужно немедленно инициализировать его в конструкторе, потому что, конечно, нельзя установить значение позже, так как это изменило бы его. Например:

const int Constant1=96; 

создаст целочисленную константу, не вызывающую воображения Constant1, со значением 96.

Такие константы полезны для параметров, которые используются в программе, но их не нужно менять после компиляции программы. Он имеет преимущество для программистов перед командой препроцессора C #defineв том, что он понимается и используется самим компилятором, а не просто подставляется препроцессором в текст программы до того, как он достигнет основного компилятора, поэтому сообщения об ошибках гораздо более полезны.

Он также работает с указателями, но нужно быть осторожным, где constопределить, является ли указатель или то, на что он указывает, постоянным или и тем, и другим. Например:

const int * Constant2 

объявляет, что Constant2является указателем переменной на постоянное целое число и:

int const * Constant2

альтернативный синтаксис, который делает то же самое, тогда как

int * const Constant3

объявляет, что Constant3является постоянным указателем на целое число переменной и

int const * const Constant4

объявляет, что Constant4является постоянным указателем на постоянное целое число. По существу, «const» относится к тому, что находится непосредственно слева от него (кроме случаев, когда там ничего нет, в этом случае оно применяется к тому, что непосредственно справа от него).

ссылка: http://duramecho.com/ComputerInformation/WhyHowCppConst.html

У меня были те же сомнения, что и у вас, пока я не наткнулся на эту книгу Гуру С ++ Скотта Мейерса. Обратитесь к третьему пункту в этой книге, где он подробно рассказывает об использовании const.

Просто следуйте этому совету

1. Если слово constпоявляется слева от звездочки, на что указывает постоянная
2. Если слово constпоявляется справа от звездочки, сам указатель является постоянным
3. Если constпоявляется с обеих сторон, оба являются постоянными

Это просто, но сложно. Пожалуйста , обратите внимание , что мы можем поменять constклассификатор с любым типом данных ( int, char, floatи т.д.).

Давайте посмотрим на приведенные ниже примеры.

const int *p==> *pтолько для чтения [ pявляется указателем на постоянное целое число]

int const *p==> *pтолько для чтения [ pявляется указателем на постоянное целое число]

int *p const==> Неверное утверждение. Компилятор выдает синтаксическую ошибку.

int *const p==> pтолько для чтения [ pявляется постоянным указателем на целое число]. Так как указатель pздесь только для чтения, объявление и определение должны быть в одном месте.

const int *p const ==> Неверное утверждение. Компилятор выдает синтаксическую ошибку.

const int const *p ==> *pтолько для чтения

const int *const p1 ==> *pи pдоступны только для чтения [ pэто постоянный указатель на постоянное целое число]. Так как указатель pздесь только для чтения, объявление и определение должны быть в одном месте.

int const *p const ==> Неверное утверждение. Компилятор выдает синтаксическую ошибку.

int const int *p ==> Неверное утверждение. Компилятор выдает синтаксическую ошибку.

int const const *p ==> *pтолько для чтения и эквивалентноint const *p

int const *const p ==> *pи pдоступны только для чтения [ pэто постоянный указатель на постоянное целое число]. Так как указатель pздесь только для чтения, объявление и определение должны быть в одном месте.

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

• Вы часто передаете большие аргументы, такие как строки, поскольку TYPE const &это предотвращает изменение или копирование объекта. Пример :

  TYPE& TYPE::operator=(const TYPE &rhs) { ... return *this; }

  Но TYPE & constэто бессмысленно, потому что ссылки всегда постоянны.

• Вы должны всегда помечать методы класса, которые не изменяют класс как const, иначе вы не можете вызвать метод из TYPE const &ссылки. Пример :

  bool TYPE::operator==(const TYPE &rhs) const { ... }

• Есть общие ситуации, когда и возвращаемое значение, и метод должны быть постоянными. Пример :

  const TYPE TYPE::operator+(const TYPE &rhs) const { ... }

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

• В результате часто приходится создавать как константный, так и неконстантный метод с использованием константной перегрузки. Например, если вы определите T const& operator[] (unsigned i) const;, то вы, вероятно, также захотите неконстантную версию, заданную как:

  inline T& operator[] (unsigned i) { return const_cast<char&>( static_cast<const TYPE&>(*this)[](i) ); }

На самом деле, в C нет константных функций, функции, не являющиеся членами, сами по себе не могут быть константными в C ++, методы const могут иметь побочные эффекты, а компилятор не может использовать функции const, чтобы избежать дублирования вызовов функций. Фактически, даже простая int const &ссылка может свидетельствовать об изменении значения, на которое она ссылается, в другом месте.

Синтаксис объявления C и C ++ неоднократно описывался разработчиками как неудачный эксперимент.

Вместо этого давайте называть тип «указатель Type»; Я назову это Ptr_:

template< class Type >
using Ptr_ = Type*;

Теперь Ptr_<char>указатель на char.

Ptr_<const char>является указателем const char.

И const Ptr_<const char>это constуказатель на const char.

Там.

Для меня позиция, constто есть, кажется ли она ЛЕВОЙ или ПРАВОЙ или ЛЕВОЙ и ПРАВОЙ относительно, *помогает мне понять фактическое значение.

1. A constLEFT *означает, что объект, на который указывает указатель, является constобъектом.

2. От А constдо ПРАВА *указывает, что указатель является constуказателем.

Следующая таблица взята из Stanford CS106L Standard C ++ Programming Laboratory Reader.

В основном это касается второй строки: лучшие практики, назначения, параметры функций и т. Д.

Общая практика. Попробуйте сделать все, constчто вы можете. Или, говоря иначе, сделайте все constдля начала, а затем удалите точно минимальный набор consts, необходимый для работы программы. Это будет большим подспорьем в достижении константности и поможет избежать появления незаметных ошибок, когда люди попытаются заняться вещами, которые они не должны изменять.

Избегайте const_cast <>, как чума. Есть один или два законных варианта использования, но их очень мало и они далеко друг от друга. Если вы пытаетесь изменить constобъект, вам будет гораздо лучше найти того, кто объявил об этом constв первом темпе, и обсудить этот вопрос с ними, чтобы достичь консенсуса относительно того, что должно произойти.

Что приводит очень аккуратно в назначениях. Вы можете назначить что-то, только если это неконстантно. Если вы хотите присвоить что-то, что является постоянным, см. Выше. Помните , что в декларации int const *foo;и int * const bar;разные вещи const- другие ответы здесь покрыли этот вопрос превосходно, поэтому я не буду вдаваться в подробности .

Параметры функции:

Передача по значению: например, void func(int param)вам не важно, так или иначе на вызывающем сайте. Можно привести аргумент, что существуют варианты использования для объявления функции как, void func(int const param)но это не влияет на вызывающего, только на саму функцию, в том смысле, что любое переданное значение не может быть изменено функцией во время вызова.

Передайте по ссылке: например, void func(int &param)теперь это имеет значение. Как только что заявлено func, разрешено изменять param, и любой вызывающий сайт должен быть готов справиться с последствиями. Изменение декларации, чтобы void func(int const &param)изменить контракт, и гарантии, которые funcтеперь не могут измениться param, то есть то, что передано, то, что вернется. Как уже отмечали другие, это очень полезно для дешевой передачи большого объекта, который вы не хотите менять. Передача ссылки намного дешевле, чем передача большого объекта по значению.

Проходит указатель: например , void func(int *param)и void func(int const *param)эти два довольно много синонимов их позиционные коллегами, с той оговоркой , что вызываемая функция в настоящее время необходимо , чтобы проверить , nullptrесли некоторые другие договорные гарантии уверяют , funcчто он никогда не получит nullptrв param.

Часть мнения на эту тему. Доказать правильность в таком случае адски сложно, просто чертовски легко ошибиться. Так что не рискуйте, и всегда проверяйте параметры указателя nullptr. Вы избавите себя от боли и страданий, и вам будет трудно найти ошибки в долгосрочной перспективе. А что касается стоимости проверки, то она очень дешевая, и в случаях, когда статический анализ, встроенный в компилятор, может управлять им, оптимизатор все равно ее исключит. Включите Link Time Generation Generation для MSVC или WOPR (я думаю) для GCC, и вы получите всю программу, то есть даже в вызовах функций, которые пересекают границу модуля исходного кода.

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

Константа с int с обеих сторон сделает указатель на константу int :

const int *ptr=&i;

или:

int const *ptr=&i;

constпосле *сделает постоянный указатель на int :

int *const ptr=&i;

В этом случае все они являются указателями на постоянное целое число , но ни один из них не является постоянным указателем:

 const int *ptr1=&i, *ptr2=&j;

В этом случае все являются указателями на постоянное целое число, а ptr2 является постоянным указателем на постоянное целое число . Но ptr1 не является постоянным указателем:

int const *ptr1=&i, *const ptr2=&j;

• если constэто слева от *, оно относится к значению (это не имеет значения , является ли это const intили int const)
• если constэто справа от *, это относится к самому указателю
• это может быть одновременно

Важный момент: const int *p не означает, что значение, на которое вы ссылаетесь, является постоянным! , Это означает, что вы не можете изменить его через этот указатель (то есть вы не можете назначить $ * p = ... `). Само значение может быть изменено другими способами. Например

int x = 5;
const int *p = &x;
x = 6; //legal
printf("%d", *p) // prints 6
*p = 7; //error 

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

Просто ради полноты для C, следуя другим объяснениям, не уверен для C ++.

• pp - указатель на указатель
• р - указатель
• данные - вещь указанная, в примерах x
• полужирный - переменная только для чтения

Указатель

• р данные - int *p;
• р данные -int const *p;
• р данные -int * const p;
• р данные -int const * const p;

Указатель на указатель

1. pp p data - int **pp;
2. pp p data -int ** const pp;
3. pp p data -int * const *pp;
4. pp p data -int const **pp;
5. pp p data -int * const * const pp;
6. pp p data -int const ** const pp;
7. pp p data -int const * const *pp;
8. pp p data -int const * const * const pp;

// Example 1
int x;
x = 10;
int *p = NULL;
p = &x;
int **pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 2
int x;
x = 10;
int *p = NULL;
p = &x;
int ** const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

// Example 3
int x;
x = 10;
int * const p = &x; // Definition must happen during declaration
int * const *pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 4
int const x = 10; // Definition must happen during declaration
int const * p = NULL;
p = &x;
int const **pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 5
int x;
x = 10;
int * const p = &x; // Definition must happen during declaration
int * const * const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

// Example 6
int const x = 10; // Definition must happen during declaration
int const *p = NULL;
p = &x;
int const ** const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

// Example 7
int const x = 10; // Definition must happen during declaration
int const * const p = &x; // Definition must happen during declaration
int const * const *pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 8
int const x = 10; // Definition must happen during declaration
int const * const p = &x; // Definition must happen during declaration
int const * const * const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

N-уровни разыменования

Просто продолжай, но пусть человечество отлучит тебя от церкви.

int x = 10;
int *p = &x;
int **pp = &p;
int ***ppp = &pp;
int ****pppp = &ppp;

printf("%d \n", ****pppp);

1. const int*указатель на постоянный intобъект.

Вы можете изменить значение указателя; Вы не можете изменить значение intобъекта, на который указывает указатель.

2. const int * constпостоянный указатель на постоянный intобъект.

Вы не можете изменить значение указателя или значение intобъекта, на который указывает указатель.

3. int const *указатель на постоянный intобъект.

Это утверждение эквивалентно 1. const int*- Вы можете изменить значение указателя, но вы не можете изменить значение intобъекта, на который указывает указатель.

На самом деле, есть 4-й вариант:

4. int * constпостоянный указатель на intобъект.

Вы можете изменить значение объекта, на который указывает указатель, но вы не можете изменить значение самого указателя. Указатель всегда будет указывать на один и тот же intобъект, но это значение этого intобъекта можно изменить.

Если вы хотите определить определенный тип конструкции C или C ++, вы можете использовать Правило по часовой стрелке / спирали, разработанное Дэвидом Андерсоном; но не путать с правилом Андерсона, сформулированным Россом Дж. Андерсоном, который является чем-то совершенно отличным.