Vị trí của dấu hoa thị trong khai báo con trỏ

Gần đây tôi đã quyết định rằng cuối cùng tôi cũng phải học C / C ++, và có một điều tôi không thực sự hiểu về con trỏ hay chính xác hơn là định nghĩa của chúng.

Làm thế nào về các ví dụ này:

1. int* test;
2. int *test;
3. int * test;
4. int* test,test2;
5. int *test,test2;
6. int * test,test2;

Bây giờ, theo sự hiểu biết của tôi, ba trường hợp đầu tiên đều hoạt động giống nhau: Kiểm tra không phải là một int, mà là một con trỏ tới một.

Bộ ví dụ thứ hai phức tạp hơn một chút. Trong trường hợp 4, cả test và test2 sẽ là con trỏ đến một int, trong khi trong trường hợp 5, chỉ test là một con trỏ, trong khi test2 là int "thực". Còn trường hợp 6 thì sao? Tương tự như trường hợp 5?

4, 5 và 6 giống nhau, chỉ có thử nghiệm là một con trỏ. Nếu bạn muốn có hai con trỏ, bạn nên sử dụng:

int *test, *test2;

Hoặc, thậm chí tốt hơn (để làm cho mọi thứ rõ ràng):

int* test;
int* test2;

Khoảng trắng xung quanh dấu hoa thị không có ý nghĩa. Cả ba đều có nghĩa giống nhau:

int* test;
int *test;
int * test;

" int *var1, var2" Là một cú pháp xấu chỉ nhằm mục đích gây nhầm lẫn cho mọi người và nên tránh. Nó mở rộng thành:

int *var1;
int var2;

Nhiều hướng dẫn mã hóa khuyên bạn chỉ nên khai báo một biến trên mỗi dòng . Điều này tránh bất kỳ sự nhầm lẫn nào về loại mà bạn đã có trước khi đặt câu hỏi này. Hầu hết các lập trình viên C ++ mà tôi đã từng làm việc dường như dính vào điều này.

Tôi biết một chút sang một bên, nhưng điều tôi thấy hữu ích là đọc ngược lại các khai báo.

int* test;   // test is a pointer to an int

Điều này bắt đầu hoạt động rất tốt, đặc biệt là khi bạn bắt đầu khai báo con trỏ const và khó biết đó là con trỏ đó là const, hay thứ mà con trỏ đang trỏ vào đó là const.

int* const test; // test is a const pointer to an int

int const * test; // test is a pointer to a const int ... but many people write this as  
const int * test; // test is a pointer to an int that's const

Sử dụng "Quy tắc xoắn ốc theo chiều kim đồng hồ" để giúp phân tích cú pháp các khai báo C / C ++;

Có ba bước đơn giản để làm theo:

1. Bắt đầu với phần tử chưa biết, di chuyển theo hướng xoắn ốc / chiều kim đồng hồ; khi gặp các yếu tố sau, hãy thay thế chúng bằng các câu lệnh tiếng Anh tương ứng:

   [X]hoặc []: Kích thước mảng X của ... hoặc Kích thước không xác định của mảng ...

   (type1, type2): hàm truyền kiểu1 và kiểu2 trả về ...

   *: (các) con trỏ tới ...

2. Tiếp tục làm điều này theo hướng xoắn ốc / chiều kim đồng hồ cho đến khi tất cả các thẻ đã được bao phủ.
3. Luôn giải quyết bất cứ điều gì trong ngoặc đơn trước!

Ngoài ra, khai báo nên ở trong các câu lệnh riêng biệt khi có thể (điều này đúng trong phần lớn thời gian).

Như những người khác đã đề cập, 4, 5 và 6 giống nhau. Thông thường, mọi người sử dụng những ví dụ này để đưa ra đối số rằng *thuộc về biến thay vì kiểu. Trong khi đó là một vấn đề về phong cách, có một số cuộc tranh luận về việc liệu bạn có nên nghĩ ra và viết nó theo cách này hay không:

int* x; // "x is a pointer to int"

hoặc theo cách này:

int *x; // "*x is an int"

FWIW Tôi đang ở trại đầu tiên, nhưng lý do những người khác đưa ra lập luận cho dạng thứ hai là nó (chủ yếu) giải quyết được vấn đề cụ thể này:

int* x,y; // "x is a pointer to int, y is an int"

mà có khả năng gây hiểu lầm; thay vào đó bạn sẽ viết

int *x,y; // it's a little clearer what is going on here

hoặc nếu bạn thực sự muốn hai con trỏ,

int *x, *y; // two pointers

