ประเภทที่เฉพาะเจาะจงยังคงมีความจำเป็น?

สิ่งหนึ่งที่เกิดขึ้นกับฉันในวันอื่น ๆ คือประเภทที่เฉพาะเจาะจงยังคงมีความจำเป็นหรือเป็นมรดกตกทอดเรา สิ่งที่ฉันหมายถึงคือเราต้องการสั้น, int, long, bigint ฯลฯ หรือไม่

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

โฟลตของจริงและดับเบิลนั้นค่อนข้างเลื่องลือเพราะประเภทนั้นขึ้นอยู่กับความแม่นยำที่คุณต้องการ สตริงควรจะสามารถใช้หน่วยความจำน้อย upp ในหลาย ๆ กรณี (ใน. Net) ที่ส่วนใหญ่ ascii ใช้สตริง buth ใช้หน่วยความจำสองเท่าเพราะการเข้ารหัสแบบ unicode

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

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

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

มันไม่ได้แทนที่ประสิทธิภาพการเขียนโปรแกรมที่สำคัญ มันเป็นเพียงการเขียนโปรแกรมที่ไม่ใช่ประสิทธิภาพที่สำคัญยิ่งกว่า

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

แม้แต่ภาษาที่ใช้งานทั่วไปที่รองรับการเชื่อมโยงล่าช้า (ความละเอียดของประเภทที่รันไทม์เช่น VB6) มีแนวโน้มที่จะส่งเสริมการพิมพ์ที่รัดกุมในขณะนี้ (VB.NET) เนื่องจากประสิทธิภาพการทำงานที่เคยเกิดขึ้นเมื่อถูกผูกมัดช้าและเนื่องจากคุณ ท้ายด้วยรหัสน่าเกลียดเมื่อประเภทไม่ชัดเจน ( อ้างอิง / Professional Refactoring ใน Visual Basic - Danijel Arsenovski )

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

คิดว่าการแลกเปลี่ยนระหว่างอาร์เรย์และเวกเตอร์ (หรือรายการที่เชื่อมโยง) ด้วยอาร์เรย์การค้นหาตำแหน่งที่เฉพาะเจาะจงเป็นเรื่องง่าย ๆ ในการรับตำแหน่งเริ่มต้นและเลื่อนตัวชี้หน่วยความจำช่องว่าง x เพื่อค้นหาตำแหน่งใหม่นั้นในหน่วยความจำ คิดว่า int เป็นบิต [32] การอ่าน int เกี่ยวข้องกับการเดินผ่านอาร์เรย์นั้นเพื่อรับค่าบิตทั้งหมด

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

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

จำเป็นต้องใช้ประเภทเฉพาะสำหรับภาษาและโครงการที่เน้นเป็นศูนย์กลาง ตัวอย่างหนึ่งคือ on-the-wire network protocols

แต่ลองสร้าง - เพื่อความสนุก - ประเภท varint ในภาษาอย่าง C ++ สร้างจากnewอาร์เรย์ของ int

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

การคูณมีค่าใกล้เคียงกัน ใช้การเพิ่ม / เปลี่ยนแบบวนซ้ำ และเช่นเคยความบิดที่แท้จริงในหางของคุณคือการหาร [*]

คุณทำอะไรหายไปเมื่อสิ่งนี้เกิดขึ้น?

• เวลาที่กำหนด คุณมี syscall ( new) ที่อาจก่อให้เกิดจุดที่ไม่สามารถควบคุมได้

• พื้นที่ที่กำหนด

• คณิตศาสตร์กึ่งซอฟแวร์ช้า

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

[*] อัลกอริทึมทางคณิตศาสตร์ของฮาร์ดแวร์ Cf สำหรับวิธีที่เร็วกว่าในการทำมัน - โดยปกติกลอุบายนั้นจะเป็นการทำงานแบบขนาน

นี่เป็นคำถามที่ดี มันอธิบายว่าทำไมภาษาเช่น Python ไม่ต้องการ "short, int, bigint etc. ": จำนวนเต็ม, ดี, จำนวนเต็ม (มีชนิดจำนวนเต็มเดียวใน Python 3) และไม่มีขนาด จำกัด (นอกเหนือจากที่ แน่นอนว่าหน่วยความจำของคอมพิวเตอร์)

สำหรับ Unicode การเข้ารหัส UTF-8 (ซึ่งเป็นส่วนหนึ่งของ Unicode) ใช้อักขระเดียวสำหรับอักขระ ASCII เท่านั้นดังนั้นมันจึงไม่เลว

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

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

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

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

มันขึ้นอยู่กับภาษา สำหรับภาษาระดับสูงกว่าเช่น Python, Ruby, Erlang และเช่นนั้นคุณมีเพียงแนวคิดของจำนวนเต็มและทศนิยม

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

