แท็ก: โปรแกรมแรกในภาษาซี พื้นฐาน ศรีบ่อแลนด์. เกียร์รหัส C ศรี เอ็มบาร์กาเดโร. ซี เอ็มเอส วิชวล สตูดิโอ ซี เอ็ม เอส เอ็กซ์เพรส

การเขียนโปรแกรม C แรกของเรา

ขั้นแรกคุณต้องติดตั้ง ซอฟต์แวร์- โดยหลักการแล้ว ไม่สำคัญว่าคุณจะใช้ซอฟต์แวร์อะไร เช่นเดียวกับที่ไม่สำคัญ ระบบปฏิบัติการ- แต่ตลอดหลักสูตร ผมจะยกตัวอย่างการใช้ MS Visula Studio 2012 Express Edition Visual Studio 2012 Express Edition ให้บริการฟรีและเพียงพอที่จะศึกษาทั้งหลักสูตร นอกจากนี้ ดังที่แสดงให้เห็นแล้วว่า มีโค้ดที่เข้มงวดกว่ามากและให้คำอธิบายข้อผิดพลาดและคำเตือนที่สมบูรณ์ยิ่งขึ้น เมื่อเรียนภาษา คุณสามารถใช้ Borland (หรือที่เรียกว่า CodeGEAR หรือ Embarcadero เป็นต้น) Dev Cpp, MinGW หรือ gcc หรืออะไรก็ได้ที่คุณต้องการ

ตัวอย่างสำหรับ MS Visual Studio

1. เปิด IDE ไปที่ File | สร้างโครงการ...

2. เลือกแอปพลิเคชันคอนโซลและตั้งชื่อ ในกรณีนี้คือ first_program

4. ทำเครื่องหมายในช่อง "โครงการว่าง"

5. หลังจากนั้นเราจะได้โครงสร้างโครงการที่ว่างเปล่า มาเพิ่มกันเถอะ องค์ประกอบใหม่: คลิกขวาที่โฟลเดอร์
“ไฟล์ ซอร์สโค้ด" | เพิ่ม | สร้างองค์ประกอบ...

เพิ่มไฟล์ cpp ใหม่ แต่บันทึกเป็นนามสกุล .c

ฉันตั้งชื่อไฟล์ว่า main.c ทุกอย่างพร้อมแล้วคุณสามารถเขียนโปรแกรมได้ ขั้นตอนสำหรับแพลตฟอร์มอื่นๆ

บอร์แลนด์

ฉันติดตั้ง Code Gear C++ Builder 2007 เท่านั้น แต่ในรุ่นอื่นๆ (และรุ่นก่อนหน้า) ทุกอย่างก็เหมือนเดิม

1. มาสร้างกันเถอะ โครงการใหม่ไฟล์ | ใหม่ | อื่น...

2. เพิ่มแอปพลิเคชันคอนโซล

3. เลือกภาษา C

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

ตัวอย่างสำหรับ cc/gcc สำหรับเทอร์มินัล

โอ้เปิดรายการโปรดของคุณ โปรแกรมแก้ไขข้อความและคัดลอกโค้ดโปรแกรมไปที่นั่น

#รวม int main(int argc, char* argv) ( printf("Hello, World!"); scanf("1"); return 0; )

หากคุณบันทึกโปรแกรมไว้ในไฟล์ชื่อ hello.c ให้พิมพ์คำสั่งในเทอร์มินัล

Cc hello.c -o สวัสดี

Gcc สวัสดี -o สวัสดี

ในกรณีนี้คุณต้องอยู่ในโฟลเดอร์ของโปรแกรมอย่างแน่นอน gcc จะสร้าง ไฟล์ปฏิบัติการด้วยชื่อสวัสดี เรียกใช้แล้วมันจะส่งออก Hello, World!

บางครั้งอาจมีปัญหากับสิทธิ์การเข้าถึง ตรวจสอบว่าคุณมีไฟล์ปฏิบัติการ หรือไม่ก็ให้สิทธิ์ตัวเองในการเรียกใช้ไฟล์นั้น

Chmod 760 สวัสดี

หากคุณมีหลายไฟล์ คุณจะต้องแสดงรายการชื่อของไฟล์ทั้งหมดตามลำดับ ตัวอย่างเช่น หากคุณมีไฟล์อีกสองไฟล์ simple.h และ simple.c คุณจะต้องเขียน

Cc hello.c simple.c -o สวัสดี

รหัสโปรแกรม

เป็นเรื่องปกติในโปรแกรมแรกที่จะแสดง Hello, World! ไปที่หน้าจอ

#รวม #รวม int main(int argc, char* argv) ( printf("Hello, World!"); _getch(); return 0; )

รันโปรแกรม (Run | Run หรือ F9 สำหรับ Borland, Build | Build Solution หรือ F5 สำหรับ MS) โปรแกรมจะแสดง Hello, World! และจะรอให้คุณกดปุ่มใดก็ได้

ลองดูโค้ดโดยละเอียดเพิ่มเติม สองบรรทัดแรก

#รวม #รวม

คำสั่งไปยังคอมไพเลอร์สำหรับการเชื่อมต่อไลบรารีมาตรฐาน stdio (เอาต์พุตอินพุตมาตรฐาน) และ conio (เอาต์พุตอินพุตคอนโซล) ส่วนขยาย .h ระบุว่าเป็นไฟล์ส่วนหัว คอมไพลเลอร์จะคัดลอกโค้ดของไลบรารี conio และ stdio และทำให้สามารถใช้ฟังก์ชันที่อธิบายไว้ในไลบรารีเหล่านี้ได้

Int หลัก (int argc, ถ่าน * argv)

นี่คือหน้าที่หลัก มันแตกต่างจากฟังก์ชั่นอื่น ๆ ที่คุณสามารถกำหนดได้ตรงที่เป็นจุดเริ่มต้น - การทำงานของโปรแกรมเริ่มต้นจากมัน

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

#รวม #รวม int main() ( printf("Hello, World!"); _getch(); return 0; ) ฟังก์ชั่นหลักจะต้องส่งคืนจำนวนเต็ม หากเป็น 0 แสดงว่าฟังก์ชันทำงานโดยไม่มีข้อผิดพลาด ในมาตรฐาน C สมัยใหม่ คุณไม่สามารถคืนค่า 0 และอธิบายฟังก์ชันเป็น void main ได้ #รวม #รวม

