ฉันเคยเขียนสิ่งต่างๆเช่น

char *x=NULL;

บนสมมติฐานที่ว่า

 char *x=2;

จะสร้างcharตัวชี้ไปยังที่อยู่ 2

แต่ในบทช่วยสอนการเขียนโปรแกรม GNU Cบอกว่าจะint *my_int_ptr = 2;เก็บค่าจำนวนเต็ม2ไว้ที่ที่อยู่แบบสุ่มใด ๆ ก็ตามmy_int_ptrเมื่อมีการจัดสรร

สิ่งนี้ดูเหมือนจะบอกเป็นนัยว่าของฉันเองchar *x=NULLกำลังกำหนดค่าของการNULLร่ายให้กับ a charคือที่อยู่แบบสุ่มบางส่วนในหน่วยความจำ

ในขณะที่

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

int main()
{
    char *x=NULL;

    if (x==NULL)
        printf("is NULL\n");

    return EXIT_SUCCESS;
}

ในความเป็นจริงพิมพ์

เป็นโมฆะ

เมื่อฉันรวบรวมและเรียกใช้ฉันกังวลว่าฉันกำลังอาศัยพฤติกรรมที่ไม่ได้กำหนดหรืออย่างน้อยพฤติกรรมที่ไม่ระบุและฉันควรเขียน

char *x;
x=NULL;

แทน.

เป็นไปได้หรือไม่ที่จะเริ่มต้นตัวชี้ C เป็น NULL

TL; DRใช่มาก

เรียกร้องที่เกิดขึ้นจริงในวันที่คู่มืออ่านเหมือน

ในทางกลับกันถ้าคุณใช้การกำหนดเริ่มต้นเพียงครั้งเดียวint *my_int_ptr = 2;โปรแกรมจะพยายามเติมเนื้อหาของตำแหน่งหน่วยความจำที่ชี้ไปmy_int_ptrด้วยค่า 2 เนื่องจากmy_int_ptrเต็มไปด้วยขยะจึงสามารถเป็นที่อยู่ใดก็ได้ [... ]

ดีที่พวกเขามีความผิดคุณมีสิทธิ

สำหรับคำสั่ง ( ไม่สนใจในตอนนี้ความจริงที่ว่าตัวชี้ไปยังการแปลงจำนวนเต็มเป็นพฤติกรรมที่กำหนดโดยการนำไปใช้งาน )

int * my_int_ptr = 2;

my_int_ptrเป็นตัวแปร (ชนิดของตัวชี้ไปที่int) มีที่อยู่ของตัวเอง (ประเภท: ที่อยู่ของตัวชี้เป็นจำนวนเต็ม) คุณกำลังจัดเก็บค่า2ไว้ในที่อยู่นั้น

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

ดังนั้นสำหรับข้อสรุป

 char *x=NULL;

เริ่มต้นตัวแปรชี้xจะNULLไม่คุ้มค่าที่อยู่หน่วยความจำที่ชี้ไปตามตัวชี้

นี่คือเดียวกันเป็น

 char *x;
 x = NULL;    

การขยาย:

ตอนนี้กำลังปฏิบัติตามอย่างเคร่งครัดคำสั่งเช่น

 int * my_int_ptr = 2;

ผิดกฎหมายเนื่องจากเกี่ยวข้องกับการละเมิดข้อ จำกัด ต้องมีความชัดเจน,

• my_int_ptr เป็นตัวแปรตัวชี้ชนิด int *
• ค่าคงที่จำนวนเต็ม2มีชนิดintตามนิยาม

และพวกเขาไม่ได้เป็นประเภท "เข้ากันได้" ดังนั้นการเริ่มต้นนี้ไม่ถูกต้องเพราะการละเมิดกฎของงานที่เรียบง่ายที่กล่าวถึงในบท§6.5.16.1 / P1 ที่อธิบายไว้ในคำตอบของ Lundin

