Tôi luôn luôn lộn xộn lên làm thế nào để sử dụng const int*, const int * constvà int const *chính xác. Có một bộ quy tắc xác định những gì bạn có thể và không thể làm?

Tôi muốn biết tất cả những việc cần làm và tất cả các quy định về nhiệm vụ, chuyển đến các chức năng, v.v.

Đọc ngược lại (như được điều khiển bởi Quy tắc theo chiều kim đồng hồ / xoắn ốc ):

• int* - con trỏ tới int
• int const * - con trỏ tới const int
• int * const - const con trỏ tới int
• int const * const - const con trỏ tới const int

Bây giờ đầu tiên constcó thể ở hai bên của loại vì vậy:

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

Nếu bạn muốn phát điên, bạn có thể làm những việc như thế này:

• int ** - con trỏ tới con trỏ tới int
• int ** const - một con trỏ const tới một con trỏ tới int
• int * const * - một con trỏ tới một con trỏ const tới một int
• int const ** - một con trỏ tới một con trỏ tới const int
• int * const * const - một con trỏ const tới một con trỏ const tới một int
• ...

Và để chắc chắn rằng chúng tôi rõ ràng về ý nghĩa của 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.           

foolà một con trỏ biến thành một số nguyên không đổi. Điều này cho phép bạn thay đổi những gì bạn trỏ đến nhưng không phải là giá trị mà bạn trỏ đến. Thông thường, điều này được nhìn thấy với các chuỗi kiểu C trong đó bạn có một con trỏ tới a const char. Bạn có thể thay đổi chuỗi nào bạn trỏ đến nhưng bạn không thể thay đổi nội dung của các chuỗi này. Điều này rất quan trọng khi chính chuỗi nằm trong phân đoạn dữ liệu của chương trình và không nên thay đổi.

barlà một con trỏ cố định hoặc cố định đến một giá trị có thể thay đổi. Đây giống như một tài liệu tham khảo mà không cần thêm cú pháp. Vì thực tế này, thông thường bạn sẽ sử dụng một tham chiếu trong đó bạn sẽ sử dụng một T* constcon trỏ trừ khi bạn cần cho phép các NULLcon trỏ.

Đối với những người không biết về Quy tắc theo chiều kim đồng hồ / xoắn ốc: Bắt đầu từ tên của biến, di chuyển đồng hồ chính xác (trong trường hợp này, di chuyển lùi) sang con trỏ hoặc loại tiếp theo . Lặp lại cho đến khi biểu thức kết thúc.

Đây là một bản demo:

Tôi nghĩ mọi thứ đã được trả lời ở đây rồi, nhưng tôi chỉ muốn nói thêm rằng bạn nên cẩn thận với typedefs! Họ KHÔNG chỉ thay thế văn bản.

Ví dụ:

typedef char *ASTRING;
const ASTRING astring;

Các loại astringlà char * const, không const char *. Đây là một lý do tôi luôn có xu hướng đặt constbên phải của loại, và không bao giờ bắt đầu.

Giống như khá nhiều người chỉ ra:

Sự khác biệt giữa const X* p, X* const pvà const X* const p?

Bạn phải đọc khai báo con trỏ từ phải sang trái.

• const X* p có nghĩa là "p trỏ đến X là const": đối tượng X không thể thay đổi thông qua p.

• X* const p có nghĩa là "p là một con trỏ const thành X không phải là const": bạn không thể tự thay đổi con trỏ p, nhưng bạn có thể thay đổi đối tượng X thông qua p.

• const X* const p có nghĩa là "p là con trỏ const thành X là const": bạn không thể tự thay đổi con trỏ p, cũng như không thể thay đổi đối tượng X qua p.

1. Tham khảo liên tục:

   Một tham chiếu đến một biến (ở đây int), là hằng số. Chúng tôi chuyển biến như một tham chiếu là chủ yếu, bởi vì các tham chiếu có kích thước nhỏ hơn giá trị thực, nhưng có một tác dụng phụ và đó là vì nó giống như một bí danh cho biến thực. Chúng tôi có thể vô tình thay đổi biến chính thông qua quyền truy cập đầy đủ vào bí danh, vì vậy chúng tôi làm cho nó không đổi để ngăn chặn tác dụng phụ này.

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

2. Con trỏ liên tục

   Khi một con trỏ không đổi trỏ đến một biến thì nó không thể trỏ đến bất kỳ biến nào khác.

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