ในshortยังมีสถานที่สำหรับประเภทที่เฉพาะเจาะจงมากขึ้น แต่ปัญหาการพัฒนาจำนวนมากไม่ต้องการความแม่นยำนั้น

ฉันเพิ่งสร้างแลดเดอร์ลอจิกเอดิเตอร์และรันไทม์และฉันตัดสินใจที่จะ จำกัด ประเภท:

• บูลีน
• จำนวน
• เชือก
• วันเวลา

ฉันเชื่อว่ามันทำให้ใช้งานง่ายขึ้นสำหรับผู้ใช้ นี่คือการออกเดินทางที่รุนแรงจาก PLC ส่วนใหญ่ที่มีประเภท "ปกติ" ทุกประเภทที่คุณเห็นในภาษาเช่น C

ภาษาการเขียนโปรแกรมเคลื่อนไปในทิศทางนั้น ใช้สตริงตัวอย่าง ในภาษาเก่าคุณต้องประกาศขนาดของสตริงเช่นPIC X(42)ใน COBOL DIM A$(42)ในบางรุ่นของ BASIC หรือ [ VAR] CHAR(42)ใน SQL ในภาษาสมัยใหม่คุณมีเพียงหนึ่งstringประเภทที่จัดสรรแบบไดนามิกและไม่จำเป็นต้องคำนึงถึงขนาด

อย่างไรก็ตามจำนวนเต็มที่ต่างกัน:

สิ่งที่ฉันหมายถึงคือเราต้องการสั้น, int, long, bigint ฯลฯ หรือไม่

ดู Python มันใช้เพื่อแยกความแตกต่างระหว่างจำนวนเต็มขนาดเครื่อง ( int) และขนาดโดยพลการ ( long) ใน 3.x อดีตหายไป (เก่าlongคือใหม่int) และไม่มีใครคิดถึงมัน

แต่ยังคงมีประเภทเฉพาะสำหรับลำดับของจำนวนเต็ม 8 บิตในรูปแบบของและbytes bytearrayทำไมไม่ใช้ a tupleหรือlistจำนวนเต็มตามลำดับ จริงbytesมีวิธีการแบบสตริงพิเศษที่tupleไม่ได้ แต่ประสิทธิภาพแน่นอนมีส่วนเกี่ยวข้องกับมัน

โฟลตของจริงและดับเบิลนั้นค่อนข้างเลื่องลือเพราะประเภทนั้นขึ้นอยู่กับความแม่นยำที่คุณต้องการ

ไม่ได้จริงๆ วิธีการ "ทุกอย่างมีความแม่นยำสองเท่า" เป็นเรื่องปกติ

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

โฟลตของจริงและดับเบิลนั้นค่อนข้างเลื่องลือเพราะประเภทนั้นขึ้นอยู่กับความแม่นยำที่คุณต้องการ สตริงควรจะสามารถใช้หน่วยความจำน้อย upp ในหลาย ๆ กรณี (ใน. Net) ที่ส่วนใหญ่ ascii ใช้สตริง buth ใช้หน่วยความจำสองเท่าเพราะการเข้ารหัสแบบ unicode

Fortran มีบางอย่างที่คล้ายกัน (ฉันไม่รู้ว่านี่คือสิ่งที่คุณหมายถึงอย่างแท้จริงเพราะฉันเห็นสองคำถามขึ้นจริง ๆ ) ตัวอย่างเช่นใน F90 ขึ้นไปคุณไม่จำเป็นต้องกำหนดขนาดประเภทอย่างชัดเจนเพื่อที่จะพูด ซึ่งเป็นสิ่งที่ดีไม่เพียง แต่จะช่วยให้คุณเป็นศูนย์กลางในการกำหนดประเภทข้อมูลของคุณ แต่ยังเป็นวิธีการกำหนดแบบพกพา REAL * 4 ไม่เหมือนกันในทุกการใช้งานของโปรเซสเซอร์ทั้งหมด (และโดยโปรเซสเซอร์ฉันหมายถึง CPU + คอมไพเลอร์) ไม่ใช่โดย Longshot

select_real_kind (p, r)ส่งคืนค่าชนิดของข้อมูลจริงที่มีความแม่นยำทศนิยมมากกว่าหลักอย่างน้อย p หลักและช่วงเลขชี้กำลังสูงกว่าอย่างน้อย r

ตัวอย่างเช่นคุณไป

program real_kinds
integer,parameter :: p6 = selected_real_kind(6)
integer,parameter :: p10r100 = selected_real_kind(10,100) !p is precision, r is range
integer,parameter :: r400 = selected_real_kind(r=400)
real(kind=p6) :: x
real(kind=p10r100) :: y
real(kind=r400) :: z

print *, precision(x), range(x)
print *, precision(y), range(y)
print *, precision(z), range(z)
end program real_kinds

(ฉันคิดว่ามันเป็นตัวอย่างที่อธิบายได้ด้วยตนเอง)

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