ในกรณีที่ใครก็ตามที่สนใจว่าการเริ่มต้นเชื่อมโยงกับข้อ จำกัด ของการมอบหมายอย่างง่ายการอ้างอิงC11บทที่§6.7.9, P11

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

กวดวิชาไม่ถูกต้อง ใน ISO C int *my_int_ptr = 2;เป็นข้อผิดพลาด ใน GNU C หมายถึงเช่นเดียวกับint *my_int_ptr = (int *)2;. สิ่งนี้จะแปลงจำนวนเต็ม2เป็นที่อยู่หน่วยความจำในบางรูปแบบตามที่คอมไพเลอร์กำหนด

ไม่พยายามจัดเก็บสิ่งใด ๆ ในสถานที่ที่ระบุโดยที่อยู่นั้น (ถ้ามี) หากคุณเขียน*my_int_ptr = 5;ต่อไประบบจะพยายามจัดเก็บหมายเลข5ในตำแหน่งที่ระบุโดยที่อยู่นั้น

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

ตาม 6.5.16.1 การมอบหมายอย่างง่าย:

ข้อ จำกัด

ข้อใดข้อหนึ่งต่อไปนี้จะถือ:

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

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

เป็นที่ทราบกันดีว่า GCC ทำงานได้ไม่ดีเว้นแต่คุณจะบอกอย่างชัดเจนว่าเป็นคอมไพเลอร์ C มาตรฐาน หากคุณคอมไพล์โค้ดเป็น-std=c11 -pedantic-errorsก็จะทำการวินิจฉัยได้อย่างถูกต้องตามที่ต้องทำ

int *my_int_ptr = 2

เก็บค่าจำนวนเต็ม 2 เป็นที่อยู่สุ่มใด ๆ ที่อยู่ใน my_int_ptr เมื่อมีการจัดสรร

นี่เป็นสิ่งที่ผิดอย่างสิ้นเชิง ถ้าเขียนได้จริงโปรดหาหนังสือหรือบทช่วยสอนที่ดีกว่า

int *my_int_ptr = 2กำหนดตัวชี้จำนวนเต็มซึ่งจุดไปยังที่อยู่ 2. 2คุณมักจะได้รับความผิดพลาดถ้าคุณพยายามที่จะเข้าถึงที่อยู่

*my_int_ptr = 2กล่าวคือไม่มี intในบรรทัดจะเก็บค่าสองตามที่อยู่แบบสุ่มที่my_int_ptrชี้ไป เมื่อพูดสิ่งนี้คุณสามารถกำหนดให้NULLกับตัวชี้เมื่อมีการกำหนด char *x=NULL;ถูกต้องสมบูรณ์ C.

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

ความสับสนมากมายเกี่ยวกับพอยน์เตอร์ C มาจากตัวเลือกที่ไม่ดีมากซึ่ง แต่เดิมสร้างขึ้นเกี่ยวกับรูปแบบการเข้ารหัสซึ่งได้รับการยืนยันจากตัวเลือกเล็ก ๆ น้อย ๆ ที่ไม่ดีในไวยากรณ์ของภาษา

int *x = NULL;ถูกต้อง C แต่มันทำให้เข้าใจผิดมากฉันจะพูดว่าไร้สาระและมันขัดขวางความเข้าใจภาษาสำหรับมือใหม่หลายคน มันทำให้เราคิดว่าในภายหลังเราสามารถทำได้*x = NULL;ซึ่งแน่นอนว่าเป็นไปไม่ได้ คุณจะเห็นว่าประเภทของตัวแปรไม่ใช่intและชื่อของตัวแปรไม่ใช่*xและ*ในการประกาศไม่มีบทบาทหน้าที่ในการทำงานร่วมกับ=. เป็นการประกาศอย่างหมดจด ดังนั้นสิ่งที่สมเหตุสมผลกว่านี้คือ:

int* x = NULL;ซึ่งก็ถูกต้องเช่นกันแม้ว่าจะไม่เป็นไปตามรูปแบบการเข้ารหัส K&R ดั้งเดิม มันทำให้ชัดเจนอย่างสมบูรณ์ว่าเป็นประเภทint*และตัวแปรตัวชี้คือxดังนั้นจึงเห็นได้ชัดแม้กระทั่งสำหรับผู้ที่ไม่ได้ฝึกหัดว่าNULLมีการจัดเก็บค่าไว้xซึ่งเป็นตัวชี้ไปที่intซึ่งเป็นตัวชี้ไปยัง

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

ดังนั้นตอนนี้จึงเข้าใจได้ง่ายขึ้นมากว่ายิ่งไปกว่านั้นเราสามารถทำได้x = NULL;หรือ*x = 2;กล่าวอีกนัยหนึ่งก็คือทำให้มือใหม่ดูวิธีvariable = expressionนำไปสู่pointer-type variable = pointer-expressionและdereferenced-pointer-variable = expressionได้ง่ายขึ้น (สำหรับการเริ่มต้นโดย 'นิพจน์' ฉันหมายถึง 'rvalue')

ตัวเลือกที่น่าเสียดายในไวยากรณ์ของภาษาคือเมื่อประกาศตัวแปรท้องถิ่นคุณสามารถพูดได้ว่าตัวint i, *p;ใดประกาศจำนวนเต็มและตัวชี้เป็นจำนวนเต็มดังนั้นจึงทำให้เชื่อว่า*เป็นส่วนที่มีประโยชน์ของชื่อ แต่มันไม่ใช่และไวยากรณ์นี้เป็นเพียงกรณีพิเศษที่เล่นโวหารเพิ่มเพื่อความสะดวกและในความคิดของฉันมันไม่ควรมีอยู่จริงเพราะมันทำให้กฎที่ฉันเสนอข้างต้นไม่ถูกต้อง เท่าที่ฉันรู้ไม่มีที่ไหนในภาษาที่ไวยากรณ์นี้มีความหมาย แต่แม้ว่าจะเป็นเช่นนั้นก็ยังชี้ให้เห็นถึงความคลาดเคลื่อนในการกำหนดประเภทตัวชี้ใน C ทุกที่อื่นในการประกาศตัวแปรเดียวในรายการพารามิเตอร์ ในสมาชิกโครงสร้าง ฯลฯ คุณสามารถประกาศพอยน์เตอร์type* pointer-variableแทนtype *pointer-variable; ถูกต้องตามกฎหมายและสมเหตุสมผลกว่า

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

int * p = NULL;
...
if (...) {
    p = (int*) malloc(...);
    ...
}
...
free(p);

เนื่องจากเป็นไปตามมาตรฐาน ISO-IEC 9899 freeเป็น nop เมื่ออาร์กิวเมนต์เป็นNULLโค้ดด้านบน (หรือบางอย่างที่มีความหมายมากกว่าในบรรทัดเดียวกัน) จึงถูกต้อง

นี่คือตัวชี้โมฆะ

int * nullPtr = (void*) 0;

นี่คือความถูกต้อง

int main()
{
    char * x = NULL;

    if (x==NULL)
        printf("is NULL\n");

    return EXIT_SUCCESS;
}

ฟังก์ชันนี้ถูกต้องสำหรับสิ่งที่ทำ กำหนดที่อยู่เป็น 0 ให้กับตัวชี้ถ่าน x นั่นคือมันชี้ตัวชี้ x ไปยังที่อยู่หน่วยความจำ 0

ทางเลือก:

int main()
{
    char* x = 0;

    if ( !x )
        printf(" x points to NULL\n");

    return EXIT_SUCCESS;
}

ฉันเดาว่าสิ่งที่คุณต้องการคือ:

int main()
{
    char* x = NULL;
    x = alloc( sizeof( char ));
    *x = '2';

    if ( *x == '2' )
        printf(" x points to an address/location that contains a '2' \n");

    return EXIT_SUCCESS;
}

x is the street address of a house. *x examines the contents of that house.