3. Con trỏ đến hằng số

   Một con trỏ thông qua đó người ta không thể thay đổi giá trị của một biến mà nó trỏ được gọi là một con trỏ thành hằng số.

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

4. Con trỏ không đổi đến một hằng

   Một con trỏ không đổi thành hằng số là một con trỏ không thể thay đổi địa chỉ mà nó trỏ đến và cũng không thể thay đổi giá trị được giữ tại địa chỉ đó.

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

Nguyên tắc chung là consttừ khóa áp dụng cho những gì đi trước nó ngay lập tức. Ngoại lệ, một khởi đầu constáp dụng cho những gì sau.

• const int*là giống như int const*và có nghĩa là "con trỏ đến hằng int" .
• const int* constgiống như int const* constvà có nghĩa là "con trỏ không đổi đến hằng int" .

Chỉnh sửa: Đối với Dos và Don'ts, nếu câu trả lời này không đủ, bạn có thể chính xác hơn về những gì bạn muốn không?

Câu hỏi này cho thấy chính xác lý do tại sao tôi thích làm mọi thứ theo cách tôi đã đề cập trong câu hỏi của mình là const sau khi loại id được chấp nhận?

Nói tóm lại, tôi thấy cách dễ nhất để ghi nhớ quy tắc là "const" đi sau điều nó áp dụng. Vì vậy, trong câu hỏi của bạn, "int const *" có nghĩa là int không đổi, trong khi "int * const" có nghĩa là con trỏ không đổi.

Nếu ai đó quyết định đặt nó ở phía trước (ví dụ: "const int *"), như một ngoại lệ đặc biệt trong trường hợp đó, nó sẽ áp dụng cho điều sau nó.

Nhiều người thích sử dụng ngoại lệ đặc biệt đó vì họ nghĩ rằng nó trông đẹp hơn. Tôi không thích nó, bởi vì nó là một ngoại lệ, và do đó nhầm lẫn mọi thứ.

Sử dụng đơn giản const.

Việc sử dụng đơn giản nhất là khai báo một hằng số được đặt tên. Để làm điều này, người ta khai báo một hằng số như thể nó là một biến nhưng thêm vào consttrước nó. Người ta phải khởi tạo nó ngay lập tức trong hàm tạo bởi vì, tất nhiên, người ta không thể đặt giá trị sau này vì điều đó sẽ làm thay đổi nó. Ví dụ:

const int Constant1=96; 

sẽ tạo một hằng số nguyên, được gọi một cách đơn giản Constant1, với giá trị 96.

Các hằng số như vậy rất hữu ích cho các tham số được sử dụng trong chương trình nhưng không cần thay đổi sau khi chương trình được biên dịch. Nó có một lợi thế cho các lập trình viên so với #definelệnh tiền xử lý C ở chỗ nó được hiểu và sử dụng bởi chính trình biên dịch, không chỉ được thay thế vào văn bản chương trình bởi bộ tiền xử lý trước khi đến trình biên dịch chính, vì vậy các thông báo lỗi sẽ hữu ích hơn nhiều.

Nó cũng hoạt động với các con trỏ nhưng người ta phải cẩn thận constđể xác định xem con trỏ hoặc những gì nó trỏ đến là không đổi hoặc cả hai. Ví dụ:

const int * Constant2 

khai báo đó Constant2là con trỏ biến thành một số nguyên không đổi và:

int const * Constant2

là một cú pháp thay thế làm tương tự, trong khi

int * const Constant3

khai báo đó Constant3là con trỏ không đổi cho một số nguyên biến và

int const * const Constant4

tuyên bố đó Constant4là con trỏ không đổi đến một số nguyên không đổi. Về cơ bản, "const" áp dụng cho bất cứ điều gì ở bên trái của nó (trừ khi không có gì trong trường hợp đó, nó áp dụng cho bất cứ điều gì là quyền ngay lập tức của nó).

ref: http://duramecho.com/ComputerIn information / WhyHowCppConst.html

Tôi đã có cùng nghi ngờ với bạn cho đến khi tôi bắt gặp cuốn sách này của C ++ Guru Scott Meyers. Tham khảo Mục thứ ba trong cuốn sách này, nơi ông nói chi tiết về việc sử dụng const.

Chỉ cần làm theo lời khuyên này

