คำถามติดแท็ก c

ฉันมักจะไม่มีปัญหาในการตัดสินใจว่าข้อมูลบางอย่างจะต้องเป็นแบบโกลบอลสแตติกหรือบนสแต็ก (ไม่มีการจัดสรรแบบไดนามิกที่นี่ดังนั้นจึงไม่มีการใช้ฮีป) ฉันได้อ่านคำถามสองสามข้อเช่นคำถามนี้แต่คำถามของฉันเฉพาะเจาะจงมากขึ้นเพราะมันเกี่ยวข้องกับข้อมูลจำนวนมากมากเมื่อเทียบกับหน่วยความจำระบบ ฉันกำลังใช้งานโค้ดที่มีอยู่ซึ่งฉันพยายามปรับปรุง (ออกแบบปัญหาที่เป็นไปได้การแสดง ฯลฯ ) รหัสนี้วิ่งบน MCU 8bit เก่ามีเพียง4KB ของแรม ในรหัสนี้ฉันต้องเผชิญกับการใช้งานของอาร์เรย์เกือบ 1KB (ใช่1KB ในระบบRAM 4KB ) แต่ละไบต์ของอาร์เรย์นี้ถูกใช้นั่นไม่ใช่คำถาม ปัญหาคือว่าอาร์เรย์นี้เป็นอาร์เรย์แบบคงที่ในไฟล์ที่มีการประกาศดังนั้นวงจรชีวิตของมันเป็นเช่นเดียวกับโปรแกรมหนึ่ง (เช่นถือได้ว่าไม่มีที่สิ้นสุด) อย่างไรก็ตามหลังจากอ่านโค้ดฉันเพิ่งค้นพบว่าอาเรย์นี้ไม่จำเป็นต้องมีวงจรชีวิตที่ไม่มีที่สิ้นสุดมันถูกสร้างและจัดการด้วยวิธีการที่สมบูรณ์ดังนั้นเราควรจะสามารถประกาศได้เฉพาะในฟังก์ชั่นที่ใช้ วิธีนี้มันจะอยู่ในสแต็คและเราจะบันทึก 1KB ของ RAM นี้ ทีนี้คำถาม: นี่เป็นความคิดที่ดีไหม? จากมุมมองการออกแบบหากไม่ต้องการวงจรชีวิตที่ไม่มีที่สิ้นสุด / ทั่วโลกมันเป็นของสแต็ค แต่เดี๋ยวก่อนนั่นคือ 1KB จาก 4KB ไม่มีข้อเสียในการจัดสรร RAM 25% ของแบบนี้ใช่ไหม? (นั่นอาจเป็น 50% หรือมากกว่าของสแต็ก) ใครบางคนสามารถแบ่งปันประสบการณ์บางอย่างกับสถานการณ์แบบนี้หรือใครบางคนคิดเกี่ยวกับเหตุผลที่ถูกต้องที่จะไม่วางอาร์เรย์นี้ในกอง? ฉันกำลังมองหาข้อเสียทางเทคนิคเช่นเดียวกับความคิดเห็นในการออกแบบ สิ่งเดียวที่ฉันใส่ใจคือฉันต้องทำให้แน่ใจว่าจริง ๆ แล้วฉันมีสแต็ก 1KB ฟรีเมื่อเข้าสู่ฟังก์ชันนี้ …

12 c  embedded-systems  stack  memory-usage 

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

12 c  language-features  c11 

ฉันเพิ่งเริ่มเรียนรู้การเขียนโปรแกรมใน C และเพื่อปรับปรุงความเข้าใจของฉันเกี่ยวกับพอยน์เตอร์และอาร์เรย์ฉันพยายามอ้างถึงองค์ประกอบของอาร์เรย์โดยไม่สร้างตัวชี้ใด ๆ เลย: for(k1 = 0; k1 < ROW; k1++){ for(k2 = 0; k2 < COLUMN; k2++){ array[k1][k2] = k1*COLUMN + k2 + 1; printf("[%d][%d] = %d\n", k1, k2, *(array[k1] + k2)); } } รหัสทั้งหมดรวบรวมและทำงานอย่างไม่มีที่ติ ฉันคิดว่าต้องสร้างตัวชี้สำหรับทุก ๆ อาร์เรย์ในซอร์สโค้ดขนาดใหญ่ดูเหมือนว่าจะไม่มีประสิทธิภาพสูง ดังนั้นแทนที่จะมีที่อยู่ของอาร์เรย์ที่เก็บและดึงข้อมูลโดยใช้ตัวชี้มันเป็นวิธีการเขียนโปรแกรมที่ไม่ดีหรือไม่ที่จะใช้ที่อยู่ของอาร์เรย์โดยตรงดังที่แสดงไว้ด้านบน

