“ blub paradox” และ c ++

ฉันอ่านบทความที่นี่: http://www.paulgraham.com/avg.htmlและส่วนหนึ่งเกี่ยวกับ "blub paradox" นั้นน่าสนใจเป็นพิเศษ ในฐานะที่เป็นคนที่ใช้รหัสใน c ++ เป็นหลัก แต่มีการสัมผัสกับภาษาอื่น ๆ (ส่วนใหญ่เป็น Haskell) ฉันรู้ว่ามีบางสิ่งที่มีประโยชน์ในภาษาเหล่านี้ซึ่งยากที่จะทำซ้ำใน c ++ คำถามส่วนใหญ่สำหรับคนที่มีความเชี่ยวชาญทั้งใน c ++ และภาษาอื่น ๆ มีคุณสมบัติภาษาที่ทรงพลังหรือสำนวนที่คุณใช้ในภาษาที่ยากที่จะคิดหรือนำไปใช้ถ้าคุณเขียนเฉพาะใน c ++?

โดยเฉพาะอย่างยิ่งคำพูดนี้ดึงดูดความสนใจของฉัน:

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

หากปรากฎว่าฉันเป็นเทียบเท่าโปรแกรมเมอร์ "Blub" โดยอาศัยการใช้ c ++ สิ่งนี้ทำให้เกิดคำถามต่อไปนี้: มีแนวคิดหรือเทคนิคที่มีประโยชน์ที่คุณพบในภาษาอื่นที่คุณคิดว่ายากที่จะทำให้เป็นแนวคิดได้หรือไม่ เคยเขียนหรือ "คิด" ใน c ++?

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

คำถามนี้ไม่ได้มีไว้เพื่อการอภิปราย "c ++ vs lisp" หรือการอภิปรายประเภทสงครามภาษาใด ๆ การถามคำถามเช่นนี้เป็นวิธีเดียวที่ฉันสามารถเห็นความเป็นไปได้ในการค้นหาเกี่ยวกับสิ่งต่าง ๆ ที่ฉันไม่รู้ว่าไม่รู้

ก็เพราะคุณพูดถึง Haskell:

1. การจับคู่รูปแบบ ฉันพบว่าการจับคู่รูปแบบจะง่ายต่อการอ่านและเขียนมากขึ้น พิจารณาคำจำกัดความของแผนที่และคิดว่าจะนำไปใช้ในภาษาได้อย่างไรโดยไม่ต้องจับคู่รูปแบบ

   map :: (a -> b) -> [a] -> [b]
   map f [] = []
   map f (x:xs) = f x : map f xs

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

3. การเขียนโปรแกรมการทำงานโดยทั่วไป ใช้แผนที่และพับแทนการวนซ้ำ recursion มันเกี่ยวกับการคิดในระดับที่สูงขึ้น

4. การประเมินผลขี้เกียจ อีกครั้งเกี่ยวกับการคิดในระดับที่สูงขึ้นและให้ระบบจัดการการประเมิน

5. พันธมิตรแพคเกจและโมดูล การมีแพคเกจดาวน์โหลดของ Cabal สำหรับฉันนั้นสะดวกกว่าการค้นหาซอร์สโค้ดการเขียน makefile และอื่น ๆ ความสามารถในการนำเข้าเฉพาะชื่อบางชื่อนั้นดีกว่าการรวบรวมไฟล์ต้นฉบับทั้งหมดที่ถูกรวบรวมเข้าด้วยกันจากนั้นจึงรวบรวม

memoize!

ลองเขียนมันใน C ++ ไม่ได้อยู่กับ C ++ 0x

ยุ่งยากเกินไป? โอเคลองด้วย C ++ 0x

ดูว่าคุณสามารถเอาชนะ 4-line (หรือ 5-line, อะไรก็ได้: P) เวอร์ชั่นคอมไพล์เวลาใน D:

auto memoize(alias Fn, T...)(T args) {
    auto key = tuple(args);                               //Key is all the args
    static typeof(Fn(args))[typeof(key)] cache;           //Hashtable!
    return key in cache ? cache[key] : (cache[key] = Fn(args));
}

สิ่งที่คุณต้องทำเพื่อเรียกมันคือ:

int fib(int n) { return n > 1 ? memoize!(fib)(n - 1) + memoize!(fib)(n - 2) : 1;}
fib(60);