1. Nếu từ constxuất hiện ở bên trái dấu hoa thị, những gì được chỉ ra là không đổi
2. Nếu từ constxuất hiện ở bên phải dấu hoa thị, thì chính con trỏ không đổi
3. Nếu constxuất hiện ở cả hai phía, cả hai đều không đổi

Nó đơn giản nhưng khó khăn. Xin lưu ý rằng chúng ta có thể trao đổi các constvòng loại với bất kỳ loại dữ liệu ( int, char, float, vv).

Hãy xem các ví dụ dưới đây.

const int *p==> *plà chỉ đọc [ plà một con trỏ tới một số nguyên không đổi]

int const *p==> *plà chỉ đọc [ plà một con trỏ tới một số nguyên không đổi]

int *p const==> Tuyên bố sai . Trình biên dịch ném lỗi cú pháp.

int *const p==> plà chỉ đọc [ plà một con trỏ không đổi đến một số nguyên]. Vì con trỏ pở đây là chỉ đọc, nên khai báo và định nghĩa phải ở cùng một chỗ.

const int *p const ==> Tuyên bố sai . Trình biên dịch ném lỗi cú pháp.

const int const *p ==> *plà chỉ đọc

const int *const p1 ==> *pvà pchỉ đọc [ plà một con trỏ không đổi đến một số nguyên không đổi]. Vì con trỏ pở đây là chỉ đọc, nên khai báo và định nghĩa phải ở cùng một chỗ.

int const *p const ==> Tuyên bố sai . Trình biên dịch ném lỗi cú pháp.

int const int *p ==> Tuyên bố sai . Trình biên dịch ném lỗi cú pháp.

int const const *p ==> *plà chỉ đọc và tương đương vớiint const *p

int const *const p ==> *pvà pchỉ đọc [ plà một con trỏ không đổi đến một số nguyên không đổi]. Vì con trỏ pở đây là chỉ đọc, nên khai báo và định nghĩa phải ở cùng một chỗ.

Có nhiều điểm tinh tế khác xung quanh tính chính xác của const trong C ++. Tôi cho rằng câu hỏi ở đây chỉ đơn giản là về C, nhưng tôi sẽ đưa ra một số ví dụ liên quan vì thẻ là C ++:

• Bạn thường truyền các đối số lớn như các chuỗi TYPE const &để ngăn đối tượng bị sửa đổi hoặc sao chép. Thí dụ :

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

  Nhưng TYPE & constlà vô nghĩa vì tài liệu tham khảo luôn là const.

• Bạn phải luôn luôn gắn nhãn các phương thức lớp không sửa đổi lớp là const, nếu không bạn không thể gọi phương thức từ TYPE const &tham chiếu. Thí dụ :

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

• Có những tình huống phổ biến trong đó cả giá trị trả về và phương thức nên là const. Thí dụ :

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

  Trong thực tế, các phương thức const không được trả về dữ liệu của lớp bên trong dưới dạng tham chiếu đến không-const.

• Kết quả là, người ta thường phải tạo cả phương thức const và phương thức không const bằng cách sử dụng quá tải const. Ví dụ: nếu bạn xác định T const& operator[] (unsigned i) const;, thì có lẽ bạn cũng sẽ muốn phiên bản không phải được cung cấp bởi:

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

Afaik, không có hàm const trong C, các hàm không phải là thành viên không thể là const trong C ++, các phương thức const có thể có tác dụng phụ và trình biên dịch không thể sử dụng các hàm const để tránh các lệnh gọi hàm trùng lặp. Trong thực tế, ngay cả một int const &tài liệu tham khảo đơn giản cũng có thể chứng kiến ​​giá trị mà nó đề cập đến được thay đổi ở nơi khác.

Cú pháp khai báo C và C ++ đã nhiều lần được mô tả là một thử nghiệm thất bại, bởi các nhà thiết kế ban đầu.

Thay vào đó, hãy đặt tên cho con trỏ kiểu kiểu thành tên lửa Type; Tôi sẽ gọi nó Ptr_:

template< class Type >
using Ptr_ = Type*;

Bây giờ Ptr_<char>là một con trỏ đến char.

Ptr_<const char>là một con trỏ tới const char.

Và const Ptr_<const char>là một constcon trỏ đến const char.

Đó

Đối với tôi, vị trí consttức là cho dù nó xuất hiện TRÁI hoặc PHẢI hoặc trên cả TRÁI và PHẢI liên quan đến việc *giúp tôi tìm ra ý nghĩa thực tế.

