โดยเฉพาะสิ่งที่เป็นอันตรายในการคัดเลือกผลลัพธ์ของ malloc?

ก่อนที่ผู้คนจะเริ่มทำเครื่องหมายสิ่งนี้ฉันได้อ่านสิ่งต่อไปนี้ทั้งหมดซึ่งไม่มีคำตอบใดที่ให้คำตอบที่ฉันกำลังมองหา:

1. C คำถามที่พบบ่อย: การร่ายค่าตอบแทนของ malloc มีอะไรผิดปกติ?
2. SO: ฉันควรโยนค่าตอบแทนของ malloc () อย่างชัดเจนหรือไม่
3. SO: ตัวชี้ที่ไม่จำเป็นต้องร่ายใน C
4. SO: ฉันสร้างผลลัพธ์ของ malloc หรือไม่?

ทั้งคำถามที่พบบ่อยเกี่ยวกับ C และคำตอบมากมายสำหรับคำถามข้างต้นกล่าวถึงข้อผิดพลาดที่ลึกลับซึ่งmallocค่าส่งคืนของการหล่อสามารถซ่อนได้ อย่างไรก็ตามไม่มีคนใดให้ตัวอย่างเฉพาะของข้อผิดพลาดดังกล่าวในทางปฏิบัติ ตอนนี้ให้ความสนใจที่ผมกล่าวว่าข้อผิดพลาดไม่เตือน

ตอนนี้ได้รับรหัสต่อไปนี้:

#include <string.h>
#include <stdio.h>
// #include <stdlib.h>

int main(int argc, char** argv) {

    char * p = /*(char*)*/malloc(10);
    strcpy(p, "hello");
    printf("%s\n", p);

    return 0;
}

การคอมไพล์โค้ดด้านบนด้วย gcc 4.2 โดยมีและไม่มีการแคสต์จะให้คำเตือนเหมือนกันและโปรแกรมจะดำเนินการอย่างถูกต้องและให้ผลลัพธ์ที่เหมือนกันในทั้งสองกรณี

anon@anon:~/$ gcc -Wextra nostdlib_malloc.c -o nostdlib_malloc
nostdlib_malloc.c: In function ‘main’:
nostdlib_malloc.c:7: warning: incompatible implicit declaration of built-in function ‘malloc’
anon@anon:~/$ ./nostdlib_malloc 
hello

ใครก็ได้ช่วยยกตัวอย่างโค้ดเฉพาะของข้อผิดพลาดในการคอมไพล์หรือรันไทม์ที่อาจเกิดขึ้นเนื่องจากการแคmallocสต์ค่าส่งคืนหรือนี่เป็นเพียงตำนาน

แก้ไขฉันเจอข้อโต้แย้งที่เขียนได้ดีสองข้อเกี่ยวกับปัญหานี้:

1. In Favor of Casting: CERT Advisory: ส่งผลลัพธ์ของการเรียกใช้ฟังก์ชันการจัดสรรหน่วยความจำทันทีเป็นตัวชี้ไปยังประเภทที่จัดสรร
2. ต่อต้านการแคสต์ (ข้อผิดพลาด 404 ณ วันที่ 2012-02-14: ใช้สำเนาInternet Archive Wayback Machineจาก 2010-01-27 {2016-03-18: "ไม่สามารถรวบรวมข้อมูลหรือแสดงเพจได้เนื่องจาก robots.txt"})

คุณจะไม่ได้รับการรวบรวมข้อผิดพลาดแต่เตือนคอมไพเลอร์ ในฐานะที่เป็นแหล่งที่มาที่คุณกล่าวถึงการพูด (โดยเฉพาะคนแรก ) คุณสามารถได้รับการคาดเดาไม่ได้ข้อผิดพลาด runtimeเมื่อใช้หล่อโดยไม่รวมstdlib.h

