อะไรคือความแตกต่างระหว่างตัวชี้ห้อยและตัวชี้โมฆะใน C? ในทางเทคนิคแล้วทั้งคู่ดูเหมือนกัน


ตอบ 1:

ไม่มีความแตกต่างตราบใดที่คุณไม่ได้อ้างถึงตัวชี้ใด ๆ เหล่านั้น ดังนั้นการห้อยก็หมายความว่าหน่วยความจำที่ตัวชี้ชี้ไปนั้นได้รับอนุญาตให้นำมาใช้ซ้ำเพื่อสิ่งอื่น แต่โปรแกรมสันนิษฐานว่าเนื้อหาเก่ายังคงอยู่ที่นั่นและพยายามเข้าถึง สิ่งนี้มักจะนำไปสู่พฤติกรรมที่ไม่ถูกต้อง ณ จุดหนึ่งในการทำงานของโปรแกรม

นอกจากนั้นฉันรู้สึกว่าคำถามตัวเองอย่างยิ่งบ่งบอกว่าคุณไม่ได้ "เข้าใจตัวชี้" หากคุณจินตนาการถึงหน่วยความจำในรูปของกล่องตัวเลขซึ่งแต่ละกล่องสามารถมีเนื้อหา (ค่าปกติคือ 0 ... 255) ตัวชี้จะเป็นจำนวนเต็ม (ฉันทำให้สถาปัตยกรรมเฉพาะที่นี่ง่ายขึ้น) ถือตัวเลข (ไม่ใช่ ค่า) ของหนึ่งในกล่องเหล่านั้น


ตอบ 2:

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

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

int * p; // ตอนนี้ตัวชี้นี้มีที่อยู่แบบสุ่มสามารถชี้ไปที่ตำแหน่งใดก็ได้แม้อยู่นอกเซกเมนต์

* p = 10; // แน่นอนที่สุดนี้จะให้ความผิด

วิธีที่ปลอดภัยจะเป็นดังนี้:

int * p = NULL;

ถ้า (P! = NULL)

* p = 10;

ตัวชี้ที่ห้อยอยู่: ตามชื่อที่แนะนำตัวชี้ที่ไม่ชัดเจนว่าจะให้ชี้ไปที่ใดตั้งแต่บล็อกหน่วยความจำที่ แต่เดิมนั้นชี้ไปยังถูกปล่อยออกมา

มีหลายวิธีที่เป็นไปได้ที่จะทำให้ตัวชี้ห้อย วิธีที่พบมากที่สุดคือการใหม่คัดลอกและลบ

int * p = NULL; int * q = NULL;

p = ใหม่ x;

q = p;

ลบ q; // ทั้ง q และตัวชี้บล็อกหน่วยความจำโดย q ถูกลบออกจากหน่วยความจำ

// จากที่นี่เรามีตัวชี้ p ที่มีที่อยู่ซึ่งไม่มีอยู่ในหน่วยความจำ หากเราพยายามกำหนดค่าบางอย่างให้กับตัวชี้นี้เรากำลังมีปัญหา p นี่คือตัวชี้ห้อย

* p = 10; // ผิดพลาด

วิธีอื่น ๆ ที่คุณสามารถสร้างตัวชี้ห้อยโดยบังเอิญจะทำสำเนาวัตถุที่ตื้นไม่ว่าจะโดยการมอบหมายหรือโดยการส่งวัตถุไปยังวิธีการโดยใช้คอมไพเลอร์ที่จัดทำสำเนาตัวสร้างซึ่งอีกครั้งทำสำเนาตื้นสำหรับคุณ


ตอบ 3:

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

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

int * p; // ตอนนี้ตัวชี้นี้มีที่อยู่แบบสุ่มสามารถชี้ไปที่ตำแหน่งใดก็ได้แม้อยู่นอกเซกเมนต์

* p = 10; // แน่นอนที่สุดนี้จะให้ความผิด

