จิตใจที่อ่อนเยาว์จำเป็นต้องเรียนรู้แนวคิดตัวชี้?

เหตุใด C master Dennis Ritchie จึงแนะนำพอยน์เตอร์ใน C และทำไมภาษาโปรแกรมอื่น ๆ เช่น VB.NET หรือ Java หรือ C # จึงกำจัดภาษาเหล่านั้น ฉันพบบางจุดใน Google และฉันต้องการฟังความคิดเห็นของคุณด้วย ทำไมพวกเขาถึงกำจัดแนวคิดของตัวชี้ในภาษาสมัยใหม่?

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

คุณคิดว่าความรู้เกี่ยวกับพอยน์เตอร์ยังคงมีความสำคัญต่อโปรแกรมเมอร์ใหม่หรือไม่? ทุกวันนี้ผู้คนกำลังใช้ VB.NET หรือ Java ซึ่งสนับสนุนคุณสมบัติขั้นสูงมากกว่า C (และไม่ใช้แนวคิดตัวชี้) และหลาย ๆ คนอย่างที่ฉันเห็นในตอนนี้ (เพื่อนของฉัน) เลือกภาษาเหล่านี้โดยไม่สนใจ C เนื่องจากสนับสนุนคุณสมบัติขั้นสูง ฉันบอกให้พวกเขาเริ่มต้นด้วย C. พวกเขาบอกว่าเป็นเรื่องเสียที่จะเรียนรู้แนวคิดของพอยน์เตอร์เมื่อคุณทำสิ่งขั้นสูงใน VB.NET หรือ Java ซึ่งเป็นไปไม่ได้ใน C

คุณคิดอย่างไร?

อัปเดต :

ความคิดเห็นที่ฉันอ่านบน Google คือ:

1. คอมพิวเตอร์ก่อนหน้านี้ช้าเกินไปและไม่ได้รับการปรับให้เหมาะสม

2. การใช้พอยน์เตอร์ทำให้สามารถเข้าถึงที่อยู่ได้โดยตรงและประหยัดเวลาแทนที่จะทำสำเนาในการเรียกใช้ฟังก์ชั่น

3. ความปลอดภัยยิ่งแย่ลงอย่างมากเมื่อใช้พอยน์เตอร์และนั่นคือสาเหตุที่ Java และ C # ไม่ได้รวมเอาไว้

สิ่งเหล่านี้และสิ่งที่ฉันค้นพบ ฉันยังต้องการคำตอบที่มีค่า ที่จะได้รับการชื่นชมอย่างมาก

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

การพูดว่า "สิ่งขั้นสูงที่ทำใน VB.Net หรือ Java เป็นไปไม่ได้ใน C" แสดงมุมมองที่ จำกัด มากเพื่อพูดอย่างน้อย :-)

ประการแรกภาษาทั้งหมดเหล่านี้ (แม้แต่ชุดประกอบ) กำลังทัวริงสมบูรณ์ดังนั้นในทางทฤษฎีสิ่งใดก็ตามที่เป็นไปได้ในภาษาเดียวเป็นไปได้ในทุกภาษา แค่คิดว่าจะเกิดอะไรขึ้นเมื่อชิ้นส่วนของรหัส VB.Net หรือ Java ถูกคอมไพล์และดำเนินการ: ในที่สุดมันจะถูกแปลเป็น (หรือแมปเป็น) รหัสเครื่องเพราะนั่นเป็นสิ่งเดียวที่เครื่องเข้าใจ ในภาษาที่คอมไพล์เช่น C และ C ++ คุณสามารถรับรหัสเต็มของเครื่องได้เทียบเท่ากับซอร์สโค้ดระดับสูงกว่าเดิมซึ่งเป็นไฟล์ / ไลบรารีที่สามารถเรียกทำงานได้หนึ่งรายการขึ้นไป ในภาษาที่ใช้ VM นั้นเป็นเรื่องยุ่งยากมากขึ้น (และอาจไม่สามารถทำได้) เพื่อให้ได้การแทนค่ารหัสเครื่องทั้งหมดของโปรแกรมของคุณ แต่ในที่สุดมันก็มีอยู่ที่ใดที่หนึ่งภายในส่วนลึกของระบบ runtime และ JIT

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

เพื่อให้ได้คำถาม

คุณคิดว่าความรู้เกี่ยวกับตัวชี้ไปยังคนหนุ่มสาว [... ] เป็นสิ่งสำคัญหรือไม่?

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

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

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