void main() ( printf("Hello, World!"); _getch(); ) โปรแกรมของเราตอนนี้ดูเรียบง่ายมาก บรรทัด printf("สวัสดีชาวโลก!"); พิมพ์บรรทัด Hello, World! บนหน้าจอมอนิเตอร์
_getch() รอการกดปุ่ม
มาทำอะไรที่ซับซ้อนกว่านี้เพื่อเรียนรู้วิธีเพิ่มไฟล์ใหม่ลงในโปรแกรม ตอนนี้เป็นสิ่งสำคัญสำหรับคุณที่จะเรียนรู้วิธีเพิ่มไฟล์ใหม่ หากส่วนหนึ่งของโค้ดยังไม่ชัดเจนก็ไม่สำคัญ 1. สร้างไฟล์ส่วนหัวใหม่ในโฟลเดอร์ "ไฟล์ส่วนหัว" เรียกว่า simple.h 2. สร้าง
ไฟล์ใหม่

simple.c ในโฟลเดอร์ Source Files #รวม 3. เพิ่มไปที่ simple.h

#ifndef _SIMPLE_H_ #define _SIMPLE_H_ #include เป็นโมฆะทำบางสิ่งบางอย่าง (); #เอ็นดิฟทำบางสิ่งบางอย่าง ไม่มีเนื้อหา แต่จะอธิบายไว้ในไฟล์ simple.c ที่นี่เรายังรวมไลบรารี stdio และ conio ไว้ด้วย
เพิ่มลงใน .c แบบง่าย

#include "simple.h" เป็นโมฆะ doSomething() ( printf("ใช้งานได้!"); _getch(); )

เรารวมไฟล์ส่วนหัวไว้ใน simple.c มีเขียนไว้ว่า เครื่องหมายคำพูดคู่เพราะไม่ใช่ไฟล์ไลบรารีมาตรฐาน ไฟล์ไลบรารีมาตรฐานมักจะอยู่ในโฟลเดอร์รวมของ IDE หากเราวางไฟล์ของเราไว้ตรงนั้น ก็สามารถประกาศไฟล์เหล่านั้นในวงเล็บมุมได้เช่นกัน คุณยังสามารถใช้เส้นทางไฟล์แบบสัมบูรณ์ในเครื่องหมายคำพูดคู่ได้ เนื่องจากเราได้รวมไลบรารี conio และ stdio ไว้ในไฟล์ .h แล้ว ไลบรารีเหล่านั้นจึง "มองเห็นได้" ในไฟล์ .c
ถัดไปใน main.c

เรามาอธิบายกันดีกว่า ในภาษา C โปรแกรมใดๆ จะประกอบด้วยหน่วยโปรแกรมหลายหน่วย และแต่ละหน่วยเป็นฟังก์ชัน ฟังก์ชันในภาษา C คล้ายกับฟังก์ชันหรือรูทีนย่อยใน Fortran หรือโพรซีเดอร์ในภาษา Pascal ชื่อของฟังก์ชันจะถูกเลือกตามอำเภอใจ (เป็นตัวอักษรละตินเท่านั้น) แต่เป็นหนึ่งในนั้น หลักนี่คือจุดเริ่มต้นของการทำงานของโปรแกรม ฟังก์ชันหลักดังกล่าวมักจะเรียกฟังก์ชันอื่นๆ ที่อยู่ในไฟล์เดียวกันกับโปรแกรมหลักหรือดึงมาจากไลบรารีของฟังก์ชันที่ได้รับการฝึกอบรมล่วงหน้า หลักไม่มีข้อโต้แย้ง ดังนั้นรายการจึงมีลักษณะดังนี้: () - วงเล็บ { } วางกรอบตัวดำเนินการที่ใช้อัลกอริทึมนั้นเอง วงเล็บเหล่านี้คล้ายกับ BEGIN - END ในภาษา Pascal
เส้น อินท์ ก,บี,ซี;ประกาศ ก,ข,คตัวแปรประเภทจำนวนเต็ม จะต้องประกาศตัวแปรทั้งหมดที่ใช้ในโปรแกรม ถัดมาเป็นผู้ประกอบการที่ได้รับมอบหมายให้ กความหมาย 5 และเพื่อ ข - 7 , กับ- มูลค่าของผลรวมของพวกเขา ค่านิยม ตัวแปรประเภท ภายในอยู่ในช่วง [-32768; 32767]. การทำงาน พิมพ์ฉแสดง: ผลรวม = 12.

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

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

โปรแกรมก่อนหน้านี้มีข้อเสียเปรียบประการหนึ่ง: โปรแกรมสำหรับการคำนวณผลรวมเหมาะสำหรับกรณีใดกรณีหนึ่งเท่านั้น ก=5, ข=7- มาปรับปรุงด้วยการแทนที่ตัวดำเนินการกำหนดที่สอดคล้องกันด้วยการเรียกใช้ฟังก์ชัน สแกน(ตัวอย่าง 1.2) :

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

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

1 บทนำ

เอกสารนี้มีแนวทางในการเขียนโปรแกรมด้วยภาษา C++

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

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

1.1 รูปแบบเอกสาร

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

2. กฎสามารถถูกละเมิดได้หากมีการคัดค้านเป็นการส่วนตัว

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

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

3 แบบแผนการตั้งชื่อ

3.1 แบบแผนการตั้งชื่อทั่วไป

3. ชื่อที่แสดงถึงประเภทจะต้องเขียนด้วยตัวพิมพ์ผสมโดยขึ้นต้นด้วยตัวพิมพ์ใหญ่

ไลน์บัญชีออมทรัพย์

4. ชื่อตัวแปรต้องเขียนด้วยตัวพิมพ์ผสมโดยเริ่มจากตัวพิมพ์เล็ก

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

5. ค่าคงที่ที่มีชื่อ (รวมถึงค่าการแจกแจง) จะต้องเขียนด้วยตัวพิมพ์ใหญ่โดยมีขีดล่างเป็นตัวคั่น

MAX_ITERATIONS, COLOR_RED, PI
แนวปฏิบัติทั่วไปในชุมชนนักพัฒนา C++ ควรใช้ค่าคงที่ดังกล่าวให้น้อยที่สุด ในกรณีส่วนใหญ่ การใช้ค่าเป็นวิธีการแก้ปัญหาที่ดีที่สุด:

