Tôi có bỏ kết quả của malloc không?

Trong câu hỏi này , ai đó đã đề xuất trong một nhận xét rằng tôi không nên đưa ra kết quả malloc, tức là

int *sieve = malloc(sizeof(int) * length);

thay vì:

int *sieve = (int *) malloc(sizeof(int) * length);

Tại sao nó lại là vấn đề?

Không ; bạn không bỏ kết quả, vì:

• Nó là không cần thiết, như void *được tự động và được quảng bá an toàn cho bất kỳ loại con trỏ nào khác trong trường hợp này.
• Nó thêm lộn xộn vào mã, phôi không dễ đọc lắm (đặc biệt nếu loại con trỏ dài).
• Nó làm cho bạn lặp lại chính mình, mà nói chung là xấu.
• Nó có thể ẩn một lỗi nếu bạn quên bao gồm <stdlib.h>. Điều này có thể gây ra sự cố (hoặc tệ hơn là không gây ra sự cố cho đến khi về sau trong một số phần hoàn toàn khác của mã). Xem xét những gì xảy ra nếu con trỏ và số nguyên có kích thước khác nhau; sau đó bạn đang ẩn một cảnh báo bằng cách truyền và có thể mất bit của địa chỉ trả lại của bạn. Lưu ý: kể từ C99, các hàm ẩn đã biến mất khỏi C và điểm này không còn phù hợp nữa vì không có giả định tự động rằng các hàm không được khai báo sẽ trả về int.

Để làm rõ, lưu ý rằng tôi đã nói "bạn không được chọn", không phải "bạn không cần phải phân vai". Theo tôi, đó là một thất bại trong việc bao gồm các diễn viên, ngay cả khi bạn đã làm đúng. Đơn giản là không có lợi ích gì khi thực hiện nó, nhưng một loạt các rủi ro tiềm ẩn và bao gồm cả dàn diễn viên cho thấy bạn không biết về các rủi ro.

Cũng lưu ý, như các nhà bình luận chỉ ra, những điều trên nói về C thẳng chứ không phải C ++. Tôi rất tin tưởng vào C và C ++ như các ngôn ngữ riêng biệt.

Để thêm nữa, mã của bạn không cần lặp lại thông tin loại ( int) có thể gây ra lỗi. Tốt hơn là nên tham chiếu lại con trỏ đang được sử dụng để lưu trữ giá trị trả về, để "khóa" hai cái lại với nhau:

int *sieve = malloc(length * sizeof *sieve);

Điều này cũng di chuyển ra lengthphía trước để tăng khả năng hiển thị và giảm các dấu ngoặc thừa sizeof; chúng chỉ cần thiết khi đối số là tên loại. Nhiều người dường như không biết (hoặc bỏ qua) điều này, điều này làm cho mã của họ dài dòng hơn. Hãy nhớ rằng: sizeofkhông phải là một chức năng! :)

Mặc dù di chuyển lengthra phía trước có thể làm tăng khả năng hiển thị trong một số trường hợp hiếm gặp, người ta cũng nên chú ý rằng trong trường hợp chung, tốt hơn nên viết biểu thức như sau:

int *sieve = malloc(sizeof *sieve * length);

Kể từ khi giữ sizeofđầu tiên, trong trường hợp này, đảm bảo phép nhân được thực hiện với ít nhất là size_ttoán học.

So sánh: malloc(sizeof *sieve * length * width)so với malloc(length * width * sizeof *sieve)lần thứ hai có thể tràn length * widthkhi widthvà lengthlà loại nhỏ hơn size_t.

Trong C, bạn không cần bỏ giá trị trả về malloc. Con trỏ đến void được trả về mallocđược tự động chuyển đổi thành đúng loại. Tuy nhiên, nếu bạn muốn mã của mình biên dịch bằng trình biên dịch C ++, thì cần phải sử dụng cast. Một lựa chọn ưu tiên trong cộng đồng là sử dụng như sau:

int *sieve = malloc(sizeof *sieve * length);

điều này cũng giải phóng bạn khỏi phải lo lắng về việc thay đổi phía bên phải của biểu thức nếu bạn thay đổi kiểu sieve.

Diễn viên là xấu, như mọi người đã chỉ ra. Đặc biệt là phôi con trỏ.

Bạn làm diễn viên, bởi vì:

• Nó làm cho mã của bạn dễ di chuyển hơn giữa C và C ++, và như kinh nghiệm SO cho thấy, rất nhiều lập trình viên tuyên bố họ đang viết bằng C khi họ thực sự viết bằng C ++ (hoặc C cộng với các phần mở rộng trình biên dịch cục bộ).
• Không làm như vậy có thể ẩn một lỗi : lưu ý tất cả các ví dụ SO gây nhầm lẫn khi viết type *so với type **.
• Ý tưởng rằng nó khiến bạn không nhận ra bạn đã thất bại với #includemột tệp tiêu đề thích hợp bỏ lỡ rừng cho cây . Nó cũng giống như câu nói "đừng lo lắng về thực tế bạn đã thất bại khi yêu cầu trình biên dịch phàn nàn về việc không nhìn thấy các nguyên mẫu - rằng stdlib pesky đó là điều quan trọng THỰC SỰ cần nhớ!"
• Nó buộc phải kiểm tra chéo nhận thức thêm . Nó đặt loại mong muốn (bị cáo buộc) ngay bên cạnh số học bạn đang làm cho kích thước thô của biến đó. Tôi cá là bạn có thể thực hiện một nghiên cứu SO chỉ ra rằng malloc()bọ bị bắt nhanh hơn nhiều khi có diễn viên. Như với các xác nhận, các chú thích tiết lộ ý định giảm lỗi.
• Lặp đi lặp lại bản thân theo cách mà máy có thể kiểm tra thường là một ý tưởng tuyệt vời . Trên thực tế, đó là những gì một khẳng định là, và việc sử dụng diễn viên này là một khẳng định. Các xác nhận vẫn là kỹ thuật chung nhất mà chúng ta có để lấy mã chính xác, vì Turing đã đưa ra ý tưởng từ nhiều năm trước.

Như những người khác đã nêu, nó không cần thiết cho C, nhưng cần thiết cho C ++. Nếu bạn nghĩ rằng bạn sẽ biên dịch mã C của mình bằng trình biên dịch C ++, vì bất kỳ lý do gì, bạn có thể sử dụng macro thay thế, như:

#ifdef __cplusplus
# define NEW(type, count) ((type *)calloc(count, sizeof(type)))
#else
# define NEW(type, count) (calloc(count, sizeof(type)))
#endif

Bằng cách đó bạn vẫn có thể viết nó một cách rất nhỏ gọn:

int *sieve = NEW(int, 1);

và nó sẽ biên dịch cho C và C ++.

Từ Wikipedia :

Ưu điểm để đúc

• Bao gồm các diễn viên có thể cho phép một chương trình hoặc chức năng C biên dịch thành C ++.

• Dàn diễn viên cho phép các phiên bản trước của 1989 của malloc ban đầu trả về char *.

• Việc truyền có thể giúp nhà phát triển xác định sự không nhất quán trong việc định cỡ kiểu khi loại con trỏ đích thay đổi, đặc biệt nếu con trỏ được khai báo cách xa lệnh gọi malloc () (mặc dù trình biên dịch hiện đại và máy phân tích tĩnh có thể cảnh báo hành vi đó mà không yêu cầu ép kiểu).

Nhược điểm để đúc

• Theo tiêu chuẩn ANSI C, dàn diễn viên là dự phòng.

• Thêm diễn viên có thể che dấu thất bại để bao gồm tiêu đề stdlib.h, trong đó nguyên mẫu cho malloc được tìm thấy. Trong trường hợp không có nguyên mẫu cho malloc, tiêu chuẩn yêu cầu trình biên dịch C giả sử malloc trả về một int. Nếu không có cast, một cảnh báo được đưa ra khi số nguyên này được gán cho con trỏ; tuy nhiên, với các diễn viên, cảnh báo này không được tạo ra, ẩn một lỗi. Trên một số kiến ​​trúc và mô hình dữ liệu nhất định (chẳng hạn như LP64 trên các hệ thống 64 bit, trong đó các con trỏ dài và 64 bit và int là 32 bit), lỗi này thực sự có thể dẫn đến hành vi không xác định, vì malloc được khai báo ngầm trả về 32- giá trị bit trong khi hàm thực sự được xác định trả về giá trị 64 bit. Tùy thuộc vào các quy ước gọi và bố trí bộ nhớ, điều này có thể dẫn đến phá vỡ ngăn xếp. Vấn đề này ít có khả năng không được chú ý trong các trình biên dịch hiện đại, khi chúng thống nhất đưa ra các cảnh báo rằng một chức năng chưa được khai báo đã được sử dụng, do đó, một cảnh báo sẽ vẫn xuất hiện. Ví dụ, hành vi mặc định của GCC là hiển thị cảnh báo có nội dung "khai báo ngầm định không tương thích của chức năng tích hợp" bất kể diễn viên có mặt hay không.