วิธีที่ปลอดภัยจะเป็นดังนี้:

int * p = NULL;

ถ้า (P! = NULL)

* p = 10;

ตัวชี้ที่ห้อยอยู่: ตามชื่อที่แนะนำตัวชี้ที่ไม่ชัดเจนว่าจะให้ชี้ไปที่ใดตั้งแต่บล็อกหน่วยความจำที่ แต่เดิมนั้นชี้ไปยังถูกปล่อยออกมา

มีหลายวิธีที่เป็นไปได้ที่จะทำให้ตัวชี้ห้อย วิธีที่พบมากที่สุดคือการใหม่คัดลอกและลบ

int * p = NULL; int * q = NULL;

p = ใหม่ x;

q = p;

ลบ q; // ทั้ง q และตัวชี้บล็อกหน่วยความจำโดย q ถูกลบออกจากหน่วยความจำ

// จากที่นี่เรามีตัวชี้ p ที่มีที่อยู่ซึ่งไม่มีอยู่ในหน่วยความจำ หากเราพยายามกำหนดค่าบางอย่างให้กับตัวชี้นี้เรากำลังมีปัญหา p นี่คือตัวชี้ห้อย

* p = 10; // ผิดพลาด

วิธีอื่น ๆ ที่คุณสามารถสร้างตัวชี้ห้อยโดยบังเอิญจะทำสำเนาวัตถุที่ตื้นไม่ว่าจะโดยการมอบหมายหรือโดยการส่งวัตถุไปยังวิธีการโดยใช้คอมไพเลอร์ที่จัดทำสำเนาตัวสร้างซึ่งอีกครั้งทำสำเนาตื้นสำหรับคุณ


ตอบ 4:

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

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

int * p; // ตอนนี้ตัวชี้นี้มีที่อยู่แบบสุ่มสามารถชี้ไปที่ตำแหน่งใดก็ได้แม้อยู่นอกเซกเมนต์

* p = 10; // แน่นอนที่สุดนี้จะให้ความผิด

วิธีที่ปลอดภัยจะเป็นดังนี้:

int * p = NULL;

ถ้า (P! = NULL)

* p = 10;

ตัวชี้ที่ห้อยอยู่: ตามชื่อที่แนะนำตัวชี้ที่ไม่ชัดเจนว่าจะให้ชี้ไปที่ใดตั้งแต่บล็อกหน่วยความจำที่ แต่เดิมนั้นชี้ไปยังถูกปล่อยออกมา

มีหลายวิธีที่เป็นไปได้ที่จะทำให้ตัวชี้ห้อย วิธีที่พบมากที่สุดคือการใหม่คัดลอกและลบ

int * p = NULL; int * q = NULL;

p = ใหม่ x;

q = p;

ลบ q; // ทั้ง q และตัวชี้บล็อกหน่วยความจำโดย q ถูกลบออกจากหน่วยความจำ

// จากที่นี่เรามีตัวชี้ p ที่มีที่อยู่ซึ่งไม่มีอยู่ในหน่วยความจำ หากเราพยายามกำหนดค่าบางอย่างให้กับตัวชี้นี้เรากำลังมีปัญหา p นี่คือตัวชี้ห้อย

* p = 10; // ผิดพลาด

วิธีอื่น ๆ ที่คุณสามารถสร้างตัวชี้ห้อยโดยบังเอิญจะทำสำเนาวัตถุที่ตื้นไม่ว่าจะโดยการมอบหมายหรือโดยการส่งวัตถุไปยังวิธีการโดยใช้คอมไพเลอร์ที่จัดทำสำเนาตัวสร้างซึ่งอีกครั้งทำสำเนาตื้นสำหรับคุณ


ตอบ 5:

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

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

int * p; // ตอนนี้ตัวชี้นี้มีที่อยู่แบบสุ่มสามารถชี้ไปที่ตำแหน่งใดก็ได้แม้อยู่นอกเซกเมนต์