ฉันคิดว่าคุณต้องแตกต่างกัน

Java และภาษาระดับสูงอื่น ๆ ไม่ได้ลบพอยน์เตอร์ สิ่งที่พวกเขาทำคือการลบเลขคณิตตัวชี้ธรรมดา

ในความเป็นจริงแล้ว Java ยังคงอนุญาตให้ใช้ตัวชี้ทางคณิตศาสตร์ที่มีการป้องกันและจำกัด : การเข้าถึงอาร์เรย์ ใน C เก่าธรรมดาการเข้าถึงอาเรย์คืออะไรนอกจากการลงทะเบียน มันเป็นสัญกรณ์ที่แตกต่างกันคือน้ำตาลซินแทคติกถ้าคุณต้องการสื่อสารอย่างชัดเจนว่าคุณกำลังทำอะไร
ยังเทียบเท่ากับarray[index] *(array+index)เนื่องจากว่ามันก็เทียบเท่ากับindex[array]แม้ว่าฉันคิดว่าคอมไพเลอร์ C บางคนอาจให้คำเตือนถ้าคุณทำเช่นนั้น
ในฐานะที่เป็นข้อพิสูจน์ที่เทียบเท่ากับpointer[0] *pointerนั่นเป็นเพียงเพราะ "ตัวชี้ไปยังอาเรย์" เป็นที่อยู่ของรายการแรกของอาเรย์และที่อยู่ขององค์ประกอบที่ตามมาจะถูกคำนวณโดยการเพิ่มดัชนี

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

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

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

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

IMHO ทุกคนในงานของเราควรเข้าใจได้หรือว่าพวกเขาอยู่ผิดที่

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

พอยน์เตอร์มีการใช้งานในโครงสร้างข้อมูล (รายการที่เชื่อมโยง) และการออกแบบฐานข้อมูล (Foreign Key)

ภาษาเช่น VB และ C # สามารถส่งผ่านข้อมูลโดย "การอ้างอิง" ไปยังวิธีการต่างๆซึ่งอาจถือได้ว่าเป็นประเภทของตัวชี้

การทำความเข้าใจตำแหน่งที่ข้อมูลถูกจัดสรรในหน่วยความจำ (stack vs. heap) ยังคงมีความสำคัญต่อประสิทธิภาพของอัลกอริทึม

การเรียนรู้พื้นฐานที่ถูกต้องเป็นสิ่งสำคัญในความคิดของฉัน

ใช่ใช่ใช่ใช่และใช่ !!!

หากคุณไม่ทราบพื้นฐานคุณจะไม่สามารถแก้ไขปัญหาที่ยากแปลกประหลาดยากและซับซ้อนได้

และถ้าคุณเข้าใจพื้นฐานที่ดีจริงๆคุณก็จะสามารถทำการตลาดได้มากขึ้น

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

รู้มากเท่าที่คุณจะทำได้

ใช่ความเข้าใจเป็นสิ่งสำคัญ

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

ตัวอย่าง:

List<int> a = new List<int>();
a.Add(2);
a.Add(9);
a.Add(8);
a.Add(1);
List<int> b = new List<int>();
b = a; //Does not make a copy, b is just a synonym!
b.Sort();
for (int i = 0; i < a.Count; i++)
{
    Console.WriteLine("a: " + a[i] + " b: " + b[i]);
}

และแน่นอนผลลัพธ์ก็เป็นเช่นนี้:

a: 1 b: 1
a: 2 b: 2
a: 8 b: 8
a: 9 b: 9

การรู้วิธีใช้พวกมันไม่ใช่สิ่งสำคัญ แต่การเข้าใจพวกมันเป็นสิ่งสำคัญ!

ชี้แนวคิด! ​​= ชี้ทางคณิตศาสตร์! = ชี้ไวยากรณ์

เรื่องแรกเสมอถ้าคุณต้องการ (และคุณ) ทำความเข้าใจเกี่ยวกับการทำสำเนาลึก / ตื้นส่งผ่านการอ้างอิง / ส่งผ่านตามค่า ฯลฯ อีกสองเรื่องเฉพาะในกรณีที่ภาษาของคุณอนุญาตให้คุณใช้

เหตุใด C master Dennis Ritchie จึงแนะนำพอยน์เตอร์ใน C

เพราะพอยน์เตอร์เป็นกลไกที่ทรงพลังมากซึ่งสามารถใช้ได้หลายวิธี