• Nếu loại con trỏ bị thay đổi khi khai báo, người ta cũng có thể, cần thay đổi tất cả các dòng nơi malloc được gọi và truyền.

Mặc dù malloc mà không cần đúc là phương pháp ưa thích và hầu hết các lập trình viên có kinh nghiệm đều chọn nó , bạn nên sử dụng bất cứ điều gì bạn muốn khi biết về các vấn đề.

tức là: Nếu bạn cần biên dịch chương trình C thành C ++ (Mặc dù đó là một ngôn ngữ riêng), bạn phải bỏ kết quả sử dụng malloc.

Trong C, bạn có thể chuyển đổi một voidcon trỏ thành bất kỳ loại con trỏ nào khác, do đó không cần thiết phải sử dụng. Sử dụng một người có thể gợi ý cho người quan sát thông thường rằng có một số lý do tại sao một người cần thiết, có thể gây hiểu nhầm.

Bạn không bỏ kết quả của malloc, vì làm như vậy sẽ thêm sự lộn xộn vô nghĩa vào mã của bạn.

Lý do phổ biến nhất khiến mọi người bỏ kết quả của malloc là vì họ không chắc chắn về cách thức hoạt động của ngôn ngữ C. Đó là một dấu hiệu cảnh báo: nếu bạn không biết cơ chế ngôn ngữ cụ thể hoạt động như thế nào, thì đừng đoán. Nhìn lên hoặc hỏi về Stack Overflow.

Một vài bình luận:

• Một con trỏ void có thể được chuyển đổi thành / từ bất kỳ loại con trỏ nào khác mà không cần truyền rõ ràng (C11 6.3.2.3 và 6.5.16.1).

• Tuy nhiên, C ++ sẽ không cho phép một kiểu ẩn giữa void*và một loại con trỏ khác. Vì vậy, trong C ++, dàn diễn viên đã đúng. Nhưng nếu bạn lập trình trong C ++, bạn nên sử dụng newchứ không phải malloc (). Và bạn không bao giờ nên biên dịch mã C bằng trình biên dịch C ++.

  Nếu bạn cần hỗ trợ cả C và C ++ với cùng một mã nguồn, hãy sử dụng các trình chuyển đổi trình biên dịch để đánh dấu sự khác biệt. Không tìm cách sắp xếp cả hai tiêu chuẩn ngôn ngữ với cùng một mã, vì chúng không tương thích.

• Nếu trình biên dịch C không thể tìm thấy hàm vì bạn quên bao gồm tiêu đề, bạn sẽ gặp lỗi trình biên dịch / trình liên kết về điều đó. Vì vậy, nếu bạn quên bao gồm <stdlib.h>điều đó không có gì to tát, bạn sẽ không thể xây dựng chương trình của mình.

• Trên các trình biên dịch cổ đại tuân theo một phiên bản của tiêu chuẩn hơn 25 năm tuổi, việc quên đưa vào <stdlib.h>sẽ dẫn đến hành vi nguy hiểm. Bởi vì trong tiêu chuẩn cổ xưa đó, các hàm không có nguyên mẫu có thể nhìn thấy đã chuyển đổi kiểu trả về thành int. Đúc kết quả từ malloc rõ ràng sau đó sẽ che giấu lỗi này.

  Nhưng đó thực sự là một vấn đề không. Bạn không sử dụng máy tính 25 tuổi, vậy tại sao bạn lại sử dụng trình biên dịch 25 tuổi?

Trong C, bạn nhận được một chuyển đổi ngầm định từ void *bất kỳ con trỏ (dữ liệu) nào khác.

malloc()Hiện tại, việc truyền giá trị được trả về là không cần thiết, nhưng tôi muốn thêm một điểm mà dường như không ai chỉ ra:

Vào thời cổ đại, nghĩa là, trước khi ANSI C cung cấp void *loại con trỏ chung, char *là loại cho việc sử dụng đó. Trong trường hợp đó, các diễn viên có thể tắt các cảnh báo của trình biên dịch.

Tham khảo: C FAQ