ดังนั้นข้อผิดพลาดในด้านของคุณไม่หล่อ stdlib.hแต่ลืมที่จะรวมถึง คอมไพเลอร์อาจคิดว่าmallocเป็นฟังก์ชันที่ส่งคืนintดังนั้นการแปลงvoid*ตัวชี้ที่ส่งคืนจริงโดยmallocเป็นintและจากนั้นเป็นประเภทตัวชี้ของคุณเนื่องจากการแคสต์อย่างชัดเจน ในบางแพลตฟอร์มintและตัวชี้อาจใช้จำนวนไบต์ที่แตกต่างกันดังนั้นการแปลงประเภทอาจทำให้ข้อมูลเสียหายได้

โชคดีที่คอมไพเลอร์สมัยใหม่ให้คำเตือนที่ชี้ถึงข้อผิดพลาดที่แท้จริงของคุณ ดูgccเอาต์พุตที่คุณให้มา: เตือนคุณว่าการประกาศโดยนัย ( int malloc(int)) ไม่สามารถใช้ร่วมกับบิวท์อินmallocได้ ดังนั้นgccดูเหมือนจะรู้ได้โดยไม่ต้องmallocstdlib.h

การออกจากการแคสต์เพื่อป้องกันข้อผิดพลาดนี้ส่วนใหญ่เป็นเหตุผลเดียวกับการเขียน

if (0 == my_var)

แทน

if (my_var == 0)

เนื่องจากอาจทำให้เกิดข้อผิดพลาดร้ายแรงหากใครจะสับสน=และ==ในขณะที่ข้อแรกอาจนำไปสู่ข้อผิดพลาดในการคอมไพล์ โดยส่วนตัวแล้วฉันชอบสไตล์หลังมากกว่าเพราะมันสะท้อนถึงความตั้งใจของฉันได้ดีกว่าและฉันก็ไม่ได้ทำผิดพลาดนี้

เช่นเดียวกับการแคสต์ค่าที่ส่งคืนโดยmalloc: ฉันชอบที่จะมีความชัดเจนในการเขียนโปรแกรมและฉันมักจะตรวจสอบอีกครั้งเพื่อรวมไฟล์ส่วนหัวสำหรับฟังก์ชันทั้งหมดที่ฉันใช้

หนึ่งในข้อโต้แย้งระดับสูงที่ดีต่อการคัดเลือกผลลัพธ์mallocมักจะถูกปล่อยทิ้งไว้โดยไม่ได้กล่าวถึงแม้ว่าในความคิดของฉันมันมีความสำคัญมากกว่าประเด็นระดับล่างที่รู้จักกันดี (เช่นการตัดทอนตัวชี้เมื่อการประกาศหายไป)

แนวทางปฏิบัติในการเขียนโปรแกรมที่ดีคือการเขียนโค้ดซึ่งไม่ขึ้นกับประเภทให้มากที่สุด ซึ่งหมายความว่าโดยเฉพาะอย่างยิ่งชื่อประเภทนั้นควรได้รับการกล่าวถึงในรหัสให้น้อยที่สุดเท่าที่จะเป็นไปได้หรือไม่ควรกล่าวถึงเลย สิ่งนี้ใช้กับการร่าย (หลีกเลี่ยงการร่ายที่ไม่จำเป็น) ประเภทเป็นอาร์กิวเมนต์ของsizeof(หลีกเลี่ยงการใช้ชื่อประเภทในsizeof) และโดยทั่วไปการอ้างอิงอื่น ๆ ทั้งหมดในชื่อประเภท

ชื่อประเภทอยู่ในการประกาศ ชื่อประเภทควร จำกัด เฉพาะการประกาศและเฉพาะการประกาศเท่านั้น

จากมุมมองนี้บิตของรหัสนี้ไม่ดี

int *p;
...
p = (int*) malloc(n * sizeof(int));

และดีกว่านี้มาก

int *p;
...
p = malloc(n * sizeof *p);

ไม่ใช่เพียงเพราะ "ไม่ได้ส่งผลลัพธ์ของmalloc" แต่เป็นเพราะเป็นประเภทอิสระ (หรือประเภท agnositic ถ้าคุณต้องการ) เนื่องจากจะปรับตัวเองโดยอัตโนมัติpเป็นประเภทใดก็ตามที่ประกาศด้วยโดยไม่ต้องมีการแทรกแซงใด ๆ จาก ผู้ใช้งาน.