* p = 10; // แน่นอนที่สุดนี้จะให้ความผิด

วิธีที่ปลอดภัยจะเป็นดังนี้:

int * p = NULL;

ถ้า (P! = NULL)

* p = 10;

ตัวชี้ที่ห้อยอยู่: ตามชื่อที่แนะนำตัวชี้ที่ไม่ชัดเจนว่าจะให้ชี้ไปที่ใดตั้งแต่บล็อกหน่วยความจำที่ แต่เดิมนั้นชี้ไปยังถูกปล่อยออกมา

มีหลายวิธีที่เป็นไปได้ที่จะทำให้ตัวชี้ห้อย วิธีที่พบมากที่สุดคือการใหม่คัดลอกและลบ

int * p = NULL; int * q = NULL;

p = ใหม่ x;

q = p;

ลบ q; // ทั้ง q และตัวชี้บล็อกหน่วยความจำโดย q ถูกลบออกจากหน่วยความจำ

// จากที่นี่เรามีตัวชี้ p ที่มีที่อยู่ซึ่งไม่มีอยู่ในหน่วยความจำ หากเราพยายามกำหนดค่าบางอย่างให้กับตัวชี้นี้เรากำลังมีปัญหา p นี่คือตัวชี้ห้อย

* p = 10; // ผิดพลาด

วิธีอื่น ๆ ที่คุณสามารถสร้างตัวชี้ห้อยโดยบังเอิญจะทำสำเนาวัตถุที่ตื้นไม่ว่าจะโดยการมอบหมายหรือโดยการส่งวัตถุไปยังวิธีการโดยใช้คอมไพเลอร์ที่จัดทำสำเนาตัวสร้างซึ่งอีกครั้งทำสำเนาตื้นสำหรับคุณ


ตอบ 6:

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

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

int * p; // ตอนนี้ตัวชี้นี้มีที่อยู่แบบสุ่มสามารถชี้ไปที่ตำแหน่งใดก็ได้แม้อยู่นอกเซกเมนต์

* p = 10; // แน่นอนที่สุดนี้จะให้ความผิด

วิธีที่ปลอดภัยจะเป็นดังนี้:

int * p = NULL;

ถ้า (P! = NULL)

* p = 10;

ตัวชี้ที่ห้อยอยู่: ตามชื่อที่แนะนำตัวชี้ที่ไม่ชัดเจนว่าจะให้ชี้ไปที่ใดตั้งแต่บล็อกหน่วยความจำที่ แต่เดิมนั้นชี้ไปยังถูกปล่อยออกมา

มีหลายวิธีที่เป็นไปได้ที่จะทำให้ตัวชี้ห้อย วิธีที่พบมากที่สุดคือการใหม่คัดลอกและลบ

int * p = NULL; int * q = NULL;

p = ใหม่ x;

q = p;

ลบ q; // ทั้ง q และตัวชี้บล็อกหน่วยความจำโดย q ถูกลบออกจากหน่วยความจำ

// จากที่นี่เรามีตัวชี้ p ที่มีที่อยู่ซึ่งไม่มีอยู่ในหน่วยความจำ หากเราพยายามกำหนดค่าบางอย่างให้กับตัวชี้นี้เรากำลังมีปัญหา p นี่คือตัวชี้ห้อย

* p = 10; // ผิดพลาด

วิธีอื่น ๆ ที่คุณสามารถสร้างตัวชี้ห้อยโดยบังเอิญจะทำสำเนาวัตถุที่ตื้นไม่ว่าจะโดยการมอบหมายหรือโดยการส่งวัตถุไปยังวิธีการโดยใช้คอมไพเลอร์ที่จัดทำสำเนาตัวสร้างซึ่งอีกครั้งทำสำเนาตื้นสำหรับคุณ


ตอบ 7:

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

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

int * p; // ตอนนี้ตัวชี้นี้มีที่อยู่แบบสุ่มสามารถชี้ไปที่ตำแหน่งใดก็ได้แม้อยู่นอกเซกเมนต์

