Я всегда испортил, как правильно использовать const int*, const int * const и int const *. Существует ли набор правил, определяющих, что вы можете и чего не можете сделать?
Я хочу знать все, что нужно делать, и все это не касается присвоений, передачи функций и т.д.
Прочитайте его назад (как управляется по часовой стрелке/спиральному правилу):
int* - указатель на intint const * - указатель на const intint * const - const указатель на intint const * const - const указатель на const int Теперь первый const может быть по обе стороны от типа так:
const int * == int const *const int * const == int const * constЕсли вы хотите сходить с ума, вы можете делать такие вещи:
int ** - указатель на указатель на intint ** const - указатель const на указатель на intint * const * - указатель на указатель const на intint const ** - указатель на указатель на const intint * const * const - указатель const на указатель const на intИ чтобы убедиться, что мы ясно понимаем значение const
const int* foo;
int *const bar; //note, you actually need to set the pointer
//here because you can't change it later ;)
foo - переменный указатель на постоянное целое число. Это позволяет вам изменить то, что вы указываете, но не значение, на которое вы указываете. Чаще всего это видно со строк в стиле C, где у вас есть указатель на const char. Вы можете изменить строку, на которую указываете, но вы не можете изменить содержимое этих строк. Это важно, когда сама строка находится в сегменте данных программы и не должна изменяться.
bar - постоянный или фиксированный указатель на значение, которое можно изменить. Это похоже на ссылку без дополнительного синтаксического сахара. Из-за этого, как правило, вы будете использовать ссылку, где вы будете использовать указатель T* const если вам не нужно NULL указатели NULL.
Для тех, кто не знает о правиле по часовой стрелке/по спирали: начните с имени переменной, двигайтесь по часовой стрелке (в данном случае назад) к следующему указателю или типу. Повторяйте, пока не закончится выражение.
Вот демо:
Я думаю, здесь все уже сказано, но я просто хочу добавить, что вы должны остерегаться typedef ! Это не просто замена текста.
Например:
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, который является const": объект X не может быть изменен с помощью p.
X* const pозначает, что "p является указателем const к X, который не является константой": вы не можете изменить указатель p, но вы можете изменить объект X через p.
const X* const pозначает, что "p - это указатель const на X, который является const": вы не можете изменить указатель p самостоятельно, и вы не можете изменить объект X через p.
Постоянная ссылка:
Ссылка на переменную (здесь int), которая является постоянной. Мы передаем переменную как ссылку главным образом, потому что ссылки меньше по размеру, чем фактическое значение, но есть побочный эффект, и это потому, что он похож на псевдоним на фактическую переменную. Мы можем случайно изменить основную переменную через наш полный доступ к псевдониму, поэтому мы делаем его постоянным, чтобы предотвратить этот побочный эффект.
int var0 = 0;
const int &ptr1 = var0;
ptr1 = 8; // Error
var0 = 6; // OK
Константные указатели
Как только постоянный указатель указывает на переменную, он не может указывать на какую-либо другую переменную.
int var1 = 1;
int var2 = 0;
int *const ptr2 = &var1;
ptr2 = &var2; // Error
Указатель на константу
Указатель, через который нельзя изменить значение переменной, которую он указывает, известен как указатель на константу.
int const * ptr3 = &var2;
*ptr3 = 4; // Error
Постоянный указатель на константу
Постоянный указатель на константу - это указатель, который не может ни изменить адрес, на который он указывает, ни изменить значение, сохраненное по этому адресу.
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".Edit: Для Dos и Don'ts, если этого ответа недостаточно, не могли бы вы уточнить, что хотите?
Этот вопрос показывает точно, почему мне нравится делать то, что я упомянул в своем вопросе является константой после допустимого идентификатора типа? p >
Короче говоря, я считаю, что самый простой способ запомнить правило состоит в том, что "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
У меня были те же сомнения, что и вы, пока я не встретил эту книгу от С++ Guru Scott Meyers. См. Третий пункт в этой книге, где он подробно рассказывает об использовании const.
Просто следуйте этому совету
const отображается слева от звездочки, то, на что указывает, является константойconst отображается справа от звездочки, сам указатель является константой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 здесь доступен только для чтения, декларация и определение должны быть в одном месте.
В С++ есть много других тонких точек, окружающих const-корректность. Я предполагаю, что вопрос здесь просто о C, но я приведу некоторые связанные примеры, так как тег С++:
Вы часто передаете большие аргументы, такие как строки, как TYPE const &, которые препятствуют изменению или копированию объекта. Пример:
TYPE& TYPE::operator=(const TYPE &rhs) { ... return *this; }
Но TYPE & const не имеет смысла, поскольку ссылки всегда const.
Вы всегда должны указывать методы класса, которые не изменяют класс как const, иначе вы не можете вызвать метод из справочника TYPE const &. Пример:
bool TYPE::operator==(const TYPE &rhs) const { ... }
Существуют обычные ситуации, когда как возвращаемое значение, так и метод должны быть const. Пример:
const TYPE TYPE::operator+(const TYPE &rhs) const { ... }
Фактически, методы const не должны возвращать внутренние данные класса как ссылку на не-const.
В результате часто нужно создавать как const, так и неконстантный метод с использованием перегрузки const. Например, если вы определяете T const& operator[] (unsigned i) const;, то вам, вероятно, также понадобится неконстантная версия, заданная:
inline T& operator[] (unsigned i) {
return const_cast<char&>(
static_cast<const TYPE&>(*this)[](i)
);
}
Afaik, в C нет функций const, функции нечлена не могут быть const в С++, методы const могут иметь побочные эффекты, а компилятор не может использовать функции const, чтобы избежать дублирования вызовов функций. На самом деле даже простая ссылка int const & может свидетельствовать о том, что значение, к которому оно относится, будет изменено в другом месте.
Синтаксис объявления 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 то есть, отображается ли оно влево или вправо или как влево, так и вправо относительно * помогает мне понять фактическое значение.
Значение const для LEFT из * указывает, что объект, на который указывает указатель, является объектом const.
const справа от * указывает на то, что указатель является const указатель.
Следующая таблица взята из Стандартного считывателя курсов по программированию Stanford CS106L Standard C++.
Константа с 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 для начала, а затем удалите точно минимальный набор const, необходимый, чтобы позволить программе функционировать. Это будет большой помощью в достижении const-correctness и поможет гарантировать, что тонкие ошибки не будут введены, когда люди попытаются назначить вещи, которые они не должны изменять.
Избегайте const_cast < > как чума. Для него есть один или два законных варианта использования, но их очень мало и далеко друг от друга. Если вы пытаетесь изменить объект const, вам будет намного лучше найти того, кто его объявил const в первом темпе, и обсудить с ними вопрос, чтобы достичь консенсуса относительно того, что должно произойти.
Это очень удобно ведет к назначениям. Вы можете назначить что-то только в том случае, если оно не const. Если вы хотите назначить что-то, что является константой, см. Выше. Помните, что в объявлениях int const *foo; и int * const bar; разные вещи const - другие ответы здесь очень хорошо отражают эту проблему, поэтому я не буду в нее входить.
Параметры функции:
Перейдите по значению: например. void func(int param) вам все равно, так или иначе, на вызывающем сайте. Можно утверждать, что существуют варианты использования функции как void func(int const param), но это не влияет на вызывающего, только на самой функции, поскольку любое переданное значение не может быть изменено функцией во время вызова.
Передача по ссылке: например. void func(int ¶m) Теперь это имеет значение. Как только объявлено, что func разрешено изменять param, и любой вызывающий сайт должен быть готов обработать последствия. Изменение объявления на void func(int const ¶m) изменяет контракт и гарантирует, что func теперь не может изменить param, то есть то, что передается, - это то, что вернется. Как отмечали другие, это очень полезно для дешевой передачи большого объекта, который вы не хотите изменять. Передача справки намного дешевле, чем передача большого объекта по значению.
Пропустить указатель: например. void func(int *param) и void func(int const *param) Эти два являются довольно синонимичными для их ссылочных копий, с оговоркой, что вызываемая функция теперь должна проверять nullptr, если какая-либо другая договорная гарантия не гарантирует func, что она никогда не получит nullptr in param.
Мнение по этой теме. Доказательство правильности в таком случае адски трудно, просто слишком просто сделать ошибку. Поэтому не рискуйте и всегда проверяйте параметры указателя для nullptr. Вы избавитесь от боли и страданий и сможете найти ошибки в долгосрочной перспективе. А что касается стоимости чека, то он дешевый, и в тех случаях, когда статический анализ, встроенный в компилятор, может управлять им, оптимизатор все равно его удалит. Включите генерацию кода временного кода для MSVC или WOPR (я думаю) для GCC, и вы получите его в виде программы в целом, то есть даже в вызове функций, пересекающих границу модуля исходного кода.
В конце дня все вышеизложенное делает очень надежный случай, когда всегда предпочитают ссылки на указатели. Они просто безопаснее повсюду.
Просто ради полноты для C, следуя другим объяснениям, не уверен для C++.
xint *p;int const *p;int * const p;int const * const p;int **pp;int ** const pp;int * const *pp;int const **pp;int * const * const pp;int const ** const pp;int const * const *pp;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);
Просто продолжай, но пусть человечество отлучит тебя.
int x = 10;
int *p = &x;
int **pp = &p;
int ***ppp = &pp;
int ****pppp = &ppp;
printf("%d \n", ****pppp);
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
Это предназначено для использования в основном в сигнатурах функций, чтобы гарантировать, что функция не сможет случайно изменить переданные аргументы.