Tại sao nó an toàn hơn để sử dụng sizeof (* con trỏ) trong malloc

Question

Với

struct node 
{ 
    int a; 
    struct node * next; 
}; 

Để malloc một cấu trúc mới,

struct node *p = malloc(sizeof(*p)); 

là an toàn hơn

struct node *p = malloc(sizeof(struct node)); 

Tại sao? Tôi nghĩ chúng giống nhau.

Answer 1

Đó là an toàn hơn vì bạn không phải đề cập đến tên loại hai lần và không phải xây dựng chính tả thích hợp cho phiên bản "không tham chiếu" của loại. Ví dụ, bạn không cần phải "đếm những vì sao" trong

int *****p = malloc(100 * sizeof *p); 

so sánh với loại dựa trên sizeof trong

int *****p = malloc(100 * sizeof(int ****)); 

nơi bạn đã quá chắc chắn rằng bạn sử dụng đúng số * dưới sizeof.

Để chuyển sang loại khác, bạn chỉ phải thay đổi một địa điểm (khai báo p) thay vì hai. Và những người có thói quen đúc kết quả của malloc phải thay đổi ba địa điểm.

Nói chung, điều này có ý nghĩa rất nhiều khi tuân thủ nguyên tắc sau: nhập tên thuộc về khai báo và không có nơi nào khác. Các câu lệnh thực tế phải độc lập với loại. Họ nên tránh đề cập đến bất kỳ tên loại hoặc sử dụng bất kỳ tính năng loại cụ thể khác càng nhiều càng tốt.

Phương tiện sau có nghĩa là: Tránh phôi không cần thiết. Tránh cú pháp không đổi loại cụ thể không cần thiết (như 0.0 hoặc 0L trong đó một đồng bằng 0 sẽ đủ). Tránh đề cập đến tên loại dưới sizeof. Và cứ thế.

Answer 2

Bởi vì nếu tại một số điểm sau này trong thời gian p được thực hiện để trỏ đến một kiểu cấu trúc sau đó phân bổ tuyên bố bộ nhớ của bạn sử dụng malloc không nhất thiết phải thay đổi, nó vẫn phân bổ đủ bộ nhớ cần thiết cho việc mới loại. Nó đảm bảo:

• Bạn không phải sửa đổi tuyên bố phân bổ bộ nhớ mỗi khi bạn thay đổi loại nó phân bổ bộ nhớ.
• Mã của bạn mạnh mẽ hơn và ít bị lỗi thủ công hơn.

Nói chung, luôn luôn là một thực hành tốt để không dựa vào các loại cụ thể và biểu mẫu đầu tiên chỉ làm điều đó, nó không khó mã hóa một loại.

Answer 3

Đó là thuận lợi, bởi vì bạn có thể chuyển đổi này:

struct node *p= malloc(sizeof(*p)); 

Into này:

#define MALLOC(ptr) (ptr) = malloc(sizeof(*(ptr))) 

struct node *p; 
MALLOC(p); 

Hoặc, đối với một mảng:

#define MALLOC_ARR(ptr, arrsize) \ 
     (ptr) = malloc(sizeof(*(ptr)) * arrsize) 

struct node *p; 
MALLOC_ARR(p, 20); 

Và tại sao điều này là an toàn? Bởi vì người dùng sử dụng các macro này sẽ ít có khả năng phạm sai lầm đã được vạch ra bởi AndreyT, giống như trong trường hợp của DIM() để nhận được kích thước của một mảng tĩnh.

#define DIM(arr) ((sizeof(arr))/(sizeof(arr[0]))) 

Điều này cũng an toàn hơn, vì người dùng không cần phải làm cho kích thước mảng tĩnh phù hợp ở một vài nơi. Đặt kích thước mảng ở một nơi và sau đó chỉ cần sử dụng DIM() và bạn đã hoàn tất! Trình biên dịch sẽ xử lý nó cho bạn.

Answer 4

Nó không ảnh hưởng trực tiếp đến an toàn, nhưng người ta có thể khẳng định nó có thể ngăn chặn một lỗi trong bản sửa đổi trong tương lai. Mặt khác, rất dễ quên rằng *. Làm thế nào về làm cho nó một loại, nó chắc chắn là sạch hơn.

typedef struct node 
{ 
    int a; 
    struct node * next; 
} node_t; 

Sau đó, bạn có thể làm điều này:

node_t *p = malloc(sizeof(node_t));