Con trỏ không đổi so với Con trỏ tới hằng số [trùng lặp]

Tôi muốn biết sự khác biệt giữa

const int* ptr;

và

int * const ptr; 

và nó hoạt động như thế nào.

Tôi khá khó hiểu hoặc tiếp tục ghi nhớ điều này. Xin vui lòng giúp đỡ.

const int* ptr; 

khai báo ptrmột con trỏ để const intnhập. Bạn có thể ptrtự sửa đổi nhưng đối tượng được trỏ tới ptrsẽ không được sửa đổi.

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

Trong khi

int * const ptr;  

khai báo ptrmột constcon trỏ để intnhập. Bạn không được phép sửa đổi ptrnhưng đối tượng được trỏ đến ptrcó thể được sửa đổi.

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

Nói chung, tôi thích khai báo như thế này để dễ đọc và dễ hiểu (đọc từ phải sang trái):

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

const int * ptr;

có nghĩa là dữ liệu trỏ là không đổi và không thay đổi nhưng con trỏ thì không.

int * const ptr;

có nghĩa là con trỏ là hằng số và bất biến nhưng dữ liệu trỏ thì không.

1) Con trỏ không đổi: Loại con trỏ này là loại con trỏ không thể thay đổi địa chỉ mà chúng đang trỏ tới. Điều này có nghĩa là giả sử có một con trỏ trỏ đến một biến (hoặc lưu trữ địa chỉ của biến đó). Bây giờ nếu chúng ta cố gắng trỏ con trỏ đến một số biến khác (hoặc cố gắng tạo địa chỉ lưu trữ con trỏ của một số biến khác), thì các con trỏ hằng không thể thực hiện được điều này.

Một con trỏ hằng được khai báo là: int *const ptr(vị trí của 'const' làm cho con trỏ 'ptr' là con trỏ hằng)

2) Con trỏ đến Hằng số: Loại con trỏ này là loại con trỏ không thể thay đổi giá trị mà chúng đang trỏ tới. Điều này có nghĩa là họ không thể thay đổi giá trị của biến có địa chỉ mà họ đang giữ.

Một con trỏ tới một hằng được khai báo là: const int *ptr(vị trí của 'const' làm cho con trỏ 'ptr' là một con trỏ tới hằng.

Thí dụ

Con trỏ không đổi

#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;
}

Bây giờ, khi chúng tôi biên dịch đoạn mã trên, trình biên dịch phàn nàn:

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’

Do đó, chúng ta thấy rất rõ ở trên rằng trình biên dịch phàn nàn rằng chúng ta không thể thay đổi địa chỉ được giữ bởi một con trỏ hằng.

Con trỏ đến Hằng số

#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;
}

Bây giờ, khi đoạn mã trên được biên dịch, trình biên dịch phàn nàn:

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’

Do đó ở đây chúng ta cũng thấy rằng trình biên dịch không cho phép con trỏ tới một hằng số để thay đổi giá trị của biến được trỏ.

Bảng báo giá

Giới thiệu từ This Thread

Con trỏ không đổi

Đầu tiên chúng ta hãy hiểu con trỏ hằng là gì. Con trỏ hằng là một con trỏ không thể thay đổi địa chỉ mà nó đang nắm giữ. Nói cách khác, chúng ta có thể nói rằng một khi một con trỏ hằng trỏ đến một biến thì nó không thể trỏ đến bất kỳ biến nào khác.

Một con trỏ hằng được khai báo như sau:
<type of pointer> * const <name of pointer>
Một khai báo ví dụ sẽ giống như sau:
int * const ptr;
Hãy lấy một đoạn mã nhỏ để minh họa các loại con trỏ này:

#include<stdio.h>

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

    return 0;
} 

Trong ví dụ trên:

• Chúng tôi đã khai báo hai biến var1 và var2
  
• Một con trỏ hằng 'ptr' đã được khai báo và tạo thành điểm var1
  
• Tiếp theo, ptr được tạo thành điểm var2.
  
• Cuối cùng, chúng tôi cố gắng in giá trị ptr đang trỏ đến.
  

Con trỏ đến Hằng số

Rõ ràng từ cái tên, một con trỏ mà qua đó người ta không thể thay đổi giá trị của biến mà nó trỏ đến được gọi là một con trỏ đến hằng số. Các loại con trỏ này có thể thay đổi địa chỉ mà chúng trỏ đến nhưng không thể thay đổi giá trị được lưu giữ tại các địa chỉ đó.

Một con trỏ tới hằng số được định nghĩa là: const <type of pointer>* <name of pointer> Một ví dụ về định nghĩa có thể là: const int* ptr; Hãy lấy một đoạn mã nhỏ để minh họa một con trỏ đến một hằng số:

 #include<stdio.h>

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

    return 0;
} 

Trong đoạn mã trên:

• Chúng tôi đã xác định một biến var1 với giá trị 0
• chúng tôi đã xác định một con trỏ đến một hằng số trỏ đến biến var1
• Bây giờ, thông qua con trỏ này, chúng tôi đã cố gắng thay đổi giá trị của var1
• Đã sử dụng printf để in giá trị mới.

const int* ptr;

là một con trỏ đến hằng số (nội dung). Bạn được phép sửa đổi con trỏ. ví dụ ptr = NULL, ptr++nhưng thay đổi nội dung là không có thể.

int * const ptr;

Là một con trỏ hằng. Điều ngược lại là có thể. Bạn không được phép sửa đổi con trỏ, nhưng bạn được phép sửa đổi những gì nó trỏ tới ví dụ *ptr += 5.

int i;
int j;

int * const ptr1 = &i;

Trình biên dịch sẽ ngăn bạn thay đổi ptr1.

const int * ptr2 = &i;

Trình biên dịch sẽ ngăn bạn thay đổi *ptr2.

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

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

Lưu ý rằng bạn vẫn có thể thay đổi *ptr2, không chỉ bằng cách nhập theo nghĩa đen *ptr2:

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

Bạn cũng có thể có một con trỏ với cả hai tính năng:

const int * const ptr3 = &i;

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

Vui lòng tham khảo liên kết sau để hiểu rõ hơn về sự khác biệt giữa con trỏ Const và con trỏ trên một giá trị không đổi.

con trỏ hằng so với con trỏ trên một giá trị không đổi

const int* ptr; ở đây nghĩ như * ptr là không đổi và * ptr không thể thay đổi lại

int * const ptr; trong khi ở đây nghĩ như ptr như một hằng số và không thể thay đổi lại được