และทำไมภาษาโปรแกรมอื่น ๆ เช่น VB.NET หรือ Java หรือ C # จึงกำจัดภาษาเหล่านั้น

เนื่องจากพอยน์เตอร์เป็นกลไกที่อันตรายมากซึ่งสามารถนำไปใช้ในทางที่ผิดได้หลายวิธี

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

นี่คือรายการที่ไม่สมบูรณ์ที่ใช้สำหรับพอยน์เตอร์:

• การจัดสรรแบบไดนามิก ( new T)
• โครงสร้างข้อมูลแบบเรียกซ้ำ ( struct T { T* next; /* ... */ };)
• ตัววนซ้ำในอาร์เรย์ ( for (T* p = &a[0]; p != &a[0] + n; ++p) { ... })
• การเข้าถึงวัตถุร่วมกัน ( T* new_pointer = existing_pointer;)
• ความหลากหลายชนิดย่อย ( T* pointer_to_base = pointer_to_derived;)
• การโทรแบบเดิมโดยการอ้างอิง ( mutate(&object);)
• ประเภทตัวเลือก ( if (p) { /* ... */ })

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

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

และตอนนี้อย่างจริงจังพอยน์เตอร์ไม่ได้เป็นส่วนสำคัญของการเขียนโปรแกรมในหลาย ๆ ด้าน แต่พวกเขาอนุญาตให้ผู้คนเข้าใจว่าการทำงานของ internals เป็นอย่างไร และถ้าเราไม่มีใครเข้าใจการทำงานของ internals ก็จะมีสถานการณ์ที่ SQL2020, Windows 15 และ Linux 20.04 จะถูกเขียนในขยะเสมือนที่เก็บรวบรวมเครื่องเสมือนที่เรียกใช้กว่า 30 เลเยอร์ของ abstraction โดยใช้รหัสที่สร้างผ่าน IDE ใน JavaScript .

นี่ไม่ใช่สิ่งที่ฉันต้องการจะดู

ดังนั้นใช่พวกเขาจะต้องแน่นอน!

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

ลองพิจารณาสิ่งต่อไปนี้ใน C ++ และ Java และฉันเดาว่ามันไม่แตกต่างกันมากใน C #:
aClass *x = new aClass();
aClass x = new aClass();
ไม่มีความแตกต่างระหว่างพอยน์เตอร์กับการอ้างอิงใช่ไหม?
ควรหลีกเลี่ยงการใช้ตัวชี้ทางคณิตศาสตร์เว้นแต่ว่าจำเป็นและเมื่อโปรแกรมที่มีโมเดลระดับสูงจึงไม่มีปัญหามากนัก

โปรแกรมเมอร์มืออาชีพควรเป็นพอยน์เตอร์หลัก

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

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

นั่นคือความคิดเห็นของฉัน ... ; o)

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

เลิกใช่แล้ว ! ทุกคนที่โปรแกรมต้องเข้าใจพอยน์เตอร์และทางอ้อม

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

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

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

int a, foo[10];
foo[2] = a;

บรรทัดที่ 2 ในตัวคำนวณเลขคณิตจะเป็น:

*(foo + sizeof(int) * 2) = a;

หากไม่เข้าใจพอยน์เตอร์คุณจะไม่สามารถเข้าใจการจัดการหน่วยความจำสแต็คกองหรือแม้แต่อาร์เรย์! นอกจากนี้เราจำเป็นต้องเข้าใจพอยน์เตอร์และการลดความสำคัญเพื่อให้เข้าใจถึงการส่งผ่านฟังก์ชันและวัตถุ

TL: DR : ชี้ความเข้าใจเป็นพื้นฐานในการทำความเข้าใจกับคอมพิวเตอร์ทำงานจริง

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

การจัดการกับพอยน์เตอร์ด้วยตนเองอาจเกิดข้อผิดพลาดได้ง่าย (นำไปสู่การรั่วไหลของหน่วยความจำและรหัสที่ใช้ประโยชน์ได้) และใช้เวลานานในการทำให้ถูกต้อง ดังนั้น Java และ C # ฯลฯ ทั้งหมดจึงจัดการหน่วยความจำและพอยน์เตอร์ของคุณให้กับคุณผ่าน Virtual Machines (VMs) สิ่งนี้มีประสิทธิภาพน้อยกว่าการใช้ raw C / C ++ ถึงแม้ว่า VMs จะปรับปรุงอย่างต่อเนื่อง