* p = 10; // แน่นอนที่สุดนี้จะให้ความผิด

วิธีที่ปลอดภัยจะเป็นดังนี้:

int * p = NULL;

ถ้า (P! = NULL)

* p = 10;

ตัวชี้ที่ห้อยอยู่: ตามชื่อที่แนะนำตัวชี้ที่ไม่ชัดเจนว่าจะให้ชี้ไปที่ใดตั้งแต่บล็อกหน่วยความจำที่ แต่เดิมนั้นชี้ไปยังถูกปล่อยออกมา

มีหลายวิธีที่เป็นไปได้ที่จะทำให้ตัวชี้ห้อย วิธีที่พบมากที่สุดคือการใหม่คัดลอกและลบ

int * p = NULL; int * q = NULL;

p = ใหม่ x;

q = p;

ลบ q; // ทั้ง q และตัวชี้บล็อกหน่วยความจำโดย q ถูกลบออกจากหน่วยความจำ

// จากที่นี่เรามีตัวชี้ p ที่มีที่อยู่ซึ่งไม่มีอยู่ในหน่วยความจำ หากเราพยายามกำหนดค่าบางอย่างให้กับตัวชี้นี้เรากำลังมีปัญหา p นี่คือตัวชี้ห้อย

* p = 10; // ผิดพลาด

วิธีอื่น ๆ ที่คุณสามารถสร้างตัวชี้ห้อยโดยบังเอิญจะทำสำเนาวัตถุที่ตื้นไม่ว่าจะโดยการมอบหมายหรือโดยการส่งวัตถุไปยังวิธีการโดยใช้คอมไพเลอร์ที่จัดทำสำเนาตัวสร้างซึ่งอีกครั้งทำสำเนาตื้นสำหรับคุณ


ตอบ 8:

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

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

int * p; // ตอนนี้ตัวชี้นี้มีที่อยู่แบบสุ่มสามารถชี้ไปที่ตำแหน่งใดก็ได้แม้อยู่นอกเซกเมนต์

* p = 10; // แน่นอนที่สุดนี้จะให้ความผิด

วิธีที่ปลอดภัยจะเป็นดังนี้:

int * p = NULL;

ถ้า (P! = NULL)

* p = 10;

ตัวชี้ที่ห้อยอยู่: ตามชื่อที่แนะนำตัวชี้ที่ไม่ชัดเจนว่าจะให้ชี้ไปที่ใดตั้งแต่บล็อกหน่วยความจำที่ แต่เดิมนั้นชี้ไปยังถูกปล่อยออกมา

มีหลายวิธีที่เป็นไปได้ที่จะทำให้ตัวชี้ห้อย วิธีที่พบมากที่สุดคือการใหม่คัดลอกและลบ

int * p = NULL; int * q = NULL;

p = ใหม่ x;

q = p;

ลบ q; // ทั้ง q และตัวชี้บล็อกหน่วยความจำโดย q ถูกลบออกจากหน่วยความจำ

// จากที่นี่เรามีตัวชี้ p ที่มีที่อยู่ซึ่งไม่มีอยู่ในหน่วยความจำ หากเราพยายามกำหนดค่าบางอย่างให้กับตัวชี้นี้เรากำลังมีปัญหา p นี่คือตัวชี้ห้อย

* p = 10; // ผิดพลาด

วิธีอื่น ๆ ที่คุณสามารถสร้างตัวชี้ห้อยโดยบังเอิญจะทำสำเนาวัตถุที่ตื้นไม่ว่าจะโดยการมอบหมายหรือโดยการส่งวัตถุไปยังวิธีการโดยใช้คอมไพเลอร์ที่จัดทำสำเนาตัวสร้างซึ่งอีกครั้งทำสำเนาตื้นสำหรับคุณ


ตอบ 9:

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

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