Int getMaxIterations() // NOT: MAX_ITERATIONS = 25 ( return 25; )
แบบฟอร์มนี้สามารถอ่านได้มากขึ้นและรับประกันอินเทอร์เฟซเดียวกับค่าที่เก็บไว้ในคลาส

6. ชื่อวิธีการและฟังก์ชันต้องเป็นคำกริยา เขียนด้วยตัวพิมพ์ผสม และขึ้นต้นด้วยตัวพิมพ์เล็ก

GetName(), คำนวณTotalWidth()
เช่นเดียวกับกฎสำหรับตัวแปร แต่ความแตกต่างระหว่างตัวแปรนั้นอยู่ที่รูปแบบเฉพาะของตัวแปร

7. ชื่อเนมสเปซควรเขียนด้วยตัวพิมพ์เล็ก

รุ่น::analyzer, io::iomanager, ทั่วไป::math::geometry
แนวปฏิบัติทั่วไปในชุมชนนักพัฒนา C++

8. ชื่อประเภทในเทมเพลตควรตั้งชื่อด้วยตัวพิมพ์ใหญ่ตัวเดียว

แม่แบบ ...แม่แบบ ...
แนวปฏิบัติทั่วไปในชุมชนนักพัฒนา C++ ช่วยให้คุณแยกชื่อเทมเพลตจากชื่อที่ใช้อื่น ๆ

9. คำย่อและคำย่อในชื่อจะต้องเขียนด้วยตัวพิมพ์เล็ก
ส่งออกHtmlSource(); // อย่า: ExportHTMLSource(); openDvdPlayer(); // ไม่ใช่: openDVDPlayer();
การใช้ตัวพิมพ์ใหญ่อาจส่งผลให้เกิดข้อขัดแย้งในการตั้งชื่อที่อธิบายไว้ข้างต้น มิฉะนั้นตัวแปรจะมีชื่อว่า dVD, hTML ฯลฯ ซึ่งไม่สามารถอ่านได้ ปัญหาอื่นได้ถูกอธิบายไว้ข้างต้นแล้ว เมื่อชื่อเชื่อมโยงกับชื่ออื่น ความสามารถในการอ่านจะลดลง คำหลังตัวย่อไม่โดดเด่นเท่าที่ควร

10. ตัวแปรโกลบอลควรใช้กับตัวดำเนินการแก้ไขขอบเขต (::) เสมอ

::mainWindow.open(), ::applicationContext.getName()
ควรหลีกเลี่ยงการใช้ตัวแปรร่วม ควรใช้ซิงเกิลตัน

11. สมาชิกชั้นเรียนที่มีตัวแก้ไขส่วนตัว ควรกำหนดส่วนต่อท้ายขีดล่าง

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

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

เป็นโมฆะ setDepth (ความลึก int) (deep_ = ความลึก; )
ปัญหาคือมีสองตัวเลือกสำหรับขีดล่าง - เป็นส่วนต่อท้ายและเป็นคำนำหน้า ทั้งสองตัวเลือกมีการใช้กันอย่างแพร่หลาย แต่แนะนำให้ใช้ตัวเลือกแรกเนื่องจากช่วยให้อ่านได้ง่ายขึ้น ควรสังเกตว่าการกำหนดตัวแก้ไขการเข้าถึงสำหรับตัวแปรบางครั้งอาจเป็นปัญหาที่ถกเถียงกัน แม้ว่าดูเหมือนว่าแนวทางปฏิบัติที่แนะนำกำลังดึงดูดผู้นับถือและกลายเป็นเรื่องธรรมดาในหมู่มืออาชีพมากขึ้น

12. ตัวแปรที่กำหนดเองควรได้รับชื่อเดียวกันกับประเภท

โมฆะ setTopic (หัวข้อ * หัวข้อ) // NOT: โมฆะ setTopic (ค่าหัวข้อ *) // NOT: โมฆะ setTopic (หัวข้อ * aTopic) // NOT: โมฆะ setTopic (หัวข้อ * t) เป็นโมฆะเชื่อมต่อ (ฐานข้อมูล * ฐานข้อมูล) // ไม่ใช่ : เป็นโมฆะเชื่อมต่อ (ฐานข้อมูล * db) // ไม่ใช่: เป็นโมฆะเชื่อมต่อ (ฐานข้อมูล * oracleDB)
ลดความซับซ้อนโดยการลดจำนวนคำศัพท์และชื่อที่ใช้ นอกจากนี้ยังช่วยให้จดจำประเภทได้ง่ายขึ้นด้วยชื่อตัวแปร

ตัวแปรที่ไม่สามารถปรับได้สามารถตั้งชื่อตามวัตถุประสงค์และประเภท:

จุดเริ่มต้นPoint, centerPoint;

ชื่อล็อกอินชื่อ;

13. ชื่อทั้งหมดควรเขียนเป็นภาษาอังกฤษ

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

15. ชื่ออ็อบเจ็กต์ไม่ได้ระบุไว้อย่างชัดเจน คุณควรหลีกเลี่ยงการระบุชื่ออ็อบเจ็กต์ในชื่อเมธอด

(ขาดข้อ 16 - หมายเหตุผู้แปล)

3.2 กฎการตั้งชื่อพิเศษ

17. คำพูดรับ/ตั้งค่า ต้องใช้ทุกที่ที่มีการเข้าถึงแอตทริบิวต์โดยตรง

พนักงาน.getName(); Employee.setName(ชื่อ); matrix.getElement(2, 4); matrix.setElement(2, 4, ค่า);
แนวปฏิบัติทั่วไปในชุมชนนักพัฒนา C++ ใน Java แบบแผนนี้ได้กลายเป็นมาตรฐานไม่มากก็น้อย

18. คำพูดคำนวณ สามารถใช้ในวิธีการคำนวณบางอย่างได้

ชุดค่า->computeAverage(); เมทริกซ์ -> computeInverse ()
ทำให้ผู้อ่านทราบทันทีว่าการดำเนินการนี้ใช้เวลานาน

19. คำพูดหา สามารถใช้ในวิธีการที่ทำการค้นหาใด ๆ

Vertex.findNearestVertex(); matrix.findMinElement();
ให้ผู้อ่านทราบทันทีว่านี่เป็นวิธีการค้นหาแบบง่าย ๆ ที่ไม่ต้องใช้การคำนวณมากนัก

20. คำพูดเริ่มต้น สามารถใช้เมื่อมีการเตรียมใช้งานวัตถุหรือเอนทิตี