Chỉ cần thêm kinh nghiệm của tôi, nghiên cứu về kỹ thuật máy tính, tôi thấy rằng hai hoặc ba giáo sư mà tôi đã thấy viết bằng C luôn đúc malloc, tuy nhiên người tôi đã hỏi (với một CV lớn và hiểu biết về C) nói với tôi rằng nó hoàn toàn không cần thiết nhưng chỉ được sử dụng để hoàn toàn cụ thể, và để có được các sinh viên vào tâm lý là hoàn toàn cụ thể. Về cơ bản, việc truyền sẽ không thay đổi bất cứ điều gì trong cách hoạt động của nó, nó thực hiện chính xác những gì nó nói, phân bổ bộ nhớ và truyền không ảnh hưởng đến nó, bạn có cùng bộ nhớ và ngay cả khi bạn nhầm lẫn với một thứ khác (và bằng cách nào đó trốn tránh trình biên dịch lỗi) C sẽ truy cập nó theo cùng một cách.

Chỉnh sửa: Đúc có một điểm nhất định. Khi bạn sử dụng ký hiệu mảng, mã được tạo phải biết có bao nhiêu bộ nhớ phải tăng để đạt đến điểm bắt đầu của phần tử tiếp theo, điều này đạt được thông qua việc truyền. Bằng cách này, bạn biết rằng đối với một nhân đôi, bạn đi trước 8 byte trong khi đối với một int bạn đi 4, v.v. Do đó, nó không có tác dụng nếu bạn sử dụng ký hiệu con trỏ, trong ký hiệu mảng, nó trở nên cần thiết.

Không bắt buộc phải truyền kết quả malloc, vì nó trả về void*và void*có thể được trỏ đến bất kỳ kiểu dữ liệu nào.

Một con trỏ void là một con trỏ đối tượng chung và C hỗ trợ chuyển đổi ngầm định từ một loại con trỏ void sang các loại khác, do đó không cần phải đánh máy một cách rõ ràng.

Tuy nhiên, nếu bạn muốn cùng một mã hoạt động hoàn toàn tương thích trên nền tảng C ++, không hỗ trợ chuyển đổi ngầm định, bạn cần thực hiện kiểu chữ, vì vậy tất cả phụ thuộc vào khả năng sử dụng.

Đây là những gì Hướng dẫn tham khảo thư viện GNU C nói:

Bạn có thể lưu trữ kết quả mallocvào bất kỳ biến con trỏ nào mà không cần truyền, vì ISO C tự động chuyển đổi loại void *thành loại con trỏ khác khi cần thiết. Nhưng dàn diễn viên là cần thiết trong các ngữ cảnh khác với toán tử gán hoặc nếu bạn có thể muốn mã của mình chạy trong C. truyền thống.

Và thực sự, tiêu chuẩn ISO C11 (p347) đã nói như vậy:

Con trỏ được trả về nếu phân bổ thành công được căn chỉnh phù hợp để nó có thể được gán cho một con trỏ tới bất kỳ loại đối tượng nào có yêu cầu căn chỉnh cơ bản và sau đó được sử dụng để truy cập vào một đối tượng hoặc một mảng các đối tượng đó trong không gian được phân bổ (cho đến khi không gian được giải quyết rõ ràng)

Kiểu được trả về là void *, có thể được truyền tới loại con trỏ dữ liệu mong muốn để có thể điều chỉnh được.

Trong ngôn ngữ C, một con trỏ void có thể được gán cho bất kỳ con trỏ nào, đó là lý do tại sao bạn không nên sử dụng kiểu đúc. Nếu bạn muốn phân bổ "loại an toàn", tôi có thể đề xuất các hàm macro sau, mà tôi luôn sử dụng trong các dự án C của mình:

#include <stdlib.h>
#define NEW_ARRAY(ptr, n) (ptr) = malloc((n) * sizeof *(ptr))
#define NEW(ptr) NEW_ARRAY((ptr), 1)

Với những thứ này, bạn có thể nói một cách đơn giản

NEW_ARRAY(sieve, length);

Đối với mảng không động, macro hàm phải có thứ ba là

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

mà làm cho các vòng lặp mảng an toàn hơn và thuận tiện hơn:

int i, a[100];

for (i = 0; i < LEN(a); i++) {
   ...
}