intไม่ใช่หน้าที่เป็นต้นแบบจะถือว่าผลตอบแทน

ดังนั้นคุณกำลังส่งintไปยังตัวชี้ หากพอยน์เตอร์กว้างกว่าintบนแพลตฟอร์มของคุณพฤติกรรมนี้มีความเสี่ยงสูง

นอกจากนี้แน่นอนว่าบางคนถือว่าคำเตือนเป็นข้อผิดพลาดกล่าวคือโค้ดควรรวบรวมโดยไม่มีพวกเขา

โดยส่วนตัวแล้วฉันคิดว่าการที่คุณไม่จำเป็นต้องแคสต์ไปvoid *ยังตัวชี้ประเภทอื่นเป็นคุณสมบัติใน C และพิจารณาโค้ดที่จะเสีย

หากคุณทำสิ่งนี้เมื่อคอมไพล์ในโหมด 64 บิตตัวชี้ที่ส่งคืนของคุณจะถูกตัดให้เหลือ 32 บิต

แก้ไข: ขออภัยที่สั้นเกินไป นี่คือตัวอย่างส่วนของโค้ดสำหรับวัตถุประสงค์ในการสนทนา

หลัก()
{
   ถ่าน * c = (ถ่าน *) malloc (2);
   printf ("% p", c);
}

สมมติว่าตัวชี้ฮีปที่ส่งคืนเป็นสิ่งที่ใหญ่กว่าสิ่งที่แสดงได้ใน int ให้พูด 0xAB00000000

หาก malloc ไม่ได้สร้างต้นแบบเพื่อส่งกลับตัวชี้ค่า int ที่ส่งคืนในขั้นต้นจะอยู่ในรีจิสเตอร์บางตัวที่มีชุดบิตที่สำคัญทั้งหมด ตอนนี้คอมไพเลอร์พูดว่า "โอเคฉันจะแปลงและ int เป็นตัวชี้ได้อย่างไร" นั่นจะเป็นได้ทั้งส่วนขยายเครื่องหมายหรือส่วนขยายศูนย์ของลำดับต่ำ 32 บิตที่ได้รับการบอกว่า malloc "ส่งคืน" โดยการละเว้นต้นแบบ เนื่องจาก int ถูกลงนามฉันคิดว่าการแปลงจะเป็นส่วนขยายเครื่องหมายซึ่งในกรณีนี้จะแปลงค่าเป็นศูนย์ ด้วยค่าส่งคืน 0xABF0000000 คุณจะได้รับตัวชี้ที่ไม่ใช่ศูนย์ซึ่งจะทำให้เกิดความสนุกสนานเมื่อคุณพยายามหักล้างมัน

กฎของซอฟต์แวร์ที่ใช้ซ้ำได้:

ในกรณีของการเขียนฟังก์ชันแบบอินไลน์ซึ่งใช้ malloc () เพื่อให้สามารถนำมาใช้ซ้ำสำหรับโค้ด C ++ ได้เช่นกันโปรดทำการแคสต์ประเภทที่ชัดเจน (เช่น (ถ่าน *)) มิฉะนั้นคอมไพเลอร์จะบ่น

ตัวชี้โมฆะใน C สามารถกำหนดให้กับตัวชี้ใดก็ได้โดยไม่ต้องมีการโยนอย่างชัดเจน คอมไพเลอร์จะเตือน แต่สามารถใช้ซ้ำได้ใน C ++โดยการแคสต์ประเภทmalloc()ไปยังประเภทที่เกี่ยวข้อง ที่มีออกมาหล่อพิมพ์ยังสามารถใช้ในCเพราะC จะไม่มีการตรวจสอบชนิดอย่างเข้มงวด แต่C ++ เป็นการตรวจสอบประเภทอย่างเคร่งครัดดังนั้นจึงจำเป็นต้องพิมพ์แคสต์malloc()ใน C ++