12 programming-practices  c 

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

12 programming-languages  c  high-level 

คุณลักษณะที่น่าสนใจของ C เมื่อเทียบกับภาษาอื่น ๆ คือประเภทข้อมูลจำนวนมากนั้นขึ้นอยู่กับขนาดของคำของสถาปัตยกรรมเป้าหมายแทนที่จะถูกระบุในเงื่อนไขแบบสัมบูรณ์ แม้ว่าสิ่งนี้จะช่วยให้ภาษาสามารถใช้ในการเขียนโค้ดบนเครื่องที่อาจมีปัญหากับบางประเภท แต่ก็เป็นการยากที่จะออกแบบรหัสซึ่งจะทำงานอย่างต่อเนื่องในสถาปัตยกรรมที่แตกต่างกัน พิจารณารหัส: uint16_t ffff16 = 0xFFFF; int64_t who_knows = ffff16 * ffff16; ในสถาปัตยกรรมที่intมี 16 บิต (ยังคงเป็นจริงของไมโครคอนโทรลเลอร์ขนาดเล็กจำนวนมาก) รหัสนี้จะกำหนดค่า 1 โดยใช้พฤติกรรมที่กำหนดไว้อย่างดี บนเครื่องที่intมี 64 บิตก็จะกำหนดค่า 4294836225 อีกครั้งโดยใช้พฤติกรรมที่กำหนดไว้อย่างดี บนเครื่องที่intมี 32 บิตก็น่าจะกำหนดค่า -131071 (ฉันไม่ทราบว่าจะเป็นพฤติกรรมการใช้งานที่กำหนดหรือไม่ได้กำหนด) แม้ว่าโค้ดจะไม่ใช้สิ่งใดนอกจากสิ่งที่ควรจะเป็นในนาม "ประเภทขนาดคงที่" มาตรฐานจะกำหนดให้คอมไพเลอร์สองแบบที่ใช้กันในวันนี้จะให้ผลลัพธ์ที่แตกต่างกันสองแบบและคอมไพเลอร์ยอดนิยมจำนวนมากในปัจจุบัน ตัวอย่างนี้เป็นการประดิษฐ์ที่ฉันไม่คาดหวังในรหัสโลกแห่งความจริงเพื่อกำหนดผลิตภัณฑ์ของค่า 16 บิตสองค่าโดยตรงกับค่า 64- บิต แต่มันถูกเลือกเป็นตัวอย่างสั้น ๆ เพื่อแสดงจำนวนเต็มสามวิธี การส่งเสริมการขายอาจโต้ตอบกับประเภทที่ไม่ได้ลงชื่อขนาดคงที่ มีสถานการณ์ในโลกจริงบางอย่างที่จำเป็นสำหรับการคำนวณทางคณิตศาสตร์ในประเภทที่ไม่ได้ลงนามตามกฎของเลขคณิตเลขจำนวนเต็มทางคณิตศาสตร์อื่น ๆ ที่จำเป็นที่จะต้องดำเนินการตามกฎของเลขคณิตแบบแยกส่วนและบางอย่างที่มันไม่จริง …

12 c  language-design  data-types 

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

12 c  history 

ในคำตอบของฉันฉันใช้_tเมื่อสิ้นสุดประเภทซึ่งจบลงอย่างดีที่สุดแย้ง นี่คือแนวทางปฏิบัติที่ฉันใช้ในโครงการปัจจุบันของฉัน typedef struct { int x; int y; } point_t; ครั้งนี้มีวัตถุประสงค์เพื่อให้สอดคล้องกับประเภท C จากstddef.hชอบหรือsize_t ptrdiff_tอย่างไรก็ตามตามความคิดเห็นบางอย่างในคำถามของฉัน_tpostfix ดูเหมือนจะถูกสงวนไว้สำหรับ POSIX ฉันควรใช้อะไรแทน_t? หรือฉันควรใช้_tต่อไปหรือไม่? คำถามนี้สำหรับทั้ง C และ C ++ หากภาษาเหล่านี้มีการประชุมที่แตกต่างกันอย่าลังเลที่จะตอบคำถาม