1. A constđến TRÁI *chỉ ra rằng đối tượng được trỏ bởi con trỏ là một constđối tượng.

2. A constđến QUYỀN *chỉ ra rằng con trỏ là constcon trỏ.

Bảng dưới đây được lấy từ Trình đọc khóa học Phòng thí nghiệm lập trình C ++ của Stanford CS106L.

Điều này chủ yếu giải quyết dòng thứ hai: thực tiễn tốt nhất, bài tập, tham số chức năng, vv

Luyện tập chung. Cố gắng làm mọi thứ constmà bạn có thể. Hoặc để nói theo cách khác, làm cho mọi thứ constbắt đầu, và sau đó loại bỏ chính xác bộ consts tối thiểu cần thiết để cho phép chương trình hoạt động. Đây sẽ là một trợ giúp lớn trong việc đạt được tính chính xác và sẽ giúp đảm bảo rằng các lỗi tinh vi không được giới thiệu khi mọi người thử và gán vào những thứ mà họ không cần phải sửa đổi.

Tránh const_cast <> như bệnh dịch hạch. Có một hoặc hai trường hợp sử dụng hợp pháp cho nó, nhưng chúng rất ít và xa giữa. Nếu bạn đang cố gắng thay đổi một constđối tượng, bạn sẽ làm tốt hơn rất nhiều để tìm bất cứ ai tuyên bố nó constở tốc độ đầu tiên và nói chuyện với họ để đạt được sự đồng thuận về những gì sẽ xảy ra.

Mà dẫn rất gọn gàng vào bài tập. Bạn chỉ có thể gán vào một cái gì đó nếu nó không phải là const. Nếu bạn muốn gán vào một cái gì đó là const, xem ở trên. Hãy nhớ rằng trong các tuyên bố int const *foo;và int * const bar;những điều khác nhau là const- các câu trả lời khác ở đây đã đề cập đến vấn đề đó một cách đáng ngưỡng mộ, vì vậy tôi sẽ không đi sâu vào nó.

Các tham số chức năng:

Truyền theo giá trị: ví dụ: void func(int param)bạn không quan tâm cách này hay cách khác tại trang web gọi điện. Đối số có thể được đưa ra là có các trường hợp sử dụng để khai báo hàm như void func(int const param)nhưng điều đó không có tác dụng đối với người gọi, chỉ đối với chính hàm đó, trong đó bất kỳ giá trị nào được truyền đều không thể thay đổi bởi hàm trong suốt cuộc gọi.

Chuyển qua tham chiếu: ví dụ: void func(int &param)Bây giờ nó làm cho một sự khác biệt. Như vừa tuyên bố funcđược phép thay đổi param, và bất kỳ trang web gọi điện nào cũng nên sẵn sàng để giải quyết hậu quả. Thay đổi tuyên bố để void func(int const &param)thay đổi hợp đồng và đảm bảo rằng funcbây giờ không thể thay đổi param, có nghĩa là những gì được thông qua là những gì sẽ trở lại. Như những người khác đã lưu ý rằng điều này rất hữu ích cho việc vượt qua một đối tượng lớn mà bạn không muốn thay đổi. Truyền tham chiếu rẻ hơn rất nhiều so với chuyển một đối tượng lớn theo giá trị.

Đi ngang qua con trỏ: ví dụ void func(int *param)và void func(int const *param)Hai là khá nhiều đồng nghĩa với các đối tác tham khảo của họ, với sự báo trước đó được gọi là chức năng hiện nay cần phải kiểm tra xem có nullptrtrừ một số đảm bảo việc bảo đảm hợp đồng khác funcmà nó sẽ không bao giờ nhận được một nullptrtrong param.

Ý kiến ​​về chủ đề đó. Chứng minh sự đúng đắn trong trường hợp như thế này là cực kỳ khó khăn, thật quá dễ để phạm sai lầm. Vì vậy, đừng nắm bắt cơ hội và luôn kiểm tra các tham số con trỏ nullptr. Bạn sẽ tự cứu mình khỏi nỗi đau và đau khổ và khó tìm ra lỗi trong thời gian dài. Và đối với chi phí kiểm tra, nó rất rẻ và trong trường hợp phân tích tĩnh được tích hợp trong trình biên dịch có thể quản lý nó, trình tối ưu hóa sẽ bỏ qua nó. Bật Tạo mã thời gian liên kết cho MSVC hoặc WOPR (tôi nghĩ) cho GCC và bạn sẽ có được chương trình rộng, tức là ngay cả trong các lệnh gọi chức năng vượt qua ranh giới mô-đun mã nguồn.