Printer.initializeFontSet();
ควรใช้ initii เวอร์ชันอเมริกัน z e แทนที่จะเป็นอักษรย่อของอังกฤษ สจ. ควรหลีกเลี่ยงตัวย่อ init

21. ตัวแปรที่เป็นตัวแทนของ GUI ควรได้รับการต่อท้ายที่สอดคล้องกับชื่อประเภทส่วนประกอบ

MainWindow, propertiesDialog, widthScale, LoginText, leftScrollbar, mainForm, fileMenu, minLabel, exitButton, yesToggle ฯลฯ
ปรับปรุงความสามารถในการอ่านเนื่องจากชื่อให้คำแนะนำโดยตรงแก่ผู้ใช้เกี่ยวกับประเภทของตัวแปรและทรัพยากรของออบเจ็กต์

22. พหูพจน์ควรใช้เพื่อแสดงชุด (คอลเลกชัน) ของวัตถุ

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

23. คำนำหน้า n ควรใช้แทนจำนวนวัตถุ

NPoints, nLines
สัญกรณ์นี้นำมาจากคณิตศาสตร์ ซึ่งเป็นแบบแผนที่กำหนดขึ้นเพื่อแสดงถึงจำนวนของวัตถุ

24. คำต่อท้ายเลขที่ ควรใช้เพื่อระบุหมายเลขเอนทิตี

เลขที่โต๊ะ เลขที่พนักงาน
สัญกรณ์นี้นำมาจากคณิตศาสตร์ ซึ่งเป็นแบบแผนที่กำหนดขึ้นเพื่อระบุจำนวนเอนทิตี

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

25. ควรตั้งชื่อตัวแปรตัววนซ้ำฉัน เจ เค ฯลฯ

สำหรับ (int i = 0; i< nTables); i++) { : } for (vector::ตัววนซ้ำ i = list.begin(); ฉัน != list.end(); i++) ( องค์ประกอบองค์ประกอบ = *i; ... )
สัญกรณ์นี้นำมาจากคณิตศาสตร์ ซึ่งเป็นแบบแผนที่กำหนดขึ้นสำหรับการระบุตัววนซ้ำ

ตัวแปรที่มีชื่อ ฉัน, เจฯลฯ ขอแนะนำให้ใช้เฉพาะในลูปที่ซ้อนกันเท่านั้น

26. คำนำหน้าเป็น ควรใช้สำหรับตัวแปรและวิธีการบูลีนเท่านั้น

IsSet, isVisible, isFound, isFound, isOpen
แนวทางปฏิบัติทั่วไปในชุมชนการพัฒนา C++ บางครั้งใช้ใน Java เช่นกัน

การใช้คำนำหน้านี้จะกำจัดชื่อเช่น สถานะหรือ ธง. เป็นสถานะหรือ isFlagไม่พอดีและโปรแกรมเมอร์ถูกบังคับให้เลือกชื่อที่มีความหมายมากกว่านี้

ในบางสถานการณ์คำนำหน้า เป็นแทนที่ด้วยอันอื่นจะดีกว่า: มี, สามารถหรือ ควร:

บูล hasLicense();

บูลสามารถประเมิน ();

บูล shouldSort();
27. ต้องใช้ชื่อสมมาตรเพื่อการดำเนินการที่เหมาะสม

รับ/ตั้งค่า, เพิ่ม/ลบ, สร้าง/ทำลาย, เริ่ม/หยุด, แทรก/ลบ, เพิ่ม/ลด, เก่า/ใหม่, เริ่มต้น/สิ้นสุด, แรก/สุดท้าย, ขึ้น/ลง, ต่ำสุด/สูงสุด, ถัดไป/ก่อนหน้า, เก่า/ ใหม่, เปิด/ปิด, แสดง/ซ่อน, ระงับ/ดำเนินการต่อ ฯลฯ

ลดความซับซ้อนด้วยความสมมาตร
28. ควรหลีกเลี่ยงการใช้คำย่อในชื่อ

คำนวณเฉลี่ย(); // ไม่ใช่: compAvg();

ลองดูคำสองประเภท คำแรกเป็นคำธรรมดาที่อยู่ในพจนานุกรมที่ไม่สามารถย่อได้ ห้ามใช้อักษรย่อ:

Cmd แทนคำสั่ง cp แทนการคัดลอก pt แทน point comp แทนการคำนวณ init แทนการเริ่มต้น ฯลฯ

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

HypertextMarkupLanguage แทน html CentralProcessingUnit แทน cpu PriceEarningRatio แทน pe เป็นต้น
29. ควรหลีกเลี่ยงการตั้งชื่อพอยน์เตอร์เพิ่มเติม

เส้น* เส้น; // ไม่แนะนำ: Line* pLine;

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

บูลมีข้อผิดพลาด; // เป็นไปไม่ได้: isNoError บูล isFound; // ไม่: isNotFound

ปัญหาเกิดขึ้นเมื่อชื่อดังกล่าวใช้ร่วมกับตัวดำเนินการปฏิเสธเชิงตรรกะ ซึ่งทำให้เกิดการปฏิเสธสองครั้ง ผลลัพธ์ไม่จำเป็นต้องเป็นลบ
!ไม่พบ 31. ค่าคงที่ในการแจกแจงสามารถมีคำนำหน้าได้ - ชื่อสามัญของประเภทเกี่ยวกับตำแหน่งของการประกาศ ค่าคงที่ที่อธิบายในการแจกแจงครั้งเดียว และแนวคิดที่ค่าคงที่เป็นตัวแทน

อีกวิธีหนึ่งคือการอ้างอิงค่าคงที่ตามประเภททั่วไป: Color::RED, Airline::AIR_FRANCE ฯลฯ

โปรดทราบว่าชื่อ enum มักจะเขียนในรูปเอกพจน์ เช่น enum Color (...) ชื่อพหูพจน์ดูดีเมื่อประกาศ แต่ใช้ไม่ได้ผลดี การใช้งานจริง.

32. คลาสข้อยกเว้นควรได้รับการต่อท้ายข้อยกเว้น .

ข้อยกเว้นการเข้าถึงคลาส ( : )
คลาสข้อยกเว้นไม่ได้เป็นส่วนหนึ่งของสถาปัตยกรรมโปรแกรมจริงๆ และการตั้งชื่อคลาสด้วยวิธีนี้จะแยกคลาสออกจากคลาสอื่น