คุณสามารถลองสิ่งที่คล้ายกันใน Scheme แม้ว่าจะช้าลงเล็กน้อยเนื่องจากมันเกิดขึ้นในขณะใช้งานและเนื่องจากการค้นหาที่นี่เป็นแบบเส้นตรงแทนที่จะเป็นแบบแฮช (และก็เพราะว่า Scheme):

(define (memoize f)
    (let ((table (list)))
        (lambda args
            (cdr
                (or (assoc args table)
                    (let ((entry (cons args (apply f args))))
                        (set! table (cons entry table))
                        entry))))))
(define (fib n)
        (if (<= n 1)
            1
            (+ (fib (1- n))
                (fib (- n 2)))))))
(set! fib (memoize fib))

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

ที่กล่าวว่าฉันไม่สามารถคิดออกด้านบนของหัวของฉันของภาษาพื้นเมือง C ++ คุณสมบัติที่ทำสิ่งที่yieldPython หรือ JavaScript ทำ

อีกตัวอย่างหนึ่งคือการเขียนโปรแกรมพร้อมกัน C ++ 0x จะพูดเกี่ยวกับเรื่องนี้ แต่มาตรฐานปัจจุบันไม่ได้และการเห็นพ้องด้วยกันเป็นวิธีคิดใหม่ทั้งหมด

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

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

วิปัสสนาและการคอมไพล์โค้ดเวลาทำงาน / การดำเนินการ / การประเมินผล / อะไรก็ตามที่เป็นคุณสมบัติที่ทรงพลังมหาศาลที่ C ++ ขาด

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

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

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

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

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

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

¹ บางทีไม่ได้ค่อนข้างใกล้ชิด แต่carและcdrใช้ชื่อของพวกเขาจากฮาร์ดแวร์: แรกเสียงกระเพื่อมวิ่งบนเครื่องที่มีการปรับตัวลดลงที่เกิดขึ้นจริงและลงทะเบียนที่อยู่ที่เกิดขึ้นจริงสมัครสมาชิก เป็นไงบ้าง

อาร์เรย์ที่เกี่ยวข้อง

วิธีการประมวลผลข้อมูลทั่วไปคือ:

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

เครื่องมือที่เหมาะสมสำหรับมันเป็นอาเรย์

• การสนับสนุนภาษาที่ดีที่สุดสำหรับอาเรย์แบบเชื่อมโยงที่ฉันเห็นคือMUMPSซึ่งอาเรย์แบบเชื่อมโยงคือ: 1. เรียงลำดับเสมอ 2. สามารถสร้างได้บนดิสก์ (ฐานข้อมูลที่เรียกว่า) โดยมีไวยากรณ์เดียวกัน (ผลข้างเคียง: มันมีประสิทธิภาพมากในฐานะฐานข้อมูลโปรแกรมเมอร์สามารถเข้าถึง btree ดั้งเดิมระบบ NoSQL ที่ดีที่สุดตลอดกาล)
• รางวัลที่สองของฉันไปPHPผมชอบforeachและไวยากรณ์ง่ายเช่น$ a [] = xหรือ$ a [x] [Y] [Z] ++

ฉันไม่ชอบไวยากรณ์อาเรย์ JavaScript เพราะฉันไม่สามารถสร้างกล่าวว่าa [x] [Y] [Z] = 8 , แรกที่ผมต้องสร้างa [x]และa [x] [Y]

โอเคใน C ++ (และใน Java) มีพอร์ทคลาสของตู้คอนเทนเนอร์, แผนที่ , Multimap , แต่อย่างใด แต่ถ้าฉันต้องการสแกนผ่านฉันต้องทำการวนซ้ำและเมื่อฉันต้องการแทรกองค์ประกอบระดับลึกใหม่ฉัน ต้องสร้างระดับบนทั้งหมด ฯลฯ อึดอัด

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

ข้อจำกัดความรับผิดชอบ: ฉันไม่คุ้นเคยกับ C # และ. languges .NET อื่น ๆ AFAIK มีการจัดการอาเรย์แบบเชื่อมโยงที่ดี

ฉันไม่ได้เรียนรู้ Java, C \ C ++, Assembly และ Java Script ฉันใช้ C ++ เพื่อหาเลี้ยงชีพ

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

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

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

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