C (และ C ++) ยังคงเป็นภาษาที่ใช้กันอย่างแพร่หลายโดยเฉพาะในคอมพิวเตอร์ประสิทธิภาพสูงการเล่นเกมและพื้นที่ฮาร์ดแวร์ฝังตัว ฉันขอบคุณเป็นการส่วนตัวที่ฉันได้เรียนรู้เกี่ยวกับพอยน์เตอร์เนื่องจากการเปลี่ยนเป็นการอ้างอิงของ Java (แนวคิดคล้ายกับพอยน์เตอร์) นั้นง่ายมากและฉันก็ไม่หลงทางเมื่อเห็น NullPointerException แรกของฉัน (ซึ่งควรเรียกว่า NullReferenceException .

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

นี่คือความจริงวัตถุประสงค์:

บางภาษารองรับการเข้าถึงหน่วยความจำโดยตรง (ตัวชี้) บางภาษาไม่รองรับ มีเหตุผลที่ดีสำหรับแต่ละกรณี

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

2. ข้อได้เปรียบที่ชัดเจนของภาษาเช่น C คือช่วยให้คุณสามารถควบคุมโปรแกรมของคุณได้ดีขึ้น เมื่อไหร่ที่คุณต้องการมันวันนี้? เฉพาะเมื่อคุณสร้างแอพพลิเคชั่นโครงสร้างพื้นฐานเช่นโปรแกรมที่เกี่ยวข้องกับระบบปฏิบัติการและสภาพแวดล้อมรันไทม์ หากคุณต้องการพัฒนาซอฟต์แวร์ที่ดีรวดเร็วแข็งแกร่งและเชื่อถือได้การจัดการหน่วยความจำอัตโนมัติมักเป็นทางเลือกที่ดีกว่าของคุณ

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

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

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

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

1. วิธีที่ฉันเห็นหากสิ่งที่คุณต้องทำคือสร้างแอปพลิเคชันใน Java หรือ C # หรืออะไรทำนองนั้นคุณต้องมุ่งเน้นไปที่เทคนิคการออกแบบและการนำไปปฏิบัติที่เหมาะสม รหัสที่ทดสอบได้, รหัสสะอาด, รหัสที่ยืดหยุ่น เพื่อให้.

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

หากฉันเป็นผู้สัมภาษณ์ที่ต้องการจ้างคนมารับใบสมัครระดับสูงภาษาเหล่านั้นจะเป็นสิ่งที่ฉันสนใจมากที่สุด

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

แต่ในโลกทุกวันนี้มันไม่ใช่สิ่งศักดิ์สิทธิ์

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

มีวิธีการทำงานหลายอย่างและทันสมัยหลายวิธีฉันต้องการค่าสูงกว่าความสามารถในการทำเลขคณิตตัวชี้แฟนซีพูดเขียนฟังก์ชั่นสตริงคัดลอกที่เพิ่มประสิทธิภาพที่ 1,000 อาจทำงานแย่กว่า String.copy ของ std lib ของคุณในทางใดทางหนึ่ง

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

ฉันมักจะเห็นความพยายามที่ล้มเหลวโดยสิ้นเชิงในการเพิ่มประสิทธิภาพเว็บเซอร์เล็ตหรือรหัสที่คล้ายกันเพื่อให้ได้รับ 5% เมื่อแคช (บันทึก) การปรับ SQL ให้เหมาะสมหรือเพียงแค่ปรับแต่งการกำหนดค่าเว็บเซิร์ฟเวอร์สามารถให้ผล 100% หรือมากกว่า การเล่นซอกับพอยน์เตอร์เป็นการเพิ่มประสิทธิภาพก่อนเวลาอันควรในกรณีส่วนใหญ่

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

นอกจากนี้วันนี้พิจารณา Mobile Applications ซึ่งมีหน่วยความจำที่ จำกัด มากเราต้องใช้มันอย่างระมัดระวังเพื่อให้การดำเนินการของมันรวดเร็วมากกับการตอบสนองของผู้ใช้ ... ดังนั้นเพื่อจุดประสงค์นี้เราต้องอ้างอิงโดยตรงกับค่า ...

พิจารณาอุปกรณ์ของ Apple หรือภาษา Objective C ซึ่งทำงานร่วมกับแนวคิดตัวชี้เท่านั้น ตัวแปรทั้งหมดที่ประกาศใน Objective C มีตัวชี้ คุณต้องผ่านวิกิของ Objective C