ตัวชี้ C คืออะไรถ้าไม่ใช่ที่อยู่หน่วยความจำ

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

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

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

ตอนนี้ผมกำลังสับสนเล็กน้อย - สิ่งที่ว่าเป็นตัวชี้แล้วหากไม่ได้อยู่หน่วยความจำ?

PS

ผู้เขียนกล่าวในภายหลังว่า: ... ฉันจะใช้คำว่า 'ที่อยู่' ต่อไปเนื่องจากการคิดค้นคำ [คำศัพท์] ที่ต่างออกไปจะยิ่งแย่กว่าเดิม

มาตรฐาน C ไม่ได้กำหนดสิ่งที่ตัวชี้คือภายในและวิธีการทำงานภายใน สิ่งนี้เป็นเจตนาเพื่อไม่ให้ จำกัด จำนวนแพลตฟอร์มซึ่ง C สามารถนำไปใช้เป็นภาษาที่รวบรวมหรือตีความได้

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

ฉันไม่แน่ใจเกี่ยวกับแหล่งที่มาของคุณ แต่ประเภทของภาษาที่คุณอธิบายมาจากมาตรฐาน C:

6.5.3.2 ที่อยู่และตัวดำเนินการทางอ้อม
[... ]
3. ผู้ดำเนินการ unary & ให้ผลตอบแทนที่อยู่ของตัวถูกดำเนินการ [ ... ]

ดังนั้น ... ใช่พอยน์เตอร์ชี้ไปยังที่อยู่หน่วยความจำ อย่างน้อยนั่นคือวิธีที่มาตรฐาน C แนะนำให้หมายความว่า

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

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

แก้ไข:ฉันต้องการขยายความคิดเห็นของ Alexey Frunze

ตัวชี้คืออะไร ลองดูที่มาตรฐาน C:

6.2.5 ประเภท
[ ... ]
20 [ ... ] ประเภทตัวชี้อาจจะมาจากประเภทฟังก์ชั่นหรือชนิดของวัตถุที่เรียกว่าประเภทอ้างอิง ประเภทตัวชี้อธิบายวัตถุที่มีค่าให้การอ้างอิงไปยังเอนทิตีของประเภทอ้างอิง ชนิดตัวชี้ที่ได้มาจากชนิดที่อ้างอิง T บางครั้งเรียกว่า '' ตัวชี้ไปยัง T '' การสร้างประเภทตัวชี้จากประเภทที่อ้างอิงนั้นเรียกว่า '' pointer type pointer '' ประเภทตัวชี้เป็นประเภทวัตถุที่สมบูรณ์

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

6.3.2.3 พอยน์เตอร์
[... ]
5. จำนวนเต็มอาจถูกแปลงเป็นประเภทพอยน์เตอร์ใด ๆ ยกเว้นตามที่ระบุไว้ก่อนหน้านี้ผลที่ได้คือการใช้งานที่กำหนดไว้อาจไม่ได้รับการจัดตำแหน่งอย่างถูกต้องอาจไม่ชี้ไปที่เอนทิตีของประเภทที่อ้างอิงและอาจเป็นการแสดงกับดัก

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

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

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

ซึ่งจบลงด้วยความยาวกว่าที่ฉันคิดว่ามันจะเป็น ...

ในรูปนี้,

pointer_p เป็นตัวชี้ซึ่งอยู่ที่ 0x12345 และชี้ไปที่ตัวแปร variable_v ที่ 0x34567

ที่จะคิดว่าตัวชี้เป็นที่อยู่เป็นประมาณ เช่นเดียวกับการประมาณทุกอย่างมันดีพอที่จะมีประโยชน์ในบางครั้ง แต่ก็ไม่แน่นอนซึ่งหมายความว่าการพึ่งพาอาศัยมันจะทำให้เกิดปัญหา

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