Vào cuối ngày, tất cả những điều trên tạo nên một trường hợp rất chắc chắn để luôn thích tham chiếu đến con trỏ. Họ chỉ an toàn hơn tất cả các vòng.

Các const với int ở hai bên sẽ làm cho con trỏ thành int int :

const int *ptr=&i;

hoặc là:

int const *ptr=&i;

constsau *sẽ tạo con trỏ liên tục đến int :

int *const ptr=&i;

Trong trường hợp này, tất cả chúng là con trỏ tới số nguyên không đổi , nhưng không có cái nào trong số này là con trỏ không đổi:

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

Trong trường hợp này, tất cả đều là con trỏ tới số nguyên không đổi và ptr2 là con trỏ không đổi thành số nguyên không đổi . Nhưng ptr1 không phải là con trỏ không đổi:

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

• nếu constlà ở phía bên trái của *, nó đề cập đến giá trị (nó không quan trọng cho dù đó là const inthay int const)
• nếu constlà ở bên phải của *nó, nó đề cập đến chính con trỏ
• nó có thể là cả hai cùng một lúc

Một điểm quan trọng: const int *p không có nghĩa là giá trị bạn đang đề cập là không đổi !! . Điều đó có nghĩa là bạn không thể thay đổi nó thông qua con trỏ đó (nghĩa là bạn không thể gán $ * p = ... `). Giá trị có thể được thay đổi theo những cách khác. Ví dụ

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

Điều này có nghĩa là được sử dụng chủ yếu trong chữ ký hàm, để đảm bảo rằng hàm không thể vô tình thay đổi các đối số được truyền.

Chỉ vì mục đích hoàn chỉnh cho C theo những giải thích khác, không chắc chắn cho C ++.

• pp - con trỏ tới con trỏ
• con trỏ p
• dữ liệu - điều được chỉ ra, trong các ví dụ x
• in đậm - biến chỉ đọc

Con trỏ

• dữ liệu p - int *p;
• dữ liệu p -int const *p;
• dữ liệu p -int * const p;
• dữ liệu p -int const * const p;

Con trỏ tới con trỏ

1. dữ liệu pp p - int **pp;
2. dữ liệu pp p -int ** const pp;
3. dữ liệu pp p -int * const *pp;
4. dữ liệu pp p -int const **pp;
5. dữ liệu pp p -int * const * const pp;
6. dữ liệu pp p -int const ** const pp;
7. dữ liệu pp p -int const * const *pp;
8. dữ liệu pp p -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-Dereference

Cứ tiếp tục, nhưng có thể nhân loại sẽ thông báo cho bạn.

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

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

1. const int*- con trỏ đến intđối tượng không đổi .

Bạn có thể thay đổi giá trị của con trỏ; bạn không thể thay đổi giá trị của intđối tượng, con trỏ trỏ tới.

2. const int * const- Con trỏ không đổi đến intđối tượng không đổi .

Bạn không thể thay đổi giá trị của con trỏ cũng như giá trị của intđối tượng mà con trỏ trỏ tới.

3. int const *- con trỏ đến intđối tượng không đổi .

Câu lệnh này tương đương với 1. const int*- Bạn có thể thay đổi giá trị của con trỏ nhưng bạn không thể thay đổi giá trị của intđối tượng, con trỏ trỏ tới.

Trên thực tế, có một lựa chọn thứ 4:

4. int * const- Con trỏ không đổi đến intđối tượng.

Bạn có thể thay đổi giá trị của đối tượng mà con trỏ trỏ tới nhưng bạn không thể thay đổi giá trị của chính con trỏ. Con trỏ sẽ luôn trỏ đến cùng một intđối tượng nhưng giá trị này của intđối tượng này có thể được thay đổi.

Nếu bạn muốn xác định một loại cấu trúc C hoặc C ++ nhất định, bạn có thể sử dụng Quy tắc theo chiều kim đồng hồ / xoắn ốc do David Anderson thực hiện; nhưng không nhầm lẫn với Quy tắc của Anderson được thực hiện bởi Ross J. Anderson, một điều khá khác biệt.