33. ควรตั้งชื่อฟังก์ชัน (วิธีการที่ส่งคืนค่า) ขึ้นอยู่กับสิ่งที่พวกเขาส่งคืน และขั้นตอนควรตั้งชื่อตามสิ่งที่พวกเขาดำเนินการ (วิธีการเป็นโมฆะ)

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

4 ไฟล์

4.1 ไฟล์ต้นฉบับ

34. ไฟล์ส่วนหัว C++ ควรได้รับนามสกุล.ชม (ที่ต้องการ) หรือ.hp - ไฟล์ซอร์สโค้ดอาจมีนามสกุล.c++ (ที่แนะนำ).ซี , .ซีซี หรือ.ซีพีพี .

MyClass.c++, MyClass.h
ส่วนขยายเหล่านี้เป็นส่วนขยายที่ได้รับอนุมัติโดยมาตรฐาน C++

35. คลาสควรได้รับการประกาศในไฟล์ส่วนหัวและกำหนด (นำไปใช้) ในไฟล์ซอร์สโค้ด ชื่อไฟล์จะเหมือนกับชื่อคลาส

MyClass.h, MyClass.c++

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

36. คำจำกัดความทั้งหมดจะต้องอยู่ในไฟล์ซอร์สโค้ด

คลาส MyClass ( สาธารณะ: int getValue () (คืนค่า _;) // ไม่! ... ส่วนตัว: int value_; )
ไฟล์ส่วนหัวประกาศอินเทอร์เฟซ ไฟล์ซอร์สโค้ดนำไปใช้ หากโปรแกรมเมอร์จำเป็นต้องค้นหาการใช้งาน เขาต้องแน่ใจว่าเขาจะพบมันในไฟล์ซอร์สโค้ด

37. เนื้อหาไฟล์ไม่ควรเกิน 80 คอลัมน์

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

38. ไม่สามารถใช้งานได้ อักขระพิเศษ(เช่น TAB) และตัวแบ่งหน้า

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

39. ความไม่สมบูรณ์ของเส้นขาดควรชัดเจน

ผลรวมทั้งหมด = a + b + c + d + e; ฟังก์ชั่น (param1, param2, param3); setText("แยกบรรทัดยาว" "ออกเป็นสองส่วน"); สำหรับ (int tableNo = 0; tableNo< nTables; tableNo += tableStep) { ... }
ตัวแบ่งแถวจะปรากฏขึ้นเมื่อมีการละเมิดขีดจำกัด 80 คอลัมน์ที่อธิบายไว้ข้างต้น เป็นการยากที่จะให้กฎเกณฑ์ที่ยากและรวดเร็วในการแจกแจงรายละเอียด แต่ตัวอย่างข้างต้นแสดงให้เห็นหลักการทั่วไป

โดยทั่วไป:

• ตัวแบ่งทศนิยม
• หยุดพักหลังจากผู้ปฏิบัติงาน;
• การปรับระดับ บรรทัดใหม่โดยมีจุดเริ่มต้นของนิพจน์ในบรรทัดก่อนหน้า

4.2 การรวมไฟล์

40. ไฟล์ส่วนหัวจะต้องมีการป้องกันการซ้อน

#ifndef COM_COMPANY_MODULE_CLASSNAME_H #กำหนด COM_COMPANY_MODULE_CLASSNAME_H: #endif // COM_COMPANY_MODULE_CLASSNAME_H
การออกแบบช่วยให้คุณหลีกเลี่ยงข้อผิดพลาดในการคอมไพล์ แบบแผนนี้ช่วยให้คุณเห็นตำแหน่งของไฟล์ในโครงสร้างโปรเจ็กต์และป้องกันความขัดแย้งของชื่อ

41. คำสั่งการรวมควรได้รับการจัดเรียง (โดยสถานที่ในลำดับชั้นของระบบ ระดับล่าง - ตำแหน่งที่สูงกว่า) และจัดกลุ่ม เว้นบรรทัดว่างระหว่างกลุ่ม

#รวม #รวม #รวม #รวม #รวม "com/company/ui/PropertiesDialog.h" #รวม "com/company/ui/MainWindow.h"
เส้นทางการรวมไม่จำเป็นต้องเป็นแบบสัมบูรณ์ ควรใช้คำสั่งคอมไพเลอร์แทน

42. ควรวางคำสั่งรวมไว้ที่จุดเริ่มต้นของไฟล์เท่านั้น

การปฏิบัติทั่วไป หลีกเลี่ยงผลข้างเคียงที่ไม่พึงประสงค์ซึ่งการ "ซ่อน" รวมไว้ตรงกลางไฟล์ซอร์สโค้ดอาจทำให้เกิดได้

5 สำนวน

5.1 ประเภท

43. ประเภทท้องถิ่นที่ใช้ในไฟล์เดียวจะต้องประกาศในไฟล์นั้นเท่านั้น

ปรับปรุงการซ่อนข้อมูล

44. ส่วนชั้นเรียนสาธารณะ , ได้รับการคุ้มครอง และส่วนตัว จะต้องเรียงลำดับ ต้องระบุทุกส่วนอย่างชัดเจน

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

45. การหล่อประเภทต้องชัดเจน อย่าพึ่งพาการคัดเลือกประเภทโดยนัย

FloatValue = static_cast (intValue); // ไม่: floatValue = intValue;
จากสิ่งนี้ โปรแกรมเมอร์แสดงให้เห็นว่าเขาตระหนักถึงความแตกต่างในประเภทต่างๆ และความสับสนนั้นเกิดขึ้นโดยเจตนา

5.2 ตัวแปร

46. ​​​​ตัวแปรควรเริ่มต้น ณ ตำแหน่งที่ประกาศไว้

เพื่อให้แน่ใจว่าตัวแปรจะสามารถใช้งานได้ตลอดเวลา แต่บางครั้งก็ทำไม่ได้:

int x, y, z;
ในกรณีเหล่านี้ จะเป็นการดีกว่าถ้าปล่อยตัวแปรไว้โดยไม่กำหนดค่าเริ่มต้น แทนที่จะกำหนดค่าใดๆ ให้กับตัวแปรเหล่านั้น

47. ตัวแปรไม่ควรมีความหมายซ้ำซ้อน

ปรับปรุงความสามารถในการอ่านโดยให้แน่ใจว่าแนวคิดทั้งหมดที่นำเสนอมีความสอดคล้องกัน ลดโอกาสที่จะเกิดข้อผิดพลาดอันเนื่องมาจากผลข้างเคียง

48. ควรหลีกเลี่ยงการใช้ตัวแปรร่วม

ไม่มีเหตุผลที่จะใช้ตัวแปรทั่วโลกใน C ++ (อันที่จริงก็มี - หมายเหตุผู้แปล) เช่นเดียวกับฟังก์ชันโกลบอลและตัวแปร (คงที่) ที่มีขอบเขตเป็นไฟล์ทั้งหมด

49. คุณไม่ควรประกาศตัวแปรคลาสเป็นสาธารณะ .

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

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

(ขาดข้อ 50 - หมายเหตุผู้แปล)

ลอย* x; // ไม่แนะนำ: float *x; อินท์&วาย; // ไม่แนะนำ: int
ตัวแปรที่เป็นตัวชี้หรือการอ้างอิงอ้างอิงถึงประเภทของตัวแปรมากกว่าชื่อ โปรแกรมเมอร์ภาษา C มักจะใช้แนวทางที่แตกต่างออกไป แต่ใน C++ จะดีกว่าหากปฏิบัติตามคำแนะนำนี้

(ขาดข้อ 52 - หมายเหตุผู้แปล)

53. ควรหลีกเลี่ยงการเปรียบเทียบตัวแปรบูลีน (ลอจิคัล) และพอยน์เตอร์กับศูนย์โดยปริยาย

ถ้า (nLines != 0) // ไม่แนะนำ: if (nLines) if (value != 0.0) // ไม่แนะนำ: if (value)
มาตรฐาน C++ ไม่รับประกันว่าค่าของตัวแปร int และ float เท่ากับศูนย์จะแสดงเป็นไบนารี 0 นอกจากนี้ ด้วยการเปรียบเทียบที่ชัดเจน ประเภทที่จะเปรียบเทียบก็สามารถมองเห็นได้

มันจะสมเหตุสมผลที่จะถือว่าพอยน์เตอร์ไม่ควรเปรียบเทียบโดยปริยายกับศูนย์ เช่น if (line == 0) แทนที่จะเป็น if (line) อย่างหลังเป็นวิธีปฏิบัติทั่วไปใน C/C++ ดังนั้นจึงสามารถใช้ได้เช่นกัน

54. ควรประกาศตัวแปรในขอบเขตที่เล็กที่สุดเท่าที่จะเป็นไปได้

ทำให้ง่ายต่อการควบคุมผลกระทบของตัวแปรและผลข้างเคียง

5.3 รอบ

55. คุณไม่สามารถรวมนิพจน์ในโครงสร้าง for() ที่ไม่เกี่ยวข้องกับการควบคุมลูป

ผลรวม = 0; // ไม่: สำหรับ (i = 0, ผลรวม = 0; i< 100; i++) for (i = 0; i < 100; i++) sum += value[i]; sum += value[i];
ปรับปรุงการสนับสนุนและความสามารถในการอ่าน ควบคุมวงจรโดยแยกจากวงจรที่มีอยู่อย่างเคร่งครัด

56. ตัวแปรที่เกี่ยวข้องกับลูปควรเริ่มต้นทันทีก่อนหน้านั้น

57. สามารถหลีกเลี่ยงการวนซ้ำ Do- While ได้

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

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

โครงสร้างที่ใช้น้อยลงช่วยให้อ่านง่ายขึ้น

58.หลีกเลี่ยงการใช้หยุดพัก และดำเนินการต่อ ในรอบ

ควรใช้สำนวนดังกล่าวเมื่อช่วยให้อ่านง่ายขึ้นเท่านั้น

(ขาดข้อ 59 - หมายเหตุผู้แปล)

60. สำหรับ วนซ้ำไม่รู้จบควรใช้แบบฟอร์มในขณะที่ (จริง) .

ในขณะที่ (จริง) ( ​​: ) สำหรับ (;;) ( // NO! : ) ในขณะที่ (1) ( // NO! : )
การทดสอบอย่างใดอย่างหนึ่งนั้นไม่จำเป็นและไม่มีความหมาย แบบฟอร์ม for (;;) ไม่สามารถอ่านได้มากนัก ยังไม่ชัดเจนว่าการวนซ้ำนั้นไม่มีที่สิ้นสุด

5.4 นิพจน์แบบมีเงื่อนไข

61. หลีกเลี่ยงบทกลอนที่ซับซ้อนอย่างเคร่งครัด ให้ป้อนตัวแปรบูลีนแทน

บูล isFinished = (องค์ประกอบหมายเลข< 0) || (elementNo >องค์ประกอบสูงสุด); บูล isRepeatedEntry = elementNo == LastElement; ถ้า (isFinished || isRepeatedEntry) ( : ) // NOT: if ((elementNo< 0) || (elementNo >องค์ประกอบสูงสุด)||
elementNo == องค์ประกอบสุดท้าย) ( : )

การตั้งค่าตัวแปรบูลีนสำหรับนิพจน์จะทำให้โปรแกรมจัดทำเอกสารด้วยตนเอง การออกแบบจะง่ายต่อการอ่าน ดีบัก และบำรุงรักษา 62. ส่วนที่คาดหวังควรอยู่ในส่วนนั้น ถ้าข้อยกเว้น - บางส่วน .

อื่น
บูล isOk = readFile (ชื่อไฟล์); ถ้า (isOk) ( : ) อื่น ๆ ( : )

ซึ่งช่วยให้แน่ใจว่าข้อยกเว้นไม่ทำให้การดำเนินการปกติสับสน สำคัญสำหรับการอ่านและประสิทธิภาพ

63. เงื่อนไขควรแยกบรรทัด.

64. ควรหลีกเลี่ยงการแสดงออกในข้อกำหนดและเงื่อนไขโดยเคร่งครัด
ไฟล์* fileHandle = open(ชื่อไฟล์, "w"); if (!fileHandle) ( : ) // NOT: if (!(fileHandle = open(fileName, "w"))) ( : )

นิพจน์ที่ดำเนินการได้ในเงื่อนไขทำให้การอ่านยากขึ้น โดยเฉพาะอย่างยิ่งสำหรับผู้เริ่มต้นใช้ C/C++

5.5 เบ็ดเตล็ด

65. ควรหลีกเลี่ยงตัวเลข “Magic” ในโค้ด ควรประกาศตัวเลขอื่นที่ไม่ใช่ 0 หรือ 1 เป็นค่าคงที่ที่มีชื่อ

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

ผลรวมสองเท่า = 0.0; // ไม่แนะนำ: ผลรวมสองเท่า = 0; ความเร็วสองเท่า = 3.0e8; // ไม่แนะนำ: ความเร็วสองเท่า = 3e8; ผลรวมสองเท่า; : ผลรวม = (ก + ข) * 10.0;
สิ่งนี้เน้นย้ำแนวทางต่างๆ เมื่อทำงานกับจำนวนเต็มและตัวเลขทศนิยม จากมุมมองทางคณิตศาสตร์ ทั้งสองโมเดลนี้แตกต่างอย่างสิ้นเชิงและเข้ากันไม่ได้

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

67. ค่าคงที่จุดลอยตัวควรเขียนด้วยตัวเลขอย่างน้อยหนึ่งหลักก่อนจุดทศนิยมเสมอ

ระบบตัวเลขและสำนวน C++ มาจากคณิตศาสตร์ และคุณควรยึดถือสัญกรณ์แบบดั้งเดิมทุกครั้งที่เป็นไปได้ เหนือสิ่งอื่นใด 0.5 สามารถอ่านได้มากกว่า .5 (ตัวเลือกแรกต้องไม่สับสนกับหมายเลข 5)

68. ฟังก์ชั่นจะต้องระบุประเภทค่าตอบแทน

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

69. ไม่ควรใช้ข้ามไป .

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

70. ควรใช้ "0" แทน "NULL"

NULL เป็นส่วนหนึ่งของไลบรารีมาตรฐาน C และเลิกใช้แล้วในภาษา C++

6 การออกแบบและความคิดเห็น

6.1 การออกแบบ

71. การเยื้องหลักควรเป็นช่องว่างสองช่อง

สำหรับ (i = 0; i< nElements; i++) a[i] = 0;
การเยื้องช่องว่างหนึ่งช่องมีขนาดเล็กพอที่จะสะท้อนถึงโครงสร้างลอจิคัลของโค้ด การเว้นวรรคมากกว่า 4 ช่องทำให้โค้ดที่ซ้อนกันลึกไม่สามารถอ่านได้ และเพิ่มโอกาสที่บรรทัดจะต้องขาด ตัวเลือกที่มีช่องว่าง 2, 3 หรือ 4 เป็นที่แพร่หลาย และ 2 และ 4 - กว้างขึ้น

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

ในขณะที่ (!เสร็จสิ้น) ( doSomething(); เสร็จสิ้น = moreToDo(); )

ในขณะที่ (!เสร็จสิ้น) ( doSomething(); เสร็จสิ้น = moreToDo(); )

ในขณะที่ (!เสร็จสิ้น) ( doSomething(); เสร็จสิ้น = moreToDo(); )
ตัวอย่างที่ 3 ใช้ช่องว่างภายในเพิ่มเติม ซึ่งทำให้จอแสดงผลไม่ชัดเจน โครงสร้างเชิงตรรกะรหัส.

73. การประกาศชั้นเรียน

คลาส SomeClass: BaseClass สาธารณะ ( สาธารณะ: ... ป้องกัน: ... ส่วนตัว: ... )
ผลที่ตามมาโดยเฉพาะของกฎที่ระบุไว้ข้างต้น

74. คำจำกัดความของวิธีการควรอยู่ในรูปแบบดังนี้:

โมฆะ someMethod() ( ... )

75. การก่อสร้างถ้า-อย่างอื่น ควรจัดรูปแบบดังนี้:

If (เงื่อนไข) ( ประโยค; ) if (เงื่อนไข) ( ประโยค; ) else ( ประโยค; ) if (เงื่อนไข) ( ประโยค; ) else if (เงื่อนไข) ( ประโยค; ) else ( ประโยค; )
ข้อพิสูจน์ของกฎที่ระบุไว้ข้างต้น อีกทั้งการเขียน อื่นในบรรทัดเดียวกับวงเล็บปีกกาปิดของบล็อกแรกไม่ผิดกฎหมาย:

ถ้า (เงื่อนไข) ( คำสั่ง; ) อื่น ๆ ( คำสั่ง; )
แยกส่วน if-else แต่ละส่วนออกจากบรรทัดจะดีกว่า ทำให้ง่ายต่อการจัดการโค้ด เช่น การย้ายบล็อก อื่น.

76. วงจรสำหรับ ควรจัดรูปแบบดังนี้:

สำหรับ (การเริ่มต้น; เงื่อนไข; อัปเดต) ( คำสั่ง; )
ข้อพิสูจน์ของกฎที่ระบุไว้ข้างต้น

77. วงจรสำหรับ โดยมีเนื้อความว่างควรจัดรูปแบบดังนี้

สำหรับ (การเริ่มต้น; เงื่อนไข; อัปเดต) ;
เน้นย้ำให้ผู้อ่านเห็นว่าร่างกายว่างเปล่า อย่างไรก็ตาม ควรหลีกเลี่ยงวงจรที่ไม่มีร่างกาย

78. วงจรในขณะที่ ควรจัดรูปแบบดังนี้:

ในขณะที่ (เงื่อนไข) ( คำสั่ง; )
ข้อพิสูจน์ของกฎที่ระบุไว้ข้างต้น

79. วงจรทำในขณะที่ ควรจัดรูปแบบดังนี้:

ทำ ( คำสั่ง; ) ในขณะที่ (เงื่อนไข);
ข้อพิสูจน์ของกฎที่ระบุไว้ข้างต้น

80. การก่อสร้างสวิตช์ ควรจัดรูปแบบดังนี้:

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

81. การก่อสร้างลองจับ ควรจัดรูปแบบดังนี้:

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

82.หากออกแบบถ้า-อย่างอื่น มีเพียงนิพจน์เดียวในร่างกาย สามารถละเว้นเครื่องหมายปีกกาได้

ถ้า (เงื่อนไข) คำสั่ง; ในขณะที่ (เงื่อนไข) คำสั่ง; สำหรับ (การเริ่มต้น; เงื่อนไข; อัปเดต) คำสั่ง;
ขอแนะนำไม่ให้ละเว้นเครื่องหมายปีกกา

83. ประเภทการส่งคืนของฟังก์ชันสามารถอยู่เหนือชื่อของฟังก์ชันได้

เป็นโมฆะ MyClass::myMethod(เป็นโมฆะ) ( : )
วิธีนี้ทำให้ฟังก์ชันต่างๆ ถูกจัดเรียงไว้ในคอลัมน์เดียว

6.2 ช่องว่าง

84.

ตัวดำเนินการควรคั่นด้วยช่องว่าง
- หลังจากจองแล้ว คำหลักใน C ++ คุณควรใช้ช่องว่าง
- ควรเว้นวรรคหลังเครื่องหมายจุลภาค
- เครื่องหมายทวิภาคควรคั่นด้วยช่องว่าง
- หลังอัฒภาคในวงวน สำหรับควรรวมช่องว่างด้วย

ก = (ข + ค) * ง; // ไม่แนะนำ: a=(b+c)*d while (true) // ไม่แนะนำ: while(true) ( ​​​​... doSomething(a, b, c, d); // ไม่แนะนำ: doSomething (a ,b,c,d); กรณีที่ 100: // ไม่แนะนำ: กรณีที่ 100: สำหรับ (i = 0; i< 10; i++) { // НЕ РЕКОМЕНДУЕТСЯ: for(i=0;i<10;i++){ ...
เน้นสำนวนแต่ละส่วน ปรับปรุงความสามารถในการอ่าน เป็นการยากที่จะให้คำแนะนำที่ครอบคลุมเกี่ยวกับช่องว่างใน C ++ คำแนะนำข้างต้นควรแสดงหลักการทั่วไป

85. ชื่อเมธอดอาจตามด้วยการเว้นวรรคหากชื่ออื่นตามหลัง

ทำอะไรบางอย่าง (ไฟล์ปัจจุบัน);
ไฮไลท์ชื่อบุคคล ปรับปรุงความสามารถในการอ่าน หากไม่มีชื่อเพิ่มเติม สามารถละเว้นช่องว่างได้ (doSomething())

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

86. บล็อกลอจิคัลในโค้ดควรคั่นด้วยบรรทัดว่าง

Matrix4x4 matrix = ใหม่ Matrix4x4(); cosAngle สองเท่า = Math.cos (มุม); sinAngle สองเท่า = Math.sin (มุม); matrix.setElement(1, 1, cosAngle); matrix.setElement(1, 2, sinAngle); matrix.setElement(2, 1, -sinAngle); matrix.setElement(2, 2, cosAngle); คูณ(เมทริกซ์);
ปรับปรุงความสามารถในการอ่าน

สิ่งนี้ทำให้พวกเขาโดดเด่นยิ่งขึ้น

88. ตัวแปรในการประกาศสามารถจัดตำแหน่งได้

ไฟล์ AsciiFile*; int nPoints; ลอย x, y;
ปรับปรุงความสามารถในการอ่าน คู่รักจะมองเห็นได้ชัดเจนยิ่งขึ้น ประเภท - ตัวแปร.

89. ใช้การจัดตำแหน่งทุกที่ที่ช่วยให้อ่านง่ายขึ้น

ถ้า (a == lowValue) คำนวณบางสิ่ง (); อื่นถ้า (a == mediumValue) คำนวณSomethingElse(); อย่างอื่นถ้า (a == highValue) คำนวณSomethingElseYet(); ค่า = (ศักยภาพ * ความหนาแน่นของน้ำมัน) / ค่าคงที่ 1 + (ความลึก * ความหนาแน่นของน้ำ) / ค่าคงที่ 2 + (zCoordinateValue * ความหนาแน่นของก๊าซ) / ค่าคงที่ 3; minPosition = ระยะทางคำนวณ (ต่ำสุด, x, y, z); AveragePosition = ระยะทางคำนวณ (เฉลี่ย, x, y, z); สวิตช์ (ค่า) ( ​​กรณี PHASE_OIL: strcpy (เฟส, "น้ำมัน"); แตก; กรณี PHASE_WATER: strcpy (เฟส, "น้ำ"); แตก; กรณี PHASE_GAS: strcpy (เฟส, "แก๊ส"); แตก; )
มีหลายกรณีที่โค้ดสามารถจัดวางเพิ่มเติมได้ แม้ว่าจะละเมิดกฎที่กำหนดไว้ก่อนหน้านี้ก็ตาม

6.3 ความคิดเห็น

90. ไม่ควรแสดงความคิดเห็นโค้ดที่ซับซ้อนที่เขียนโดยใช้การเคลื่อนไหวที่ยุ่งยาก แต่เขียนใหม่!

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

91. ความคิดเห็นทั้งหมดควรเขียนเป็นภาษาอังกฤษ

ในสภาพแวดล้อมระหว่างประเทศ ภาษาอังกฤษเป็นภาษาที่ต้องการ

92. การใช้งาน//สำหรับความคิดเห็นทั้งหมด รวมถึงความคิดเห็นแบบหลายบรรทัดด้วย
// ความคิดเห็นที่ครอบคลุม // หลายบรรทัด
หากคุณทำตามคำแนะนำนี้ แสดงความคิดเห็นหลายบรรทัด /* */ สามารถใช้สำหรับการดีบักและวัตถุประสงค์อื่น ๆ

หลังจาก // คุณควรเว้นวรรค และความคิดเห็นควรขึ้นต้นด้วยตัวพิมพ์ใหญ่และลงท้ายด้วยจุด

93. ควรจัดเรียงความคิดเห็นให้เกี่ยวข้องกับสิ่งที่พวกเขากำลังอธิบาย

94. ความคิดเห็นเกี่ยวกับคลาสและส่วนหัวของเมธอดควรเป็นไปตามระเบียบการ JavaDoc

โปรแกรมเมอร์ Java ใช้วิธีการขั้นสูงในการจัดทำเอกสารด้วยเครื่องมืออัตโนมัติ Javadoc มาตรฐาน ซึ่งเป็นส่วนหนึ่งของชุดพัฒนา และช่วยให้คุณสร้างเอกสาร HTML โดยอัตโนมัติจากความคิดเห็นในโค้ดของคุณ

เครื่องมือที่คล้ายกันมีอยู่ใน C ++ เป็นไปตามรูปแบบไวยากรณ์ของแท็กเดียวกันกับ JavaDoc (ดูตัวอย่าง Doc++ หรือ Doxygen)

7 ลิงค์

• รหัสเสร็จสมบูรณ์ Steve McConnell - Microsoft Press
• การเขียนโปรแกรมด้วย C++, กฎและข้อแนะนำ, M Henricson, e. Nyquist, Ellemtel (โทรคมนาคมของสวีเดน):