• ที่อยู่ของวัตถุซึ่งสามารถอ้างอิงได้ (ถ้าpมีที่อยู่xแล้วนิพจน์*pจะมีค่าเหมือนกันx)
• ชี้โมฆะซึ่งNULLเป็นตัวอย่าง;
• เนื้อหาที่ไม่ถูกต้องซึ่งไม่ได้ชี้ไปที่วัตถุ (หากpไม่ถือค่าที่ถูกต้องจากนั้นก็*pสามารถทำอะไรก็ได้ (“ พฤติกรรมที่ไม่ได้กำหนด”) โดยทำให้โปรแกรมมีความเป็นไปได้ค่อนข้างธรรมดา

ยิ่งไปกว่านั้นมันจะมีความแม่นยำมากกว่าที่จะบอกว่าตัวชี้ (ถ้าถูกต้องและไม่เป็นโมฆะ) มีที่อยู่: ตัวชี้จะระบุตำแหน่งที่จะค้นหาวัตถุ แต่มีข้อมูลเพิ่มเติมผูกอยู่กับมัน

โดยเฉพาะอย่างยิ่งตัวชี้มีประเภท บนแพลตฟอร์มส่วนใหญ่ชนิดของตัวชี้จะไม่มีผลกับรันไทม์ แต่มีอิทธิพลที่เกินกว่าประเภทในเวลาคอมไพล์ ถ้าpเป็นตัวชี้ไปที่int( int *p;) แล้วp + 1ชี้ไปที่จำนวนเต็มซึ่งเป็นsizeof(int)ไบต์หลังจากp(สมมติว่าp + 1ยังคงเป็นตัวชี้ที่ถูกต้อง) ถ้าqเป็นตัวชี้ไปยังcharจุดที่ไปยังที่อยู่เดียวกับp( char *q = p;) แล้วไม่ได้เป็นเช่นเดียวกับที่อยู่q + 1 p + 1หากคุณคิดว่าตัวชี้เป็นที่อยู่มันไม่ง่ายนักที่“ ที่อยู่ถัดไป” นั้นแตกต่างกันไปสำหรับตัวชี้ที่แตกต่างกันไปยังที่ตั้งเดียวกัน

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

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

มีสภาพแวดล้อมที่พอยน์เตอร์ชนิดต่าง ๆ มีการแสดงต่างกัน คุณคิดว่าเป็นที่อยู่ประเภทต่าง ๆ ที่มีการเป็นตัวแทนที่แตกต่างกัน ตัวอย่างเช่นสถาปัตยกรรมบางอย่างมีพอยน์เตอร์พอยน์เตอร์และพอยน์เตอร์พอยน์เตอร์, หรือพอยน์เตอร์พอยน์เตอร์และพอยน์เตอร์ของฟังก์ชัน

โดยรวมแล้วการคำนึงถึงพอยน์เตอร์เนื่องจากที่อยู่ไม่ได้เลวร้ายเกินไปตราบใดที่คุณจำไว้ว่า

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

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

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

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

unsigned int x = 0;
unsigned short *p = (unsigned short*)&x;
p[0] = 1;
printf("%u = %u\n", x, *p);

คุณอาจคาดหวังได้ว่าบนเครื่องที่ทำงานที่ใดsizeof(int)==4และsizeof(short)==2สิ่งนี้จะพิมพ์1 = 1?(little-endian) หรือ65536 = 1?(big-endian) แต่บน Linux PC 64 บิตของฉันด้วย GCC 4.4:

$ c99 -O2 -Wall a.c && ./a.out 
a.c: In function ‘main’:
a.c:6: warning: dereferencing pointer ‘p’ does break strict-aliasing rules
a.c:5: note: initialized from here
0 = 1?

GCC ใจดีมากพอที่จะเตือนเราว่ามีอะไรผิดปกติในตัวอย่างง่ายๆนี้ - ในตัวอย่างที่ซับซ้อนกว่านี้คอมไพเลอร์อาจไม่สังเกตเห็น เนื่องจากpมีประเภทที่แตกต่างจาก&xการเปลี่ยนpจุดที่ไม่สามารถส่งผลกระทบต่อสิ่งที่&xชี้ไปที่ (นอกบางข้อยกเว้นที่กำหนดไว้อย่างดี) ดังนั้นคอมไพเลอร์มีอิสระในการรักษามูลค่าของxการลงทะเบียนและไม่ปรับปรุงการลงทะเบียนนี้เป็นการ*pเปลี่ยนแปลง โปรแกรมกำหนดตัวชี้สองตัวไปยังที่อยู่เดียวกันและรับค่าสองค่าที่แตกต่างกัน!

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

ดังนั้นให้คิดว่าการพอยน์เตอร์เป็นขั้นตอนแรกในการทำความเข้าใจของคุณ แต่อย่าทำตามสัญชาตญาณที่ไกลเกินไป

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

ตัวอย่างเช่น:

int q = 10; /*say q is at address 0x10203040*/
int *p = &q; /*means let p contain the address of q, which is 0x10203040*/
*p = 20; /*set whatever is at the address pointed by "p" as 20*/

แค่นั้นแหละ. มันง่ายมาก

โปรแกรมแสดงให้เห็นถึงสิ่งที่ฉันพูดและเอาท์พุทมันอยู่ที่นี่

http://ideone.com/rcSUsb

โปรแกรม:

#include <stdio.h>

int main(int argc, char *argv[])
{
  /* POINTER AS AN ADDRESS */
  int q = 10;
  int *p = &q;

  printf("address of q is %p\n", (void *)&q);
  printf("p contains %p\n", (void *)p);

  p = NULL;
  printf("NULL p now contains %p\n", (void *)p);
  return 0;
}

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

ตัดสินจากคำตอบทั้งหมดที่เขียนบางคนคิดว่า (1) ที่อยู่จะต้องเป็นจำนวนเต็มและ (2) ตัวชี้ไม่จำเป็นต้องเป็นเสมือนที่ไม่ได้กล่าวถึงในข้อกำหนด ด้วยสมมติฐานเหล่านี้ตัวชี้อย่างชัดเจนจึงไม่จำเป็นต้องมีที่อยู่

อย่างไรก็ตามเราเห็นว่าในขณะที่ (2) อาจเป็นจริง (1) อาจไม่จำเป็นต้องเป็นจริง และจะทำอย่างไรกับข้อเท็จจริงที่ & เรียกว่าที่อยู่ของผู้ประกอบการตาม @ CornStalks คำตอบ? นี่หมายความว่าผู้เขียนสเปคตั้งใจให้พอยน์เตอร์มีที่อยู่หรือไม่?

เราสามารถพูดได้ว่าตัวชี้ประกอบด้วยที่อยู่ แต่ที่อยู่ไม่จำเป็นต้องเป็นจำนวนเต็ม? อาจจะ.

ฉันคิดว่าทั้งหมดนี้คือการพูดคุยทางความหมายที่พูดไม่คล่อง มันไร้ค่าโดยสิ้นเชิง คุณสามารถนึกถึงคอมไพเลอร์ที่สร้างรหัสในลักษณะที่ค่าของตัวชี้ไม่ใช่ที่อยู่ได้หรือไม่? ถ้าเป็นเช่นนั้นอะไร นั่นคือสิ่งที่ฉันคิดว่า...

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

ตัวอย่างเช่น,

 int x;
 int* y = &x;
 char* z = &x;

ทั้ง y และ z เป็นตัวชี้ แต่ y + 1 และ z + 1 ต่างกัน หากพวกเขาเป็นที่อยู่หน่วยความจำการแสดงออกเหล่านั้นจะไม่ให้คุณค่าเดียวกันกับคุณ?

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

55555 อาจไม่ใช่ตัวชี้ถึงแม้ว่ามันอาจเป็นที่อยู่ แต่ (int *) 55555 เป็นตัวชี้ 55555 + 1 = 55556 แต่ (int *) 55555 + 1 คือ 55559 (+/- ความแตกต่างในแง่ของขนาดของ (int))

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

แหล่งที่มาของความเศร้าที่เป็นไปได้มากที่สุดคือตัวชี้ทางคณิตศาสตร์ซึ่งเป็นจุดแข็งของ C หากตัวชี้เป็นที่อยู่คุณจะคาดหวังให้ตัวชี้เลขคณิตเป็นเลขคณิตของที่อยู่ แต่มันไม่ใช่ ตัวอย่างเช่นการเพิ่ม 10 ไปยังที่อยู่ควรให้ที่อยู่ที่ใหญ่กว่าโดย 10 หน่วยที่อยู่ แต่การเพิ่ม 10 ไปยังตัวชี้จะเพิ่มขึ้นทีละ 10 เท่าของชนิดของวัตถุที่ชี้ไปที่ (และไม่ใช่ขนาดที่แท้จริง แต่จะถูกปัดขึ้นเป็นขอบเขตการจัดตำแหน่ง) ด้วยint *สถาปัตยกรรมแบบธรรมดาที่มีจำนวนเต็ม 32- บิตการเพิ่ม 10 เข้าไปจะเพิ่มขึ้นได้ 40 หน่วย (ไบต์) โปรแกรมเมอร์ C ที่มีประสบการณ์รู้เรื่องนี้และอยู่กับมัน แต่ผู้เขียนของคุณเห็นได้ชัดว่าไม่มีแฟนของคำอุปมาอุปมัยที่เลอะเทอะ

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

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

ตัวอย่างเช่นกำหนด:

union {
    int i;
    char c;
} u;

คุณสามารถมีตัวชี้ที่แตกต่างกันสามตัวชี้ไปที่วัตถุเดียวกันทั้งหมด:

void *v = &u;
int *i = &u.i;
char *c = &u.c;

หากคุณเปรียบเทียบค่าของพอยน์เตอร์เหล่านี้ค่าเหล่านี้จะเท่ากันทั้งหมด:

v==i && i==c

อย่างไรก็ตามหากคุณเพิ่มตัวชี้แต่ละตัวคุณจะเห็นว่าประเภทที่ชี้ไปนั้นเกี่ยวข้องกันหรือไม่

i++;
c++;
// You can't perform arithmetic on a void pointer, so no v++
i != c

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

Mark Bessey ได้พูดไปแล้ว แต่สิ่งนี้จะต้องเน้นย้ำอีกครั้งจนกว่าจะเข้าใจ

ตัวชี้มีส่วนเกี่ยวข้องกับตัวแปรมากกว่าตัวอักษร 3

ตัวชี้เป็น tuple ของค่า (ของที่อยู่) และประเภท (พร้อมคุณสมบัติเพิ่มเติมเช่นอ่านอย่างเดียว) ประเภท (และพารามิเตอร์เพิ่มเติมถ้ามี) สามารถเพิ่มเติมกำหนดหรือ จำกัด บริบท เช่น. __far ptr, __near ptr: บริบทของที่อยู่คืออะไร: สแต็ค, กอง, ที่อยู่เชิงเส้น, ชดเชยจากที่ไหนสักแห่ง, หน่วยความจำกายภาพหรืออะไร

เป็นคุณสมบัติประเภทที่ทำให้ตัวชี้คณิตศาสตร์แตกต่างจากเลขจำนวนเต็มเล็กน้อย

ตัวอย่างตัวนับของตัวชี้ที่ไม่ใช่ตัวแปรมีจำนวนมากเกินกว่าที่จะเพิกเฉยได้

• fopen ส่งคืนตัวชี้ FILE (ตัวแปรอยู่ที่ไหน)

• ตัวชี้สแต็คหรือตัวชี้เฟรมโดยทั่วไปแล้วจะไม่สามารถลงทะเบียนได้

  *(int *)0x1231330 = 13; - การส่งค่าจำนวนเต็มตามอำเภอใจไปยังชนิด pointer_of_integer และการเขียน / อ่านจำนวนเต็มโดยไม่ต้องแนะนำตัวแปร

ในช่วงอายุของโปรแกรม C จะมีอินสแตนซ์อื่น ๆ อีกมากมายของพอยน์เตอร์พอยน์เตอร์ที่ไม่มีที่อยู่ - ดังนั้นพวกมันจึงไม่ใช่ตัวแปร แต่เป็นนิพจน์ / ค่าที่เกี่ยวข้องกับเวลารวบรวม

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

แต่บางครั้งพอยน์เตอร์ก็เป็นเพียงส่วนหนึ่งของที่อยู่ ในบางสถาปัตยกรรมตัวชี้จะถูกแปลงเป็นที่อยู่พร้อมด้วยการเพิ่มฐานหรือใช้ CPU register อื่น

แต่ทุกวันนี้บนพีซีและสถาปัตยกรรมARM ที่มีรูปแบบหน่วยความจำแบบแบนและภาษา C เรียบเรียงกันแล้วก็โอเคที่จะคิดว่าตัวชี้เป็นที่อยู่จำนวนเต็มในบางพื้นที่ใน RAM แอดเดรสแบบมิติเดียว

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

คอมไพเลอร์จำนวนมากใช้พอยน์เตอร์โดยใช้บิตเก็บที่อยู่เครื่องจริง แต่นั่นไม่ได้เป็นการใช้งานที่เป็นไปได้เท่านั้น การดำเนินการสามารถเก็บอาร์เรย์หนึ่ง - ไม่สามารถเข้าถึงรหัสผู้ใช้ - รายการที่อยู่ฮาร์ดแวร์และขนาดที่จัดสรรของวัตถุหน่วยความจำทั้งหมด (ชุดของตัวแปร) ซึ่งโปรแกรมใช้และมีตัวชี้แต่ละตัวมีดัชนีลงในอาร์เรย์ตาม ด้วยการชดเชยจากดัชนีนั้น การออกแบบดังกล่าวจะช่วยให้ระบบไม่เพียง จำกัด รหัสให้ทำงานเฉพาะกับหน่วยความจำที่เป็นเจ้าของ แต่ยังมั่นใจว่าตัวชี้ไปยังรายการหน่วยความจำหนึ่งไม่สามารถแปลงเป็นตัวชี้ไปยังรายการหน่วยความจำอื่นโดยไม่ตั้งใจได้ (ในระบบที่ใช้ฮาร์ดแวร์ ที่อยู่หากfooและbarเป็นอาร์เรย์ของ 10 รายการที่เก็บไว้อย่างต่อเนื่องในหน่วยความจำตัวชี้ไปยังรายการ "สิบเอ็ด" ของfooอาจชี้ไปที่รายการแรกของbarแต่ในระบบที่แต่ละ "ตัวชี้" คือ ID วัตถุและออฟเซ็ตระบบสามารถดักจับถ้ารหัสพยายามทำดัชนีตัวชี้ไปfooเกินช่วงที่จัดสรร) มันอาจเป็นไปได้ที่ระบบดังกล่าวจะกำจัดปัญหาการกระจายตัวของหน่วยความจำเนื่องจากที่อยู่ทางกายภาพที่เชื่อมโยงกับพอยน์เตอร์สามารถย้ายไปมาได้

โปรดทราบว่าถึงแม้พอยน์เตอร์จะค่อนข้างเป็นนามธรรมแต่ทว่ามันยังไม่เป็นนามธรรมเพียงพอที่จะอนุญาตให้คอมไพเลอร์ C ที่ได้มาตรฐานตรงตามมาตรฐานเพื่อใช้งานตัวรวบรวมขยะ คอมไพเลอร์ C ระบุว่าทุกตัวแปรรวมถึงพอยน์เตอร์จะแสดงเป็นลำดับของunsigned charค่า รับตัวแปรใด ๆ หนึ่งสามารถย่อยสลายมันเป็นลำดับของตัวเลขและต่อมาแปลงลำดับของตัวเลขนั้นกลับไปเป็นตัวแปรประเภทเดิม ดังนั้นมันจะเป็นไปได้สำหรับโปรแกรมที่จะcallocที่เก็บข้อมูลบางส่วน (รับตัวชี้ไปที่) จัดเก็บบางอย่างที่นั่นสลายตัวชี้ไปยังชุดข้อมูลไบต์แสดงที่อยู่บนหน้าจอแล้วลบการอ้างอิงทั้งหมดไปยังพวกเขา หากโปรแกรมยอมรับหมายเลขบางส่วนจากแป้นพิมพ์ให้สร้างหมายเลขเหล่านั้นใหม่ไปยังตัวชี้แล้วพยายามอ่านข้อมูลจากตัวชี้นั้นและหากผู้ใช้ป้อนหมายเลขเดียวกันกับที่โปรแกรมได้แสดงไว้ก่อนหน้านี้โปรแกรมจะต้องส่งออกข้อมูล ที่ถูกเก็บไว้ในcallocหน่วยความจำ 'เอ็ด เนื่องจากไม่มีวิธีเป็นไปได้ที่คอมพิวเตอร์จะรู้ได้ว่าผู้ใช้ทำสำเนาของตัวเลขที่แสดงขึ้นมาหรือไม่คอมพิวเตอร์อาจทราบได้ว่าหน่วยความจำดังกล่าวจะสามารถเข้าถึงได้ในอนาคตหรือไม่

ตัวชี้เป็นชนิดตัวแปรที่มีอยู่ใน C / C ++ และมีที่อยู่หน่วยความจำ เช่นเดียวกับตัวแปรอื่น ๆ ที่มีที่อยู่ของตัวเองและใช้หน่วยความจำ (จำนวนเฉพาะแพลตฟอร์ม)

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

สรุปโดยย่อ (ซึ่งฉันจะใส่ที่ด้านบน):

(0) การคิดพอยน์เตอร์เป็นที่อยู่มักเป็นเครื่องมือการเรียนรู้ที่ดีและมักจะนำไปใช้งานจริงสำหรับพอยน์เตอร์กับชนิดข้อมูลธรรมดา

(1) แต่สำหรับพอยน์เตอร์คอมไพเลอร์ส่วนใหญ่สำหรับฟังก์ชั่นอาจไม่ใช่ที่อยู่ แต่ใหญ่กว่าที่อยู่ (โดยทั่วไปคือ 2x หรือมากกว่านั้น) หรือเป็นตัวชี้ไปยังโครงสร้างในหน่วยความจำมากกว่ามีที่อยู่ของฟังก์ชั่นและสิ่งต่าง ๆ เช่น สระว่ายน้ำคงที่

(2) ตัวชี้ไปยังข้อมูลสมาชิกและตัวชี้ไปยังวิธีการมักจะเป็นคนแปลกหน้า

(3) รหัส x86 รุ่นเก่าที่มีปัญหาตัวชี้ FAR และ NEAR

(4) ตัวอย่างมากมายโดยเฉพาะอย่างยิ่ง IBM AS / 400 ที่มี "พอยน์เตอร์ไขมัน" ที่ปลอดภัย

ฉันแน่ใจว่าคุณสามารถหาข้อมูลเพิ่มเติมได้

รายละเอียด:

UMMPPHHH !!!!! คำตอบจำนวนมากจนถึงขณะนี้คือคำตอบ "โปรแกรมเมอร์วีน" ทั่วไป - แต่ไม่ใช่คอมไพเลอร์ weenie หรือ weenie ฮาร์ดแวร์ เนื่องจากฉันแกล้งทำเป็น Weenie ฮาร์ดแวร์และมักจะทำงานกับ Weenies ของคอมไพเลอร์ให้ฉันโยนสองเซ็นต์ของฉัน:

ในหลาย ๆ อาจจะมากที่สุดคอมไพเลอร์ C ตัวชี้ไปยังข้อมูลจากประเภทนี้ในความเป็นจริงที่อยู่ของTT

ละเอียด.

แต่แม้กระทั่งคอมไพเลอร์เหล่านี้หลายตัวชี้บางอย่างไม่ได้อยู่ sizeof(ThePointer)คุณสามารถบอกนี้โดยดูที่

ตัวอย่างเช่นพอยน์เตอร์ของฟังก์ชันบางครั้งก็ใหญ่กว่าที่อยู่ธรรมดามาก หรือพวกเขาอาจเกี่ยวข้องกับระดับของการอ้อม บทความนี้ให้คำอธิบายเดียวซึ่งเกี่ยวข้องกับโปรเซสเซอร์ Intel Itanium แต่ฉันเคยเห็นคนอื่น ๆ โดยทั่วไปแล้วการเรียกฟังก์ชันคุณต้องรู้ไม่เพียง แต่ที่อยู่ของรหัสฟังก์ชั่น แต่ยังเป็นที่อยู่ของสระว่ายน้ำคงที่ของฟังก์ชัน - ขอบเขตของหน่วยความจำที่ค่าคงที่จะถูกโหลดด้วยคำสั่งโหลดเดียวมากกว่าคอมไพเลอร์ ค่าคงที่ 64 บิตจากคำสั่งโหลดทันทีและ Shift และคำสั่ง OR ดังนั้นแทนที่จะเป็นที่อยู่ 64 บิตเดียวคุณต้องมีที่อยู่ 2 64 บิต ABIs บางตัว (Application Binary Interfaces) ย้ายสิ่งนี้ไปเป็น 128 บิตในขณะที่คนอื่นใช้ระดับของการอ้อมด้วยตัวชี้ฟังก์ชั่นจริง ๆ แล้วเป็นที่อยู่ของตัวบ่งชี้ฟังก์ชั่นที่มี 2 ที่อยู่จริงเพียงแค่กล่าวถึง ไหนดีกว่ากัน ขึ้นอยู่กับมุมมองของคุณ: ประสิทธิภาพขนาดรหัส และปัญหาความเข้ากันได้บางครั้ง - บ่อยครั้งที่โค้ดสันนิษฐานว่าตัวชี้สามารถถูกส่งไปเป็นแบบยาวหรือยาว แต่อาจสันนิษฐานว่ายาวเป็น 64 บิต รหัสดังกล่าวอาจไม่เป็นไปตามมาตรฐาน แต่อย่างไรก็ตามลูกค้าอาจต้องการให้มันใช้งานได้

พวกเราหลายคนมีความทรงจำอันเจ็บปวดของสถาปัตยกรรมเซกเมนต์เก่าของ Intel x86 ที่มีตัวชี้ใกล้และตัวชี้ไกล โชคดีที่สิ่งเหล่านี้เกือบจะสูญพันธุ์ไปแล้วในตอนนี้ดังนั้นสรุปได้อย่างรวดเร็วเท่านั้น: ในโหมดจริง 16 บิต, ที่อยู่เชิงเส้นที่แท้จริงคือ

LinearAddress = SegmentRegister[SegNum].base << 4 + Offset

ในขณะที่อยู่ในโหมดป้องกันมันอาจจะเป็น

LinearAddress = SegmentRegister[SegNum].base + offset

ด้วยที่อยู่ผลลัพธ์จะถูกตรวจสอบกับขีด จำกัด ที่ตั้งไว้ในส่วน บางโปรแกรมใช้การประกาศตัวชี้ C / C ++ FAR และ NEAR ไม่ได้มาตรฐานจริงๆ แต่หลายโปรแกรมเพิ่งบอกว่า*T--- แต่มีคอมไพเลอร์และสวิทช์ลิงค์เกอร์ตัวอย่างเช่นตัวชี้รหัสอาจอยู่ใกล้ตัวชี้เพียง 32 บิตชดเชยกับสิ่งที่อยู่ การลงทะเบียน CS (ส่วนของรหัส) ในขณะที่พอยน์เตอร์ข้อมูลอาจเป็นพอยน์เตอร์ FAR โดยระบุทั้งหมายเลขเซ็กเมนต์ 16 บิตและออฟเซ็ต 32 บิตสำหรับค่า 48 บิต ตอนนี้ปริมาณทั้งสองนี้เกี่ยวข้องกับที่อยู่อย่างแน่นอน แต่เนื่องจากขนาดไม่เท่ากันซึ่งเป็นที่อยู่ใด นอกจากนี้เซ็กเมนต์ยังมีสิทธิ์ใช้งาน - อ่านอย่างเดียวอ่านเขียนปฏิบัติได้ - นอกเหนือจากสิ่งที่เกี่ยวข้องกับที่อยู่จริง

อีกตัวอย่างที่น่าสนใจคือ IMHO คือ (หรืออาจจะเป็น) ตระกูล IBM AS / 400 คอมพิวเตอร์เครื่องนี้เป็นเครื่องแรกที่ใช้ระบบปฏิบัติการใน C ++ พอยน์เตอร์ของเครื่องนี้มีขนาดปกติ 2 เท่าเช่นงานนำเสนอนี้กล่าวว่าตัวชี้ 128 บิต แต่ที่อยู่จริงคือ 48-64 บิตและอีกครั้งข้อมูลพิเศษบางอย่างที่เรียกว่าความสามารถที่ให้สิทธิ์เช่นการอ่านเขียนและขีด จำกัด เพื่อป้องกันบัฟเฟอร์ล้น ใช่: คุณสามารถทำสิ่งนี้ร่วมกับ C / C ++ - และถ้าสิ่งนี้แพร่หลาย, PLA จีนและมาเฟียสลาฟจะไม่ถูกแฮ็คเข้าสู่ระบบคอมพิวเตอร์ของตะวันตกมากมาย แต่ในอดีตการเขียนโปรแกรม C / C ++ ส่วนใหญ่ได้ละเลยความปลอดภัยสำหรับประสิทธิภาพ สิ่งที่น่าสนใจที่สุดคือตระกูล AS400 อนุญาตให้ระบบปฏิบัติการสร้างพอยน์เตอร์ที่ปลอดภัยซึ่งอาจมอบให้กับรหัสที่ไม่ได้รับสิทธิพิเศษ แต่รหัสที่ไม่ได้รับสิทธินั้นไม่สามารถปลอมแปลงหรือแก้ไขได้ ความปลอดภัยอีกครั้งและในขณะที่เป็นไปตามมาตรฐานรหัส C / C ++ ที่ไม่เป็นไปตามมาตรฐานเลอะเทอะมากจะไม่ทำงานในระบบที่ปลอดภัยเช่นนี้ อีกครั้งมีมาตรฐานอย่างเป็นทางการ

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

มีหลายวิธีในการแก้ปัญหานี้ [ปัญหาที่เกี่ยวข้องกับความเฉื่อยชาแบบเดี่ยวและหลายครั้งและการสืบทอดเสมือน] นี่คือวิธีที่คอมไพเลอร์ Visual Studio ตัดสินใจจัดการ: ตัวชี้ไปยังฟังก์ชันสมาชิกของคลาสที่สืบทอดที่สืบทอดมานั้นเป็นโครงสร้างจริงๆ "และพวกเขากล่าวต่อไปว่า" การคัดเลือกตัวชี้ฟังก์ชันสามารถเปลี่ยนขนาดได้! "

ในขณะที่คุณสามารถเดาได้จากการรักษาความปลอดภัย (ใน) pontificating ของฉันฉันได้มีส่วนร่วมใน C / C ++ ฮาร์ดแวร์ / โครงการซอฟต์แวร์ที่ตัวชี้ได้รับการปฏิบัติเช่นความสามารถมากกว่าที่อยู่ดิบ

ฉันสามารถไปต่อได้ แต่ฉันหวังว่าคุณจะได้รับความคิด

สรุปโดยย่อ (ซึ่งฉันจะใส่ที่ด้านบน):

(0) การคิดพอยน์เตอร์เป็นที่อยู่มักจะเป็นเครื่องมือการเรียนรู้ที่ดีและมักจะเป็นการใช้งานจริงสำหรับพอยน์เตอร์กับชนิดข้อมูลธรรมดา

(1) แต่สำหรับพอยน์เตอร์คอมไพเลอร์ส่วนใหญ่สำหรับฟังก์ชั่นอาจไม่ใช่ที่อยู่ แต่ใหญ่กว่าที่อยู่ (โดยทั่วไปคือ 2X หรือมากกว่านั้นเป็นสองเท่า) หรือเป็นตัวชี้ไปยังโครงสร้างในหน่วยความจำมากกว่าที่มีที่อยู่ของฟังก์ชันและสิ่งต่าง ๆ เช่น สระว่ายน้ำคงที่

(2) ตัวชี้ไปยังข้อมูลสมาชิกและตัวชี้ไปยังวิธีการมักจะเป็นคนแปลกหน้า

(3) รหัส x86 รุ่นเก่าที่มีปัญหาตัวชี้ FAR และ NEAR

(4) ตัวอย่างมากมายโดยเฉพาะอย่างยิ่ง IBM AS / 400 ที่มี "พอยน์เตอร์ไขมัน" ที่ปลอดภัย

ฉันแน่ใจว่าคุณสามารถหาข้อมูลเพิ่มเติมได้

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

คุณสามารถดูได้ด้วยวิธีนี้ ตัวชี้คือค่าที่แสดงถึงที่อยู่ในพื้นที่หน่วยความจำที่กำหนดแอดเดรสได้

ตัวชี้เป็นเพียงตัวแปรอื่นที่สามารถมีที่อยู่หน่วยความจำปกติของตัวแปรอื่น ตัวชี้เป็นตัวแปรมันก็มีที่อยู่หน่วยความจำ

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

ตัวอย่างเช่นตัวชี้ C ถูกพิมพ์ค่อนข้างรวย ถ้าคุณเพิ่มพอยน์เตอร์ผ่านอาร์เรย์ของโครงสร้างมันจะกระโดดจากโครงสร้างหนึ่งไปอีกโครงสร้างหนึ่ง

พอยน์เตอร์อยู่ภายใต้กฎการแปลงและให้การตรวจสอบประเภทเวลาคอมไพล์

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

ตัวชี้สามารถใช้เป็นตัวแปรบูลีน: มันจะทดสอบจริงถ้ามันเป็นอย่างอื่นที่ไม่ใช่โมฆะและเท็จถ้ามันเป็นโมฆะ

ในภาษาเครื่องหากตัวชี้โมฆะเป็นที่อยู่ตลกเช่น 0xFFFFFFFF คุณอาจต้องทดสอบอย่างชัดเจนสำหรับค่านั้น C ซ่อนสิ่งนั้นจากคุณ แม้ว่าชี้โมฆะคือ 0xFFFFFFFF if (ptr != 0) { /* not null! */}คุณสามารถทดสอบได้โดยใช้

การใช้พอยน์เตอร์ที่ล้มล้างระบบประเภทนำไปสู่พฤติกรรมที่ไม่ได้กำหนดในขณะที่รหัสที่คล้ายกันในภาษาเครื่องอาจถูกกำหนดไว้อย่างดี ผู้ประกอบจะรวบรวมคำแนะนำที่คุณเขียน แต่คอมไพเลอร์ C จะปรับให้เหมาะสมตามสมมติฐานที่ว่าคุณไม่ได้ทำอะไรผิด หากfloat *pตัวชี้ชี้ไปที่long nตัวแปรและ*p = 0.0ถูกเรียกใช้งานคอมไพเลอร์ไม่จำเป็นต้องจัดการสิ่งนี้ การใช้งานในภายหลังnจะไม่จำเป็นต้องอ่านรูปแบบบิตของค่าลอย แต่บางทีมันอาจเป็นการเข้าถึงที่ได้รับการปรับให้เหมาะสมซึ่งตั้งอยู่บนสมมุติฐาน "aliasing ที่เข้มงวด" ที่nยังไม่ได้สัมผัส! นั่นคือข้อสันนิษฐานว่าโปรแกรมจะมีความประพฤติดีและไม่ควรที่จะชี้ไปที่pn

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

ดังนั้นคุณจะเห็นได้ว่ามีความแตกต่างทางความหมายหลายอย่างระหว่างที่อยู่ของเครื่องและตัวชี้ C

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

+ : A variable of type integer (usually called offset) can be added to yield a new pointer
- : A variable of type integer (usually called offset) can be subtracted to yield a new pointer
  : A variable of type pointer can be subtracted to yield an integer (usually called offset)
* : De-referencing. Retrieve the value of the variable (called address) and map to the object the address refers to.
++: It's just `+= 1`
--: It's just `-= 1`

ตัวชี้ถูกจัดประเภทตามประเภทของวัตถุที่อ้างอิงในปัจจุบัน ข้อมูลเพียงส่วนเดียวเท่านั้นคือขนาดของวัตถุ

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

หมายเหตุตลอดคำอธิบายนี้ฉันได้ละทิ้งแนวคิดของหน่วยความจำ

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

ในทางเทคนิคที่อยู่ไม่เคยมีค่าใน C เพราะความหมายของคำว่า "มูลค่า" ใน (ISO) C คือ:

ความหมายที่แม่นยำของเนื้อหาของวัตถุเมื่อตีความว่ามีประเภทเฉพาะ

(เน้นโดยฉัน) อย่างไรก็ตามไม่มี "ประเภทที่อยู่" ใน C

ตัวชี้ไม่เหมือนกัน ตัวชี้เป็นชนิดชนิดหนึ่งในภาษา C มีตัวชี้ที่แตกต่างกันหลายประเภท พวกเขาไม่จำเป็นต้องปฏิบัติตามชุดที่เหมือนกันของกฎของภาษาเช่นผลกระทบของ++บนค่าของชนิดเทียบกับint*char*

ค่าใน C สามารถเป็นประเภทตัวชี้ นี้เรียกว่าค่าตัวชี้ เพื่อให้ชัดเจนค่าตัวชี้ไม่ใช่ตัวชี้ในภาษา C แต่เราคุ้นเคยกับการผสมเข้าด้วยกันเพราะใน C มันไม่น่าจะคลุมเครือ: ถ้าเราเรียกการแสดงออกpว่าเป็น "ตัวชี้" มันเป็นเพียงค่าตัวชี้ แต่ไม่ใช่ประเภทเนื่องจากประเภทที่มีชื่อใน C ไม่ แสดงโดยการแสดงออกแต่โดยประเภทชื่อหรือtypedef ชื่อ

บางสิ่งอื่น ๆ ที่ลึกซึ้ง ในฐานะผู้ใช้ C อันดับแรกเราควรทราบความobjectหมาย:

ภูมิภาคของการจัดเก็บข้อมูลในสภาพแวดล้อมการดำเนินการเนื้อหาที่สามารถเป็นตัวแทนของค่า

วัตถุเป็นเอนทิตีเพื่อแสดงค่าซึ่งเป็นประเภทเฉพาะ ตัวชี้เป็นชนิดของวัตถุ ดังนั้นถ้าเราประกาศint* p;ก็pหมายถึง "วัตถุประเภทตัวชี้" หรือ "วัตถุตัวชี้"

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

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

ISO C11 6.5.2.3

3 ตัวดำเนิน&การunary ให้ที่อยู่ของตัวถูกดำเนินการ

หมายเหตุถ้อยคำนี้ได้รับการแนะนำให้รู้จักกับ WG14 / N1256 เช่น ISO C99: TC3 ใน C99 มี

3 ตัวดำเนิน&การunary ส่งคืนที่อยู่ของตัวถูกดำเนินการ

มันสะท้อนความเห็นของคณะกรรมการ: ที่อยู่ไม่ใช่ค่าตัวชี้ที่ส่งคืนโดย&ผู้ประกอบการเอก

แม้จะมีข้อความข้างต้น แต่ก็ยังมีความยุ่งเหยิงแม้จะอยู่ในมาตรฐาน

ISO C11 6.6

9 ค่าคงที่ที่อยู่คือตัวชี้โมฆะตัวชี้ไปยัง lvalue ที่กำหนดวัตถุของระยะเวลาการจัดเก็บแบบคงที่หรือตัวชี้ไปยังตัวออกแบบฟังก์ชัน

ISO C ++ 11 5.19

3 ... การแสดงออกของค่าคงที่ที่อยู่คือการแสดงออกของค่าคงที่แกนหลักของประเภทตัวชี้ที่ประเมินถึงที่อยู่ของวัตถุที่มีระยะเวลาการจัดเก็บแบบคงที่ไปยังที่อยู่ของฟังก์ชั่นหรือค่าตัวชี้โมฆะ std::nullptr_tประเภท ...

(แบบร่างมาตรฐาน C ++ ล่าสุดใช้ถ้อยคำอื่นดังนั้นจึงไม่มีปัญหานี้)

ที่จริงทั้ง "ที่อยู่คงที่" ใน C และ "ที่อยู่คงที่นิพจน์" ใน C ++ มีการแสดงออกอย่างต่อเนื่องของประเภทตัวชี้ (หรืออย่างน้อยประเภท "เหมือนตัวชี้" ตั้งแต่ C ++ 11)

และตัวดำเนิน&การunary ในตัวถูกเรียกว่า "address-of" ใน C และ C ++; ทำนองเดียวกันstd::addressofแนะนำใน C ++ 11

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

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

ลองคิดดูสิฉันคิดว่ามันเป็นเรื่องของความหมาย ฉันไม่คิดว่าผู้เขียนนั้นถูกต้องเนื่องจากมาตรฐาน C อ้างถึงตัวชี้ว่าถือที่อยู่ไปยังวัตถุที่อ้างอิงตามที่คนอื่น ๆ ได้กล่าวถึงแล้วที่นี่ อย่างไรก็ตามที่อยู่! = ที่อยู่หน่วยความจำ ที่อยู่สามารถเป็นอะไรก็ได้ตามมาตรฐาน C แม้ว่าในที่สุดมันจะนำไปสู่ที่อยู่หน่วยความจำตัวชี้สามารถเป็น id ตัวเลือกชดเชย + (x86) อะไรก็ได้ตราบใดที่มันสามารถอธิบาย (หลังจากการทำแผนที่) หน่วยความจำใด ๆที่อยู่ในพื้นที่แอดเดรส

อีกวิธีหนึ่งในการที่ตัวชี้ C หรือ C ++ แตกต่างจากที่อยู่หน่วยความจำอย่างง่ายเนื่องจากตัวชี้ประเภทต่างๆที่ฉันไม่ได้เห็นในคำตอบอื่น ๆ (แม้ว่าขนาดของพวกเขาทั้งหมดฉันอาจมองข้าม) แต่มันอาจจะเป็นสิ่งที่สำคัญที่สุดเพราะแม้แต่โปรแกรมเมอร์ C / C ++ ที่มีประสบการณ์ก็สามารถเดินทางข้ามมันได้:

คอมไพเลอร์อาจสันนิษฐานว่าพอยน์เตอร์ของประเภทที่เข้ากันไม่ได้ไม่ได้ชี้ไปยังที่อยู่เดียวกันแม้ว่าพวกเขาจะทำอย่างชัดเจนซึ่งอาจให้พฤติกรรมที่ไม่เป็นไปได้ด้วยตัวชี้แบบง่าย == รูปแบบที่อยู่ พิจารณารหัสต่อไปนี้ (สมมติว่าsizeof(int) = 2*sizeof(short)):

unsigned int i = 0;
unsigned short* p = (unsigned short*)&i;
p[0]=p[1]=1;

if (i == 2 + (unsigned short)(-1))
{
  // you'd expect this to execute, but it need not
}

if (i == 0)
{
  // you'd expect this not to execute, but it actually may do so
}

โปรดทราบว่ามีข้อยกเว้นchar*ดังนั้นการจัดการค่าโดยใช้char*จึงเป็นไปได้ (แม้ว่าจะไม่สามารถพกพาได้)

ข้อมูลสรุปอย่างรวดเร็ว: ที่อยู่ AC คือค่าซึ่งโดยทั่วไปจะแสดงเป็นที่อยู่หน่วยความจำระดับเครื่องโดยมีประเภทเฉพาะ

คำว่า "ตัวชี้" ที่ไม่มีเงื่อนไขมีความกำกวม C มีตัวชี้วัตถุ (ตัวแปร) ตัวชี้ประเภทตัวชี้การแสดงออกและตัวชี้ค่า

เป็นเรื่องธรรมดามากที่จะใช้คำว่า "ตัวชี้" เพื่อหมายถึง "ตัวชี้วัตถุ" และอาจนำไปสู่ความสับสน - ซึ่งเป็นสาเหตุที่ฉันพยายามใช้ "ตัวชี้" เป็นคำคุณศัพท์แทนคำนาม

มาตรฐาน C อย่างน้อยในบางกรณีใช้คำว่า "ตัวชี้" เพื่อหมายถึง "ค่าตัวชี้" ตัวอย่างเช่นคำอธิบายของmallocบอกว่า "ส่งคืนตัวชี้ null หรือตัวชี้ไปยังพื้นที่ที่จัดสรร"

ดังนั้นที่อยู่ใน C คืออะไร? มันคือค่าตัวชี้คือค่าของตัวชี้บางประเภท (ยกเว้นว่าค่าตัวชี้โมฆะไม่จำเป็นต้องเรียกว่า "ที่อยู่" เนื่องจากไม่ใช่ที่อยู่ของสิ่งใด)

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

AC "ที่อยู่" โดยทั่วไปแล้วจะใช้งานเป็นที่อยู่ของเครื่อง - เช่นเดียวกับintค่าC จะถูกนำมาใช้เป็นคำของเครื่อง แต่ที่อยู่ C (ค่าตัวชี้) เป็นมากกว่าที่อยู่เครื่อง มันเป็นค่ามักจะแสดงเป็นที่อยู่เครื่องและก็คุ้มค่ากับเฉพาะบางประเภท

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

อย่างไรก็ตามมาตรฐานพูดคุยในระดับที่เฉพาะเจาะจงของสิ่งที่เป็นนามธรรม คนที่ผู้เขียนพูดถึงเกี่ยวกับผู้ที่ "รู้ว่าที่อยู่คืออะไรเกี่ยวกับ" แต่ผู้ที่ยังใหม่กับ C จะต้องได้เรียนรู้เกี่ยวกับที่อยู่ในระดับที่แตกต่างกันของนามธรรม - บางทีโดยการเขียนโปรแกรมภาษาประกอบ ไม่มีการรับประกันว่าการใช้งาน C จะใช้การแสดงที่อยู่เดียวกันกับที่การใช้งานซีพียู opcodes (เรียกว่า "ที่อยู่ร้านค้า" ในตอนนี้) ซึ่งคนเหล่านี้รู้อยู่แล้ว

เขาพูดต่อเกี่ยวกับ "การจัดการที่อยู่อย่างสมเหตุผล" เท่าที่มาตรฐาน C เป็นห่วงก็ไม่มีสิ่งใดที่ "จัดการที่อยู่อย่างสมเหตุสมผล" นอกจากนี้ยังมีการกำหนดไว้ในตัวชี้และนั่นคือมัน แน่นอนว่าคุณสามารถแปลงตัวชี้เป็นจำนวนเต็มทำ bitwise หรือ ops เลขคณิตและจากนั้นแปลงกลับ สิ่งนี้ไม่ได้รับประกันว่าจะทำงานได้ตามมาตรฐานดังนั้นก่อนที่จะเขียนรหัสนั้นคุณควรทราบว่าการใช้งาน C ของคุณนั้นแสดงถึงพอยน์เตอร์และดำเนินการแปลงอย่างไร มันอาจจะใช้เป็นตัวแทนอยู่ที่คุณคาดหวัง แต่มันก็ไม่ได้ว่าเป็นความผิดของคุณเพราะคุณไม่ได้อ่านคู่มือการใช้งาน นั่นไม่ใช่ความสับสนมันเป็นขั้นตอนการเขียนโปรแกรมที่ไม่ถูกต้อง ;-)