Nó phụ thuộc vào ngôn ngữ lập trình và trình biên dịch. Nếu bạn sử dụng malloctrong C, không cần phải nhập cast, vì nó sẽ tự động gõ cast. Tuy nhiên, nếu bạn đang sử dụng C ++, thì bạn nên gõ cast vì mallocsẽ trả về một void*kiểu.

Mọi người đã từng sử dụng GCC và Clang đều hư hỏng. Đó không phải là tất cả những gì tốt đẹp ngoài đó.

Tôi đã khá kinh hoàng trong những năm qua bởi các trình biên dịch có độ tuổi đáng kinh ngạc mà tôi được yêu cầu sử dụng. Thông thường các công ty và nhà quản lý áp dụng cách tiếp cận cực kỳ bảo thủ để thay đổi trình biên dịch và thậm chí sẽ không kiểm tra xem trình biên dịch mới (có tuân thủ tiêu chuẩn và tối ưu hóa mã tốt hơn) sẽ hoạt động trong hệ thống của họ hay không. Thực tế thực tế cho các nhà phát triển đang làm việc là khi bạn viết mã, bạn cần phải bao gồm các cơ sở của mình và thật không may, việc chọn mallocs là một thói quen tốt nếu bạn không thể kiểm soát trình biên dịch nào có thể được áp dụng cho mã của mình.

Tôi cũng sẽ đề nghị rằng nhiều tổ chức áp dụng một tiêu chuẩn mã hóa của riêng họ và đó phải là phương pháp mà mọi người tuân theo nếu nó được xác định. Trong trường hợp không có hướng dẫn rõ ràng, tôi có xu hướng tìm cách biên dịch ở khắp mọi nơi, thay vì tuân thủ một tiêu chuẩn.

Lập luận rằng nó không cần thiết theo các tiêu chuẩn hiện tại là khá hợp lệ. Nhưng lập luận đó bỏ qua thực tiễn của thế giới thực. Chúng tôi không viết mã trong một thế giới được cai trị độc quyền theo tiêu chuẩn trong ngày, mà bởi tính thực tiễn của cái mà tôi muốn gọi là "lĩnh vực thực tế của quản lý địa phương". Và đó là uốn cong và xoắn hơn thời gian không gian từng có. :-)

YMMV.

Tôi có xu hướng nghĩ về việc đúc malloc như một hoạt động phòng thủ. Không xinh, không hoàn hảo, nhưng nói chung là an toàn. (Thành thật mà nói, nếu bạn đã không bao gồm stdlib.h sau đó bạn đã cách nhiều vấn đề hơn so với đúc malloc!).

Tôi đưa vào dàn diễn viên chỉ đơn giản là thể hiện sự không tán thành lỗ hổng xấu xí trong hệ thống loại, cho phép mã như đoạn mã sau để biên dịch mà không cần chẩn đoán, mặc dù không có phôi nào được sử dụng để mang lại chuyển đổi xấu:

double d;
void *p = &d;
int *q = p;

Tôi ước điều đó không tồn tại (và nó không có trong C ++) và vì vậy tôi đã chọn. Nó đại diện cho sở thích của tôi, và chính trị lập trình của tôi. Tôi không chỉ đúc một con trỏ, mà còn hiệu quả, bỏ phiếu, và đuổi quỷ ngu ngốc . Nếu tôi thực sự không thể thể hiện sự ngu ngốc , thì ít nhất hãy để tôi bày tỏ mong muốn làm điều đó bằng một cử chỉ phản kháng.

Trong thực tế, một cách thực hành tốt là bọc malloc(và bạn bè) với các hàm trả về unsigned char *và về cơ bản không bao giờ sử dụng void *trong mã của bạn. Nếu bạn cần một con trỏ chung cho bất kỳ đối tượng nào, hãy sử dụng một char *hoặc unsigned char *và có các phôi theo cả hai hướng. Một thư giãn có thể được thưởng thức, có lẽ, là sử dụng các chức năng như memsetvà memcpykhông có phôi.

Về chủ đề truyền và tương thích C ++, nếu bạn viết mã của mình để nó biên dịch thành cả C và C ++ (trong trường hợp đó bạn phải truyền giá trị trả về mallockhi gán nó cho một thứ khác void *), bạn có thể làm rất hữu ích điều cho bản thân bạn: bạn có thể sử dụng các macro để truyền mà dịch sang các kiểu kiểu C ++ khi biên dịch thành C ++, nhưng giảm xuống thành một biểu tượng C khi biên dịch thành C:

/* In a header somewhere */
#ifdef __cplusplus
#define strip_qual(TYPE, EXPR) (const_cast<TYPE>(EXPR))
#define convert(TYPE, EXPR) (static_cast<TYPE>(EXPR))
#define coerce(TYPE, EXPR) (reinterpret_cast<TYPE>(EXPR))
#else
#define strip_qual(TYPE, EXPR) ((TYPE) (EXPR))
#define convert(TYPE, EXPR) ((TYPE) (EXPR))
#define coerce(TYPE, EXPR) ((TYPE) (EXPR))
#endif

Nếu bạn tuân thủ các macro này, thì một greptìm kiếm đơn giản về cơ sở mã của bạn cho các mã định danh này sẽ cho bạn biết vị trí của tất cả các phôi của bạn, vì vậy bạn có thể xem lại bất kỳ trong số chúng là không chính xác.

Sau đó, về phía trước, nếu bạn thường xuyên biên dịch mã bằng C ++, nó sẽ thực thi việc sử dụng một dàn diễn viên phù hợp. Chẳng hạn, nếu bạn strip_qualchỉ sử dụng để loại bỏ một consthoặc volatile, nhưng chương trình thay đổi theo cách liên quan đến chuyển đổi loại, bạn sẽ nhận được chẩn đoán và bạn sẽ phải sử dụng kết hợp các phôi để có được chuyển đổi mong muốn.

Để giúp bạn tuân thủ các macro này, trình biên dịch GNU C ++ (không phải C!) Có một tính năng tuyệt vời: một chẩn đoán tùy chọn được tạo cho tất cả các lần xuất hiện của kiểu phôi C.

     -Wold-style-cast (chỉ C ++ và Objective-C ++)
         Cảnh báo nếu sử dụng kiểu cũ (kiểu C) sang loại không trống
         trong một chương trình C ++. Các phôi kiểu mới (Dynamic_cast,
         static_cast, reinterpret_cast và const_cast) ít bị tổn thương hơn
         để các hiệu ứng ngoài ý muốn và dễ dàng hơn để tìm kiếm.

Nếu mã C của bạn biên dịch thành C ++, bạn có thể sử dụng -Wold-style-casttùy chọn này để tìm hiểu tất cả các lần xuất hiện của (type)cú pháp truyền có thể len ​​vào mã và theo dõi các chẩn đoán này bằng cách thay thế nó bằng một lựa chọn thích hợp trong số các macro trên (hoặc một kết hợp, nếu cần thiết).

Cách xử lý chuyển đổi này là biện minh kỹ thuật độc lập lớn nhất để làm việc trong "Clean C": phương ngữ C và C ++ kết hợp, về mặt kỹ thuật biện minh cho việc đúc giá trị trả về malloc.

Điều tốt nhất để làm khi lập trình trong C bất cứ khi nào có thể:

1. Làm cho chương trình của bạn được biên dịch thông qua trình biên dịch C với tất cả các cảnh báo được bật -Wallvà sửa tất cả các lỗi và cảnh báo
2. Đảm bảo không có biến nào được khai báo là auto
3. Sau đó biên dịch nó bằng trình biên dịch C ++ với -Wallvà -std=c++11. Sửa tất cả các lỗi và cảnh báo.
4. Bây giờ biên dịch lại bằng trình biên dịch C. Chương trình của bạn bây giờ sẽ biên dịch mà không có bất kỳ cảnh báo nào và chứa ít lỗi hơn.

Quy trình này cho phép bạn tận dụng kiểm tra loại nghiêm ngặt C ++, do đó giảm số lượng lỗi. Cụ thể, thủ tục này buộc bạn phải bao gồm stdlib.hhoặc bạn sẽ nhận được

malloc đã không được tuyên bố trong phạm vi này

và cũng buộc bạn bỏ kết quả mallochoặc bạn sẽ nhận được

chuyển đổi không hợp lệ từ void*sangT*

hoặc loại mục tiêu của bạn là gì.

Những lợi ích duy nhất từ ​​việc viết bằng C thay vì C ++ tôi có thể tìm thấy là

1. C có ABI được chỉ định rõ
2. C ++ có thể tạo thêm mã [ngoại lệ, RTTI, mẫu, đa hình thời gian chạy ]

Lưu ý rằng nhược điểm thứ hai trong trường hợp lý tưởng sẽ biến mất khi sử dụng tập hợp con chung cho C cùng với tính năng đa hình tĩnh .