12 c++  c  naming 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน6 ปีที่ผ่านมา C ++ เป็นภาษาที่ยอดเยี่ยมในหลาย ๆ ด้าน แต่บางสิ่งที่ยุ่งยากในการเขียนโดยไม่ต้องใช้ IDE ในฐานะผู้ใช้ VIM มันน่าสนใจมากถ้าฉันสามารถใช้ภาษาระดับสูงขึ้นซึ่งทำให้ฉันสามารถเขียน C ++ ด้วย S-Expressions และอาจมีมาโครคล้าย Lisp ซึ่งทำให้สามารถสร้างโค้ดที่สะอาดได้ในขณะเดียวกันก็หลีกเลี่ยงการเขียน patters เดิม ครั้งแล้วครั้งเล่า. ฉันถาม freenode และทดสอบแนวคิดหลายอย่างเช่นการคอมไพล์ Lisp-> C กับคอมไพเลอร์เช่น ECL และ Bigloo แต่ไม่มีสิ่งใดที่สร้างโค้ด C ที่สะอาดเป็นพิเศษ มีงานใด ๆ ในปัญหานี้หรือไม่?

12 programming-languages  c++  c  lisp  vim 

ทำไม? ขึ้นอยู่กับแหล่งที่มาของคุณคอมไพเลอร์ของ Intel น่าจะเป็นหรือคอมไพเลอร์ที่สร้างไฟล์ปฏิบัติการที่เร็วที่สุดสำหรับสถาปัตยกรรม x86 (ปรับปรุง 5 ถึง 100% เวลาในการประมวลผล) Intel เสนอคอมไพเลอร์สำหรับ Linux ภายใต้ใบอนุญาตที่ไม่ใช่เชิงพาณิชย์ฟรี (ฉันคิดว่าฉันอ่านมันฟรีที่ใดที่หนึ่งบนหน้าเว็บของพวกเขา: Intel - การพัฒนาซอฟต์แวร์ที่ไม่ใช่เชิงพาณิชย์ ) นอกจากนี้ยังมีใบอนุญาตที่ไม่ใช่เชิงพาณิชย์สำหรับนักเรียนฟรี แต่ใบอนุญาตนี้ไม่สามารถใช้ได้แม้ว่าจะมีเครื่องมือสำหรับระบบปฏิบัติการหลักทั้งสาม (การเชื่อมโยงหลุดเนื่องจากข้อ จำกัด ด้านชื่อเสียง) เป้าหมาย ฉัน (ในฐานะนักเรียนที่ไม่ใช่นักศึกษา) ต้องการใช้คอมไพเลอร์ของ Intel สำหรับการปรับปรุงความเร็วในการดำเนินการที่เป็นไปได้ภายใต้ใบอนุญาตที่ไม่ใช่เชิงพาณิชย์เพื่อรวบรวมไฟล์วัตถุที่สามารถเชื่อมโยงเพื่อสร้างไฟล์ประมวลผลและไลบรารีลิงค์แบบไดนามิกสำหรับ Windows X) รายละเอียดเพิ่มเติม: สิ่งที่ฉันอนุมานจากเอกสารนี้คือคอมไพเลอร์ Intel สร้างออบเจ็กต์ไฟล์ที่เข้ากันได้กับคอมไพเลอร์ที่โดดเด่นของแพลตฟอร์ม Sub-คำถาม: รูปแบบไฟล์ออบเจ็กต์ของ gcc, g ++, cl, mingw32, icc, icpc, และ icl บน Windows และ …

12 c++  open-source  c  compiler  cross-platform 

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

12 c  git  builds  build-system 