int * p; // ตอนนี้ตัวชี้นี้มีที่อยู่แบบสุ่มสามารถชี้ไปที่ตำแหน่งใดก็ได้แม้อยู่นอกเซกเมนต์

* p = 10; // แน่นอนที่สุดนี้จะให้ความผิด

วิธีที่ปลอดภัยจะเป็นดังนี้:

int * p = NULL;

ถ้า (P! = NULL)

* p = 10;

ตัวชี้ที่ห้อยอยู่: ตามชื่อที่แนะนำตัวชี้ที่ไม่ชัดเจนว่าจะให้ชี้ไปที่ใดตั้งแต่บล็อกหน่วยความจำที่ แต่เดิมนั้นชี้ไปยังถูกปล่อยออกมา

มีหลายวิธีที่เป็นไปได้ที่จะทำให้ตัวชี้ห้อย วิธีที่พบมากที่สุดคือการใหม่คัดลอกและลบ

int * p = NULL; int * q = NULL;

p = ใหม่ x;

q = p;

ลบ q; // ทั้ง q และตัวชี้บล็อกหน่วยความจำโดย q ถูกลบออกจากหน่วยความจำ

// จากที่นี่เรามีตัวชี้ p ที่มีที่อยู่ซึ่งไม่มีอยู่ในหน่วยความจำ หากเราพยายามกำหนดค่าบางอย่างให้กับตัวชี้นี้เรากำลังมีปัญหา p นี่คือตัวชี้ห้อย

* p = 10; // ผิดพลาด

วิธีอื่น ๆ ที่คุณสามารถสร้างตัวชี้ห้อยโดยบังเอิญจะทำสำเนาวัตถุที่ตื้นไม่ว่าจะโดยการมอบหมายหรือโดยการส่งวัตถุไปยังวิธีการโดยใช้คอมไพเลอร์ที่จัดทำสำเนาตัวสร้างซึ่งอีกครั้งทำสำเนาตื้นสำหรับคุณ


ตอบ 10:

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

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

int * p; // ตอนนี้ตัวชี้นี้มีที่อยู่แบบสุ่มสามารถชี้ไปที่ตำแหน่งใดก็ได้แม้อยู่นอกเซกเมนต์

* p = 10; // แน่นอนที่สุดนี้จะให้ความผิด

วิธีที่ปลอดภัยจะเป็นดังนี้:

int * p = NULL;

ถ้า (P! = NULL)

* p = 10;

ตัวชี้ที่ห้อยอยู่: ตามชื่อที่แนะนำตัวชี้ที่ไม่ชัดเจนว่าจะให้ชี้ไปที่ใดตั้งแต่บล็อกหน่วยความจำที่ แต่เดิมนั้นชี้ไปยังถูกปล่อยออกมา

มีหลายวิธีที่เป็นไปได้ที่จะทำให้ตัวชี้ห้อย วิธีที่พบมากที่สุดคือการใหม่คัดลอกและลบ

int * p = NULL; int * q = NULL;

p = ใหม่ x;

q = p;

ลบ q; // ทั้ง q และตัวชี้บล็อกหน่วยความจำโดย q ถูกลบออกจากหน่วยความจำ

// จากที่นี่เรามีตัวชี้ p ที่มีที่อยู่ซึ่งไม่มีอยู่ในหน่วยความจำ หากเราพยายามกำหนดค่าบางอย่างให้กับตัวชี้นี้เรากำลังมีปัญหา p นี่คือตัวชี้ห้อย

* p = 10; // ผิดพลาด

วิธีอื่น ๆ ที่คุณสามารถสร้างตัวชี้ห้อยโดยบังเอิญจะทำสำเนาวัตถุที่ตื้นไม่ว่าจะโดยการมอบหมายหรือโดยการส่งวัตถุไปยังวิธีการโดยใช้คอมไพเลอร์ที่จัดทำสำเนาตัวสร้างซึ่งอีกครั้งทำสำเนาตื้นสำหรับคุณ