Đối với những người tìm thấy quy tắc nghiêm ngặt C ++ bất tiện, chúng ta có thể sử dụng tính năng C ++ 11 với loại suy ra

auto memblock=static_cast<T*>(malloc(n*sizeof(T))); //Mult may overflow...

Không, bạn không bỏ kết quả malloc().

Nói chung, bạn không chọn đến hoặc từvoid * .

Một lý do điển hình được đưa ra cho việc không làm như vậy là thất bại #include <stdlib.h>có thể không được chú ý. Điều này không còn là vấn đề nữa trong một thời gian dài vì C99 đã khai báo hàm ngầm là bất hợp pháp, vì vậy nếu trình biên dịch của bạn tuân thủ ít nhất C99, bạn sẽ nhận được thông báo chẩn đoán.

Nhưng có một lý do mạnh mẽ hơn nhiều để không giới thiệu các phôi con trỏ không cần thiết:

Trong C, một con trỏ cast hầu như luôn luôn là một lỗi . Điều này là do quy tắc sau ( §6,5 p7 trong N1570, dự thảo mới nhất cho C11):

Một đối tượng sẽ có giá trị được lưu trữ chỉ được truy cập bởi một biểu thức giá trị có một trong các loại sau:
- một loại tương thích với loại hiệu quả của đối tượng,
- một phiên bản đủ điều kiện của loại tương thích với loại đối tượng hiệu quả,
- một loại là loại đã ký hoặc không dấu tương ứng với loại có hiệu lực của đối tượng,
- một loại là loại đã ký hoặc không dấu tương ứng với một phiên bản đủ điều kiện của loại đối tượng có hiệu lực,
- loại tổng hợp hoặc liên kết bao gồm một loại trong số các loại đã nói ở trên giữa các thành viên của nó (bao gồm, đệ quy, một thành viên của một tập hợp phụ hoặc có chứa), hoặc
- một loại ký tự.

Điều này còn được gọi là quy tắc răng cưa nghiêm ngặt . Vì vậy, đoạn mã sau đây là hành vi không xác định :

long x = 5;
double *p = (double *)&x;
double y = *p;

Và, đôi khi đáng ngạc nhiên, sau đây là tốt:

struct foo { int x; };
struct bar { int x; int y; };
struct bar b = { 1, 2};
struct foo *p = (struct foo *)&b;
int z = p->x;

Đôi khi, bạn làm cần phải gợi ý dàn diễn viên, nhưng với những quy tắc nghiêm ngặt răng cưa , bạn phải rất cẩn thận với nó. Vì vậy, bất kỳ sự xuất hiện của một con trỏ trong mã của bạn là nơi bạn phải kiểm tra lại tính hợp lệ của nó . Do đó, bạn không bao giờ viết một con trỏ không cần thiết.

tl; dr

Tóm lại: Bởi vì trong C, bất kỳ sự xuất hiện nào của một con trỏ đúc sẽ giơ cờ đỏ cho mã yêu cầu sự chú ý đặc biệt, bạn không bao giờ nên viết các phôi con trỏ không cần thiết .

Ghi chú bên:

• Có những trường hợp bạn thực sự cần một diễn viên void *, ví dụ nếu bạn muốn in một con trỏ:

  int x = 5;
  printf("%p\n", (void *)&x);

  Diễn viên là cần thiết ở đây, vì printf()là một hàm biến đổi, vì vậy các chuyển đổi ngầm không hoạt động.

• Trong C ++, tình hình là khác nhau. Đúc các kiểu con trỏ là hơi phổ biến (và chính xác) khi xử lý các đối tượng của các lớp dẫn xuất. Do đó, nó làm cho cảm giác rằng trong C ++, việc chuyển đổi đến và đi từ void *là không tiềm ẩn. C ++ có một bộ các hương vị khác nhau của đúc.

Tôi thích làm các diễn viên, nhưng không phải bằng tay. Yêu thích của tôi là sử dụng g_newvà g_new0macro từ glib. Nếu glib không được sử dụng, tôi sẽ thêm các macro tương tự. Các macro này làm giảm sự sao chép mã mà không ảnh hưởng đến an toàn loại. Nếu bạn nhận được loại sai, bạn sẽ nhận được một diễn viên ngầm giữa các con trỏ không trống, điều này sẽ gây ra một cảnh báo (lỗi trong C ++). Nếu bạn quên bao gồm tiêu đề xác định g_newvà g_new0, bạn sẽ gặp lỗi. g_newvà g_new0cả hai đều có cùng một đối số, không giống như mallocmất ít đối số hơn calloc. Chỉ cần thêm 0để có được bộ nhớ khởi tạo bằng không. Mã có thể được biên dịch bằng trình biên dịch C ++ mà không thay đổi.

