Постоянный указатель vs Указатель на константу

Я хочу знать разницу между

const int* ptr;

int * const ptr;

и как это работает.

Мне сложно понять или запомнить это. Пожалуйста, помогите.

Ответ 1

const int* ptr;

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

const int a = 10;
const int* ptr = &a;  
*ptr = 5; // wrong
ptr++;    // right

Пока

int * const ptr;

объявляет ptr a const указатель на тип int. Вам не разрешено изменять ptr, но объект, на который указывает ptr.

int a = 10;
int *const ptr = &a;  
*ptr = 5; // right
ptr++;    // wrong

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

int const  *ptr; // ptr is a pointer to constant int 
int *const ptr;  // ptr is a constant pointer to int

Ответ 2

const int * ptr;

означает, что указанные данные являются постоянными и неизменяемыми, но указатель не является.

int * const ptr;

означает, что указатель является постоянным и неизменным, но зато указанными данными нет.

Ответ 3

1) Константные указатели: Эти типы указателей - это те, которые не могут изменить адрес, на который они указывают. Это означает, что предположим, что есть указатель, который указывает на переменную (или сохраняет адрес этой переменной). Теперь, если мы попытаемся указать указатель на какую-либо другую переменную (или попытаться сделать адрес хранилища указателей какой-либо другой переменной), то постоянные указатели неспособны к этому.

Указатель констант объявляется как: int *const ptr (расположение 'const' делает указатель 'ptr' постоянным указателем)

2) Указатель на константу: Этот тип указателей - тот, который не может изменить значение, на которое они указывают. Это означает, что они не могут изменить значение переменной, адрес которой они удерживают.

Указатель на константу объявляется как: const int *ptr (расположение 'const' делает указатель 'ptr' как указатель на константу.

Пример

Постоянный указатель

#include<stdio.h>

int main(void)
{
    int a[] = {10,11};
    int* const ptr = a;

    *ptr = 11;

    printf("\n value at ptr is  : [%d]\n",*ptr);
    printf("\n Address pointed by ptr  : [%p]\n",(unsigned int*)ptr);

    ptr++;
    printf("\n Address pointed by ptr  : [%p]\n",(unsigned int*)ptr);

    return 0;
}

Теперь, когда мы скомпилируем вышеуказанный код, компилятор жалуется:

practice # gcc -Wall constant_pointer.c -o constant_pointer
constant_pointer.c: In function ‘main’:
constant_pointer.c:13: error: increment of read-only variable ‘ptr’

Следовательно, мы видим очень четко выше, что компилятор жалуется, что мы не можем изменить адрес, удерживаемый постоянным указателем.

Указатель на константы

#include<stdio.h>

int main(void)
{
    int a = 10;
    const int* ptr = &a;


    printf("\n value at ptr is  : [%d]\n",*ptr);
    printf("\n Address pointed by ptr  : [%p]\n",(unsigned int*)ptr);

    *ptr = 11;

    return 0;
}

Теперь, когда вышеприведенный код скомпилирован, компилятор жалуется:

practice # gcc -Wall pointer_to_constant.c -o pointer_to_constant
pointer_to_constant.c: In function ‘main’:
pointer_to_constant.c:12: error: assignment of read-only location ‘*ptr’

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

Цитата

Ответ 4

Ссылка на Эта тема

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

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

Указатель констант объявляется следующим образом:
<type of pointer> * const <name of pointer>
Пример объявления будет выглядеть следующим образом:
int * const ptr;
Давайте возьмем небольшой код, чтобы проиллюстрировать эти типы указателей:

#include<stdio.h>

int main(void)
{
    int var1 = 0, var2 = 0;
    int *const ptr = &var1;
    ptr = &var2;
    printf("%d\n", *ptr);

    return 0;
}

В приведенном выше примере:

Мы объявили две переменные var1 и var2
Постоянный указатель 'ptr был объявлен и сделан для указания var1
Далее, ptr делается для указания var2.
Наконец, мы пытаемся напечатать значение, на которое указывает ptr.

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

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

Указатель на константу определяется как: const <type of pointer>* <name of pointer> Примером определения может быть: const int* ptr; Давайте возьмем небольшой код, чтобы проиллюстрировать указатель на константу:

 #include<stdio.h>

int main(void)
{
    int var1 = 0;
    const int* ptr = &var1;
    *ptr = 1;
    printf("%d\n", *ptr);

    return 0;
}

В приведенном выше коде:

Мы определили переменную var1 со значением 0
мы указали указатель на константу, которая указывает на переменную var1
Теперь через этот указатель мы попытались изменить значение var1
Используется printf для печати нового значения.

Ответ 5

const int* ptr;

- указатель на константу (содержимое). Вы можете изменить указатель. например ptr = NULL, ptr++, возможны модификации содержимого.

int * const ptr;

Является постоянным указателем. Возможно и обратное. Вам не разрешено изменять указатель, но вам не разрешено изменять то, на что оно указывает, например. *ptr += 5.

Ответ 6

int i;
int j;

int * const ptr1 = &i;

Компилятор остановит изменение ptr1.

const int * ptr2 = &i;

Компилятор остановит вас на изменение *ptr2.

ptr1 = &j; // error
*ptr1 = 7; // ok

ptr2 = &j; // ok
*ptr2 = 7; // error

Обратите внимание, что вы все равно можете изменить *ptr2, просто не буквально набрав *ptr2:

i = 4;
printf("before: %d\n", *ptr2); // prints 4
i = 5;
printf("after: %d\n", *ptr2); // prints 5
*ptr2 = 6; // still an error

У вас также может быть указатель с обеими функциями:

const int * const ptr3 = &i;

ptr3 = &j; // error
*ptr3 = 7; // error

Ответ 7

Пожалуйста, обратитесь к следующей ссылке, чтобы лучше понять разницу между указателем Const и указателем на постоянное значение.

константный указатель против указателя на постоянное значение

Ответ 8

const int* ptr; здесь думайте, как * ptr постоянна, и * ptr не может быть изменено снова

int * const ptr;, в то время как мы считаем, что ptr как константа, и это не может быть изменено снова