มันซับซ้อนมากขึ้นเมื่อคุณเพิ่มกระบวนทัศน์การเขียนโปรแกรมลงในส่วนประสมเนื่องจากมุมมองของเราเกี่ยวกับโลกนั้นแตกต่างกัน

มีคุณสมบัติภาษาที่มีประสิทธิภาพหรือสำนวนที่คุณใช้ในภาษาที่ยากที่จะคิดหรือนำไปใช้ถ้าคุณเขียนเฉพาะใน c ++?

มีแนวคิดหรือเทคนิคที่เป็นประโยชน์ใด ๆ ที่คุณพบในภาษาอื่น ๆ ที่คุณอาจพบว่ายากที่จะทำให้แนวความคิดคุณเขียนหรือ "คิด" ใน c ++ หรือไม่

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

ลงทะเบียนการจัดสรรและการเรียกประชุม

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

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

การสร้างรหัสรันไทม์

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

ฉันขอแนะนำให้เริ่มต้นใช้งานEVALแบบแผนและเล่นกับเพื่อเรียนรู้เกี่ยวกับการประเมินผลแบบกึ่งวงจร

จัดการต้นไม้

ต้นไม้มีทุกที่ในการเขียนโปรแกรม ในการแยกวิเคราะห์คุณมีต้นไม้ไวยากรณ์ที่เป็นนามธรรม ในคอมไพเลอร์คุณมี IRs ที่เป็นต้นไม้ ในกราฟิกและการเขียนโปรแกรม GUI คุณมีแผนผังฉาก

นี้"ขันง่าย JSON Parser สำหรับ C ++"น้ำหนักในเพียง 484 LOC ซึ่งมีขนาดเล็กมากสำหรับ C ++ ตอนนี้เปรียบเทียบกับตัวแยกวิเคราะห์ JSON แบบง่าย ๆ ของฉันซึ่งมีน้ำหนักเพียง 60 LOC ของ F # ความแตกต่างเป็นหลักเนื่องจาก ML ของพีชคณิตประเภทข้อมูลและการจับคู่รูปแบบ (รวมถึงรูปแบบที่ใช้งานอยู่) ทำให้ง่ายต่อการจัดการต้นไม้อย่างมากมาย

ลองชมต้นไม้สีแดงดำใน OCamlด้วย

โครงสร้างข้อมูลที่ทำงานได้อย่างหมดจด

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

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

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

หางโทร

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

ตัวอย่างเช่นลองใช้การดำเนินการของปัญหาเครื่องหลัง 0-1 นี้โดยใช้รูปแบบการส่งต่ออย่างต่อเนื่องพร้อมการบันทึกใน F #จากอุตสาหกรรมการเงิน เมื่อคุณมีการโทรหางสไตล์การส่งต่อที่ต่อเนื่องอาจเป็นคำตอบที่ชัดเจน แต่ C ++ ทำให้มันเป็นเรื่องยาก

เห็นพ้องด้วย

อีกตัวอย่างที่ชัดเจนคือการเขียนโปรแกรมพร้อมกัน แม้ว่าสิ่งนี้จะเป็นไปได้ทั้งหมดใน C ++ แต่มันก็เป็นข้อผิดพลาดอย่างมากเมื่อเทียบกับเครื่องมืออื่น ๆ แต่ที่สำคัญที่สุดคือการสื่อสารกระบวนการตามลำดับที่เห็นในภาษาเช่น Erlang, Scala และ F #

นี่เป็นคำถามเก่า แต่เนื่องจากไม่มีใครพูดถึงมันฉันจะเพิ่ม list (และตอนนี้ dict) comprehensions ง่ายต่อการเขียนหนึ่งซับใน Haskell หรือ Python ที่แก้ปัญหา Fizz-Buzz ลองทำใน C ++

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

แม้แต่ความเข้าใจที่ง่ายที่สุดที่ใคร ๆ ก็สามารถเขียนในหนึ่งบรรทัดใน Python (และการจำกัดความยาวของอักขระ 79 บรรทัดของ Guido) ก็กลายเป็นรหัสบรรทัดมากมายเมื่อแปลเป็น C ++ และบางบรรทัดของโค้ด C ++ นั้นค่อนข้างซับซ้อน

ไลบรารีที่คอมไพล์เรียกการเรียกกลับซึ่งเป็นฟังก์ชันสมาชิกที่ผู้ใช้กำหนดของคลาสที่ผู้ใช้กำหนด

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

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

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

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

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

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

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