มาโครที่รู้จักกันในชื่อlikelyและunlikelyมาโครช่วยให้คอมไพเลอร์ทราบว่าifจะป้อนหรือข้าม การใช้มันจะส่งผลในการปรับปรุงประสิทธิภาพ (ค่อนข้างเล็กน้อย) ฉันเริ่มใช้มันเมื่อไม่นานมานี้และฉันไม่แน่ใจว่าควรใช้คำใบ้ดังกล่าวบ่อยเพียงใด ฉันกำลังใช้กับการตรวจสอบข้อผิดพลาดifs unlikelyซึ่งมักจะถูกทำเครื่องหมายเป็น ตัวอย่างเช่น: mem = malloc(size); if (unlikely(mem == NULL)) goto exit_no_mem; ดูเหมือนว่าจะใช้ได้ แต่การตรวจสอบข้อผิดพลาดifเกิดขึ้นบ่อยครั้งดังนั้นจึงใช้มาโครดังกล่าว คำถามของฉันคือมันมีมากเกินไปlikelyและunlikelyแมโครในทุกการตรวจสอบข้อผิดพลาดif? ในขณะที่เราอยู่ที่นี่พวกเขามักจะใช้ที่อื่นที่ไหน? ในการใช้งานปัจจุบันของฉันมันอยู่ในไลบรารีที่ทำให้เกิดนามธรรมจากระบบย่อยเรียลไทม์ดังนั้นโปรแกรมจะกลายเป็นแบบพกพาระหว่าง RTAI, QNX และอื่น ๆ ที่กล่าวว่าฟังก์ชั่นส่วนใหญ่ค่อนข้างเล็กและเรียกฟังก์ชั่นอื่น ๆ หนึ่งหรือสองโดยตรง หลายคนมีstatic inlineฟังก์ชั่น อย่างแรกเลยไม่ใช่แอพพลิเคชั่นที่ฉันสามารถโพรไฟล์ได้ มันไม่มีเหตุผลที่จะ "ระบุคอขวด" เนื่องจากเป็นห้องสมุดไม่ใช่แอปพลิเคชันแบบสแตนด์อโลน ประการที่สองมันคล้ายกับ "ฉันรู้ว่ามันไม่น่าเป็นไปได้ฉันก็จะบอกให้คอมไพเลอร์" ifฉันไม่แข็งขันพยายามที่จะเพิ่มประสิทธิภาพ

12 c  performance  clean-code 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน6 ปีที่ผ่านมา กฎที่สิบของ Greenspun (จริงๆแล้วเป็นเพียงกฎเดียว) ระบุว่า: Any sufficiently complicated C or Fortran program contains an ad hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp. ความทรงจำของฉันคือว่ามีเอกสารบางอย่างในหัวข้อบางทีสำหรับโครงการ Quattro (สเปรดชีต) ของ Borland และอื่น ๆ Google ไม่มีความช่วยเหลือบางทีคำค้นหาที่ถูกต้องอาจไม่เป็นที่สนใจ ฉันกำลังมองหาเอกสารหรือบทความที่สนับสนุนการอ้างสิทธิ์นี้หากมี

12 c  language-design  lisp  fortran 

ตัวชี้ชี้ไปที่ 0x0000 เหมือนกับตัวชี้ที่ตั้งค่าเป็น NULL หรือไม่ ถ้าค่า NULL ถูกกำหนดในภาษา C แปลตำแหน่งทางกายภาพเป็นอะไร มันเหมือนกับ 0x0000 ฉันจะหารายละเอียดเพิ่มเติมเกี่ยวกับแนวคิดเหล่านี้ได้ที่ไหน

12 c  pointers  null 

ใน C (ANSI, C99 ฯลฯ ) structs อาศัยอยู่ในเนมสเปซของตนเอง struct สำหรับรายการที่เชื่อมโยงอาจมีลักษณะเช่นนี้: struct my_buffer_type { struct my_buffer_type * next; struct my_buffer_type * prev; void * data; }; ดูเหมือนว่าเป็นเรื่องที่ค่อนข้างเป็นธรรมชาติ แต่สำหรับโปรแกรมเมอร์ C ส่วนใหญ่จะพิมพ์ struct เหล่านั้นโดยอัตโนมัติดังต่อไปนี้ typedef struct tag_buffer_type { struct tag_buffer_type * next; struct tag_buffer_type * prev; void * data; } my_buffer_type; และจากนั้นอ้างอิง struct …

12 programming-languages  c  namespace 

บ่อยครั้งมากที่ฉันเห็นในรหัส C ปฏิเสธรหัสข้อผิดพลาดกลับเช่นแทนreturn -EINVAL return EINVALเหตุใดจึงต้องใช้การปฏิเสธ

12 c