Cá nhân tôi nói rằng hãy giữ nó ở một biến trên mỗi dòng, sau đó không quan trọng bạn thích phong cách nào.

#include <type_traits>

std::add_pointer<int>::type test, test2;

Trong 4, 5 và 6, testluôn luôn là một con trỏ và test2không phải là một con trỏ. Khoảng trắng (hầu như) không bao giờ quan trọng trong C ++.

Theo tôi, câu trả lời là CẢ HAI, tùy trường hợp. Nói chung, IMO, tốt hơn là đặt dấu hoa thị bên cạnh tên con trỏ, thay vì đặt loại. So sánh ví dụ:

int *pointer1, *pointer2; // Fully consistent, two pointers
int* pointer1, pointer2;  // Inconsistent -- because only the first one is a pointer, the second one is an int variable
// The second case is unexpected, and thus prone to errors

Tại sao trường hợp thứ hai không nhất quán? Vì vd int x,y;khai báo hai biến cùng kiểu nhưng kiểu chỉ được đề cập một lần trong khai báo. Điều này tạo ra một tiền lệ và hành vi được mong đợi. Và int* pointer1, pointer2;không phù hợp với điều đó vì nó khai báo pointer1như một con trỏ, nhưng pointer2là một biến số nguyên. Rõ ràng dễ mắc lỗi và do đó, nên tránh (bằng cách đặt dấu hoa thị bên cạnh tên con trỏ, thay vì loại).

Tuy nhiên , có một số trường hợp ngoại lệ mà bạn không thể đặt dấu hoa thị bên cạnh tên đối tượng (và vị trí quan trọng bạn đặt nó ở đâu) mà không nhận được kết quả không mong muốn - ví dụ:

MyClass *volatile MyObjName

void test (const char *const p) // const value pointed to by a const pointer

Cuối cùng, trong một số trường hợp, có thể rõ ràng hơn nếu đặt dấu hoa thị bên cạnh tên loại , ví dụ:

void* ClassName::getItemPtr () {return &item;} // Clear at first sight

Cơ sở lý luận trong C là bạn khai báo các biến theo cách bạn sử dụng chúng. Ví dụ

char *a[100];

nói rằng đó *a[42]sẽ là một char. Và a[42]một con trỏ char. Và do đó alà một mảng con trỏ char.

Điều này bởi vì những người viết trình biên dịch ban đầu muốn sử dụng cùng một trình phân tích cú pháp cho các biểu thức và khai báo. (Không phải là một lý do rất hợp lý cho sự lựa chọn thiết kế hành lang)

Tôi sẽ nói rằng quy ước ban đầu là đặt ngôi sao ở phía tên con trỏ (phía bên phải của khai báo

• trong ngôn ngữ lập trình c của Dennis M. Ritchie, các ngôi sao nằm ở phía bên phải của khai báo.

• bằng cách nhìn vào mã nguồn linux tại https://github.com/torvalds/linux/blob/master/init/main.c, chúng ta có thể thấy rằng ngôi sao cũng nằm ở phía bên phải.

Bạn có thể tuân theo các quy tắc tương tự, nhưng sẽ không phải là vấn đề lớn nếu bạn đặt các ngôi sao ở phía loại. Hãy nhớ rằng sự nhất quán là quan trọng, vì vậy hãy luôn luôn nhưng ngôi sao ở cùng một phía bất kể bạn chọn bên nào.

Con trỏ là một bổ ngữ cho kiểu. Tốt nhất bạn nên đọc chúng từ phải sang trái để hiểu rõ hơn cách dấu hoa thị sửa đổi loại. 'int *' có thể được đọc là "con trỏ tới int". Trong nhiều khai báo, bạn phải chỉ định rằng mỗi biến là một con trỏ hoặc nó sẽ được tạo như một biến chuẩn.

1,2 và 3) Kiểm tra có kiểu (int *). Khoảng trắng không quan trọng.

4,5 và 6) Kiểm tra có kiểu (int *). Test2 có kiểu int. Một lần nữa khoảng trắng là không quan trọng.

Một nguyên tắc chung, rất nhiều người dường như nắm bắt được những khái niệm này bởi: Trong C ++, rất nhiều ý nghĩa ngữ nghĩa được hình thành bởi sự ràng buộc bên trái của các từ khóa hoặc số nhận dạng.

Lấy ví dụ:

int const bla;

Hằng số áp dụng cho từ "int". Tương tự với dấu hoa thị của con trỏ, chúng áp dụng cho từ khóa bên trái của chúng. Và tên biến thực tế? Yup, điều đó được tuyên bố bởi những gì còn lại của nó.