ในระยะสั้น C ใช้แนวคิดที่เป็นนามธรรมของที่อยู่มากกว่าที่ผู้เขียนทำ

แนวคิดของผู้เขียนเกี่ยวกับที่อยู่ของหลักสูตรไม่ได้เป็นคำระดับต่ำสุดในเรื่องนี้ สิ่งที่มีการแมปหน่วยความจำเสมือนและ RAM ที่อยู่จริงในชิปหลายตัวจำนวนที่คุณบอกซีพียูคือ "ที่อยู่ร้านค้า" ที่คุณต้องการเข้าถึงโดยทั่วไปแล้วไม่มีอะไรเกี่ยวข้องกับข้อมูลที่คุณต้องการอยู่ในฮาร์ดแวร์ มันเป็นเลเยอร์ทางอ้อมและการเป็นตัวแทน แต่ผู้แต่งได้เลือกหนึ่งสิทธิ์ หากคุณกำลังจะทำอย่างนั้นเมื่อพูดถึง C ให้เลือกระดับ C เพื่อรับสิทธิพิเศษ !

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

เพียงแค่บอกว่าพอยน์เตอร์เป็นส่วนหนึ่งของกลไกการแบ่งเซ็กเมนต์ซึ่งแปลเป็น Linear Address หลังจากการแบ่งเซ็กเมนต์และจากนั้นเป็นฟิสิคัลแอดเดรสหลังจากการเพจ ที่อยู่ทางกายภาพได้รับการแก้ไขจาก ram ของคุณ

       Selector  +--------------+         +-----------+
      ---------->|              |         |           |
                 | Segmentation | ------->|  Paging   |
        Offset   |  Mechanism   |         | Mechanism |
      ---------->|              |         |           |
                 +--------------+         +-----------+
        Virtual                   Linear                Physical