Casting chỉ dành cho C ++ chứ không phải C. Trong trường hợp bạn đang sử dụng trình biên dịch C ++, tốt nhất bạn nên thay đổi nó thành trình biên dịch C.

Khái niệm đằng sau con trỏ void là nó có thể được truyền tới bất kỳ loại dữ liệu nào, đó là lý do tại sao malloc trả về void. Ngoài ra, bạn phải nhận thức về typecasting tự động. Vì vậy, không bắt buộc phải bỏ con trỏ mặc dù bạn phải làm điều đó. Nó giúp giữ cho mã sạch và giúp gỡ lỗi

Một con trỏ void là một con trỏ chung và C hỗ trợ chuyển đổi ngầm định từ một loại con trỏ void sang các loại khác, do đó không cần phải đánh máy một cách rõ ràng.

Tuy nhiên, nếu bạn muốn cùng một mã hoạt động hoàn toàn tương thích trên nền tảng C ++, không hỗ trợ chuyển đổi ngầm định, bạn cần thực hiện kiểu chữ, vì vậy tất cả phụ thuộc vào khả năng sử dụng.

1. Như đã nêu, nó không cần thiết cho C, nhưng đối với C ++.

2. Bao gồm các diễn viên có thể cho phép một chương trình hoặc chức năng C biên dịch thành C ++.

3. Trong C thì không cần thiết, vì void * được tự động và được thăng cấp an toàn cho bất kỳ loại con trỏ nào khác.

4. Nhưng nếu bạn sử dụng thì nó có thể ẩn một lỗi nếu bạn quên bao gồm stdlib.h . Điều này có thể gây ra sự cố (hoặc tệ hơn là không gây ra sự cố cho đến khi về sau trong một số phần hoàn toàn khác của mã).

   Bởi vì stdlib.h chứa nguyên mẫu cho malloc được tìm thấy. Trong trường hợp không có nguyên mẫu cho malloc, tiêu chuẩn yêu cầu trình biên dịch C giả định malloc trả về một int. Nếu không có cast, một cảnh báo được đưa ra khi số nguyên này được gán cho con trỏ; tuy nhiên, với các diễn viên, cảnh báo này không được tạo ra, ẩn một lỗi.

Việc đúc malloc là không cần thiết trong C nhưng bắt buộc trong C ++.

Đúc không cần thiết trong C vì:

• void * được tự động và an toàn được thăng cấp lên bất kỳ loại con trỏ nào khác trong trường hợp C.
• Nó có thể ẩn một lỗi nếu bạn quên bao gồm <stdlib.h>. Điều này có thể gây ra sự cố.
• Nếu con trỏ và số nguyên có kích thước khác nhau, thì bạn đang ẩn cảnh báo bằng cách truyền và có thể mất bit của địa chỉ trả về của bạn.
• Nếu loại con trỏ bị thay đổi khi khai báo, người ta cũng có thể cần thay đổi tất cả các dòng mallocđược gọi và truyền.

Mặt khác, việc truyền có thể làm tăng tính di động của chương trình của bạn. tức là, nó cho phép một chương trình hoặc hàm C biên dịch thành C ++.

Đối với tôi, việc mang về nhà và kết luận ở đây là việc truyền mallocbằng C là hoàn toàn KHÔNG cần thiết nhưng nếu bạn thực hiện, nó sẽ không ảnh hưởng mallocvì mallocvẫn sẽ phân bổ cho bạn không gian bộ nhớ may mắn được yêu cầu của bạn. Một lý do khác về nhà là lý do hoặc một trong những lý do khiến mọi người thực hiện casting và điều này là để cho phép họ biên dịch cùng một chương trình trong C hoặc C ++.

Có thể có những lý do khác nhưng những lý do khác, gần như chắc chắn, sẽ khiến bạn gặp rắc rối nghiêm trọng sớm hay muộn.

Bạn có thể, nhưng không cần truyền vào C. Bạn phải truyền nếu mã đó được biên dịch thành C ++.