สารบัญ
- C++ คืออะไร?
- ทำไมต้องใช้ C++
- คุณสมบัติ
- การตั้งค่าสภาพแวดล้อมท้องถิ่น
- อินพุต/เอาต์พุตพื้นฐาน C++
- กระแสไฟขาออกมาตรฐาน (cout)
- สตรีมอินพุตมาตรฐาน (cin)
- เส้นสิ้นสุดมาตรฐาน (endl)
- ตัวแปร C++
- ตัวระบุ C++
- ประเภทข้อมูล C++
- ค่าคงที่ C++/ตัวอักษร
- คลาสสตอเรจ C++
- ประเภทตัวดัดแปลง C++
- ตัวดำเนินการใน C++
- C++ ลูป
- คำชี้แจงการตัดสินใจ
- ฟังก์ชัน C++
- เบอร์ C++
- อาร์เรย์ C++
- สตริง C++
- ตัวชี้ C++
- การอ้างอิง C++
- C++ วันที่และเวลา
- โครงสร้างข้อมูล C++
- C++ คลาสและวัตถุ
- มรดก C++
- ตัวแก้ไขการเข้าถึง C++
- C++ โอเวอร์โหลด
- C++ Polymorphism
- นามธรรมข้อมูล C++
- การห่อหุ้มข้อมูล C++
- คลาสนามธรรม C++
- การจัดการข้อยกเว้น C++
- หน่วยความจำไดนามิก C++
- เทมเพลต C++
- ตัวประมวลผลล่วงหน้า C++
- การจัดการสัญญาณ C++
- การเขียนโปรแกรมเว็บ C++
- บทสรุป
- บทความแนะนำ
C++ คืออะไร?
C++ เป็นภาษาข้ามแพลตฟอร์มที่ใช้สร้างแอปพลิเคชันประสิทธิภาพสูง Bjarne Stroustrup พัฒนาเป็นส่วนขยายของภาษา C C ++ ช่วยให้โปรแกรมเมอร์สามารถควบคุมทรัพยากรระบบและหน่วยความจำได้ ภาษาได้รับการอัปเดตสามครั้งที่สำคัญในปี 2011, 2014 และ 2017 เป็น C++11, C++14 และ C++17
ทำไมต้องใช้ C++
- C ++ เป็นหนึ่งในภาษาที่ได้รับความนิยมมากที่สุดสำหรับการเขียนโปรแกรม
- สามารถพบได้ในระบบปฏิบัติการ, GUI และระบบฝังตัว
- เป็นภาษาการเขียนโปรแกรมเชิงวัตถุที่ให้โครงสร้างที่ชัดเจนแก่โปรแกรมและอนุญาตให้ใช้รหัสซ้ำได้ ลดต้นทุนการพัฒนา
- เป็นแบบพกพาและสามารถใช้ในการพัฒนาแอปพลิเคชันที่สามารถปรับให้เข้ากับหลายแพลตฟอร์มได้
- เนื่องจาก C++ อยู่ใกล้กับ C# และ Java ทำให้โปรแกรมเมอร์เปลี่ยนไปใช้ C++ หรือในทางกลับกันได้ง่าย
คุณสมบัติ
- มันต้องมีส่วนหัว
- ใช้เนมสเปซ std; เพื่อเตือนคอมไพเลอร์ให้ใช้เนมสเปซ std
- line int main() เป็นคุณสมบัติหลักที่เริ่มการทำงานของโปรแกรม
- บรรทัดถัดไปตัดไปที่<< Hello World; the word Hello World is reflected on the keyboard.
- บรรทัดถัดไปคืนค่า 0; ฟังก์ชั่น main() สิ้นสุดลง
- int ก;
- int _ab;
- int a30;
- อินท์ 4;
- intxy;
- int สองเท่า;
- ค่าของ true แทนค่า true
- ค่าเท็จแทนค่าเท็จ
- ลงนาม
- ไม่ได้ลงนาม
- ยาว
- สั้น
- ตัวดำเนินการเลขคณิต
- ตัวดำเนินการเชิงตรรกะ
- ตัวดำเนินการ Bitwise
- ผู้ปฏิบัติงานที่ได้รับมอบหมาย
- ผู้ประกอบการสัมพันธ์
- ผู้ประกอบการเบ็ดเตล็ด
- ถ้าคำสั่ง
- ถ้า..ข้อความอื่น
- ซ้อนกันถ้างบ
- if-else-if บันได
- คำสั่งข้าม:
- หยุดพัก
- ดำเนินต่อ
- ไปที่
- กลับ
- int – ประเภทขององค์ประกอบที่จะจัดเก็บ
- y – ชื่อของอาร์เรย์
- 4 – ขนาดของอาร์เรย์
- สตริงที่เป็นวัตถุของคลาสสตริง
- C-strings
- ขั้นแรก กำหนดตัวแปรพอยน์เตอร์
- ตอนนี้กำหนดที่อยู่ของตัวแปรให้กับตัวชี้โดยใช้ (&) ซึ่งส่งคืนที่อยู่ของตัวแปรนั้น
- การเข้าถึงค่าที่เก็บไว้ในที่อยู่โดยใช้ (*) ซึ่งส่งกลับค่าของตัวแปรที่อยู่ตามที่อยู่ที่ระบุโดยตัวถูกดำเนินการ
- ใน มรดกหลายทาง คลาสที่ได้รับถูกสร้างขึ้นจากคลาสที่ได้รับอื่นและคลาสพื้นฐานเดียวกันกับคลาสที่ได้รับอื่น มรดกนี้ไม่ได้รับการสนับสนุนโดย สุทธิ ภาษาเช่น C#, F# เป็นต้น
- สาธารณะ
- ส่วนตัว
- มีการป้องกัน
- สมาชิกที่ประกาศเป็นสาธารณะในชั้นเรียนอาจเข้าถึงได้จากทุกที่ในโปรแกรม
- สมาชิกที่ประกาศเป็นส่วนตัวในชั้นเรียนสามารถเข้าถึงได้จากภายในชั้นเรียนเท่านั้น ไม่อนุญาตให้เข้าถึงจากส่วนใดส่วนหนึ่งของรหัสนอกชั้นเรียน
- ทำให้สมาชิกข้อมูลทั้งหมดเป็นแบบส่วนตัว
- สร้างฟังก์ชัน setter และ getter สาธารณะสำหรับสมาชิกข้อมูลแต่ละคนในลักษณะที่ฟังก์ชัน set ตั้งค่าของสมาชิกข้อมูล และฟังก์ชัน get รับค่าของสมาชิกข้อมูล
- การสร้างไดนามิกสเปซในหน่วยความจำ
- การจัดเก็บที่อยู่ในตัวชี้
- เทมเพลตฟังก์ชัน
- เทมเพลตคลาส
- มาโคร
- การรวมไฟล์
- การรวบรวมแบบมีเงื่อนไข
- คำสั่งอื่นๆ
การตั้งค่าสภาพแวดล้อมท้องถิ่น
คงจะดีถ้าคุณมีซอฟต์แวร์ต่อไปนี้ในคอมพิวเตอร์ของคุณ
เป็นคอมไพเลอร์ C++ จริง ๆ ซึ่งจะใช้เพื่อคอมไพล์ซอร์สโค้ดของคุณลงในโปรแกรมปฏิบัติการขั้นสุดท้าย คอมไพเลอร์ C++ ส่วนใหญ่ไม่สนใจว่าคุณให้ส่วนขยายใดกับซอร์สโค้ดของคุณ คอมไพเลอร์ที่ใช้บ่อยที่สุดคือคอมไพเลอร์ GNU C/C++
มันถูกใช้โดยซอฟต์แวร์ในการพิมพ์ ตัวอย่าง ได้แก่ คำสั่ง Windows Notepad, OS Edit, Short, Epsilon, EMACS และ Vim หรือ VI ไฟล์ที่คุณสร้างด้วยโปรแกรมแก้ไขจะเรียกว่าไฟล์ต้นทาง และไฟล์ C++ จะเรียกว่า .cpp, .cp หรือ .c ในการเริ่มต้นการเขียนโปรแกรม C++ คุณต้องมีโปรแกรมแก้ไขข้อความ
ให้เราดูความหมายของคลาส วัตถุ เมธอด และตัวแปรอินสแตนซ์
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|มาดูส่วนต่าง ๆ ของโปรแกรมที่กล่าวถึงข้างต้นกัน −
อินพุต/เอาต์พุตพื้นฐาน C++
การดำเนินการ C++ I/O กำลังใช้แนวคิดสตรีม กระแสคือลำดับของไบต์หรือการไหลของข้อมูล ทำให้การแสดงเป็นไปอย่างรวดเร็ว
หากไบต์ไหลจากหน่วยความจำหลักไปยังอุปกรณ์ เช่น เครื่องพิมพ์ หน้าจอแสดงผล หรือการเชื่อมต่อเครือข่าย ฯลฯ สิ่งนี้เรียกว่า การดำเนินงานเอาท์พุท
หากไบต์ไหลจากอุปกรณ์ เช่น เครื่องพิมพ์ หน้าจอแสดงผล การเชื่อมต่อเครือข่าย ฯลฯ ไปยังหน่วยความจำหลัก จะเรียกว่า การดำเนินการอินพุต
กระแสไฟขาออกมาตรฐาน (cout)
ดิ ค่าใช้จ่าย เป็นวัตถุที่กำหนดไว้ล่วงหน้าของ กระแสน้ำ ระดับ. มันเชื่อมต่อกับอุปกรณ์ส่งออกซึ่งมักจะเป็นหน้าจอแสดงผล ใช้ cout เพื่อเข้าร่วมกับตัวดำเนินการแทรกสตรีมเพื่อแสดงเอาต์พุตบนคอนโซล
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|สตรีมอินพุตมาตรฐาน (cin)
ดิ จิน เป็นวัตถุที่กำหนดไว้ล่วงหน้า มีการเชื่อมต่อกับอุปกรณ์ป้อนข้อมูล ซึ่งมักจะเป็นแป้นพิมพ์ cin ใช้เพื่อเข้าร่วมโอเปอเรเตอร์การแยกสตรีม (>>) เพื่ออ่านอินพุตคอนโซล
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|เส้นสิ้นสุดมาตรฐาน (endl)
ดิ endl เป็นวัตถุที่กำหนดไว้ล่วงหน้าของคลาส ใช้เพื่อแทรกอักขระขึ้นบรรทัดใหม่และล้างสตรีม
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|ตัวแปร C++
ตัวแปรคือชื่อของตำแหน่งหน่วยความจำ ใช้สำหรับเก็บข้อมูล ค่าสามารถเปลี่ยนแปลงได้และนำกลับมาใช้ใหม่ได้หลายครั้ง เป็นวิธีการแสดงตำแหน่งหน่วยความจำผ่านสัญลักษณ์เพื่อให้ระบุได้ง่าย ตัวแปรสามารถมีตัวอักษร ขีดล่าง และตัวเลขได้ ชื่อตัวแปรขึ้นต้นด้วยตัวอักษรและขีดล่างเท่านั้น ไม่สามารถเริ่มต้นด้วยตัวเลขได้
ไม่อนุญาตให้มีช่องว่างสีขาวภายในชื่อตัวแปร
ชื่อตัวแปรต้องไม่ใช่คำหรือคีย์เวิร์ดที่สงวนไว้ เช่น char, float เป็นต้น
ชื่อตัวแปรที่ถูกต้อง:
ชื่อตัวแปรไม่ถูกต้อง:
ตัวระบุ C++
ตัวระบุ C++ ใช้เพื่อระบุตัวแปร ฟังก์ชัน คลาส โมดูล หรือรายการอื่นๆ ที่ผู้ใช้กำหนด โดยเริ่มต้นด้วย A ถึง Z หรือ a ถึง z หรือเครื่องหมายขีดล่าง (_) ซึ่งตามด้วยตัวอักษรศูนย์หรือมากกว่า และ 0 ถึง 9 C++ ไม่อนุญาตให้ใช้เครื่องหมายวรรคตอน เช่น @, $ และ % ภายในตัวระบุ เป็นภาษาโปรแกรมที่คำนึงถึงขนาดตัวพิมพ์ ดังนั้น Workforce และ Workforce จึงเป็นตัวระบุที่แตกต่างกันสองแบบใน C++
ประเภทข้อมูล C++
| พิมพ์ | คีย์เวิร์ด |
|---|---|
| อักขระ | char |
| บูลีน | bool |
| จุดลอยตัว | ลอย |
| จุดลอยตัวสองเท่า | สองเท่า |
| จำนวนเต็ม | int |
| ไร้ค่า | โมฆะ |
| ตัวอักษรกว้าง | wchar_t |
| พิมพ์ | ความกว้างบิตทั่วไป | ช่วงทั่วไป |
| char | 1byte | -127 ถึง 127 หรือ 0 ถึง 255 |
| ถ่านที่ไม่ได้ลงชื่อ | 1byte | 0 ถึง 255 |
| ลงนาม char | 1byte | -127 ถึง 127 |
| wchar_t | 2 หรือ 4 ไบต์ | ตัวอักษรกว้าง 1 ตัว |
| int | 4bytes | -2147483648 ถึง 2147483647 |
| ไม่ได้ลงนาม int | 4bytes | 0 ถึง 4294967295 |
| ลงชื่อเข้าใช้ | 4bytes | -2147483648 ถึง 2147483647 |
| ความหมายสั้น | 2bytes | -32768 ถึง 32767 |
| ลอย | 4bytes | |
| int สั้นที่ไม่ได้ลงนาม | 2bytes | 0 ถึง 65,535 |
| ลงนาม int สั้น | 2bytes | -32768 ถึง 32767 |
| ยาว int | 8bytes | -2,147,483,648 ถึง 2,147,483,647 |
| ลงนามยาว int | 8bytes | เช่นเดียวกับ int ยาว |
| ไม่ได้ลงนาม int ยาว | 8bytes | 0 ถึง 4,294,967,295 |
| ยาวยาว int | 8bytes | -(2^63) ถึง (2^63)-1 |
| ไม่ได้ลงนาม ยาว ยาว int | 8bytes | 0 ถึง 18,446,744,073,709,551,615 |
| สองเท่า | 8bytes | |
| ยาวสองเท่า | 12bytes |
ค่าคงที่ C++/ตัวอักษร
ค่าคงที่หมายถึงค่าคงที่ที่โปรแกรมอาจเปลี่ยนแปลงและเรียกว่าค่าตามตัวอักษร
ค่าคงที่สามารถเป็นข้อมูลดิบชนิดใดก็ได้ และแบ่งออกเป็นเลขจำนวนเต็ม อักขระ ตัวเลขทศนิยม สตริง และค่าบูลีน
จำนวนเต็ม
ค่าคงที่ของเลขจำนวนเต็มคือค่าคงที่ทศนิยม ฐานแปด หรือเลขฐานสิบหก
ตัวอักษรจำนวนเต็มมีส่วนต่อท้ายที่เป็นการรวมกันของ L และ U สำหรับแบบยาวและแบบไม่มีเครื่องหมาย ตามลำดับ คำต่อท้ายอาจเป็นตัวพิมพ์เล็กหรือตัวพิมพ์ใหญ่ และสามารถอยู่ในลำดับใดก็ได้
สำหรับเช่น: 212, 215u, 0xFeeL, 078, 032UU
เลขทศนิยม
ลิเทอรัลพอยต์ทศนิยมมีส่วนจำนวนเต็ม เศษส่วน จุดทศนิยม และส่วนเลขชี้กำลัง คุณสามารถแสดงตัวอักษรทศนิยมในรูปแบบทศนิยมหรือเลขชี้กำลัง
ในขณะที่ใช้รูปแบบทศนิยม คุณต้องใส่จุดทศนิยม เลขชี้กำลัง หรือทั้งสองอย่าง ในขณะที่ใช้รูปแบบเลขชี้กำลัง คุณต้องมีส่วนที่เป็นเศษส่วน ส่วนจำนวนเต็ม หรือทั้งสองอย่าง เลขชี้กำลังที่มีเครื่องหมายถูกแนะนำโดย E หรือ e
ตัวอักษรบูลีน
มีตัวอักษรบูลีนสองตัว
ตัวอักษรตัวอักษร
ตัวอักษรอยู่ในเครื่องหมายคำพูดเดี่ยว หากตัวอักษรขึ้นต้นด้วย L จะเป็นตัวอักษรแบบกว้างและควรเก็บไว้ในตัวแปรประเภท wchar_t มิฉะนั้น จะเป็นตัวอักษรแบบแคบและถูกเก็บไว้ในตัวแปรแบบง่ายของประเภทถ่าน
| ลำดับการหลบหนี | ความหมาย |
| \ | อักขระ |
| ' | ' อักขระ |
| อักขระ | |
| ? | ? อักขระ |
| ถึง | เตือนหรือกระดิ่ง |
| Backspace | |
| f | ฟีดรูปแบบ |
| ขึ้นบรรทัดใหม่ | |
| คืนรถ | |
| แถบแนวนอน | |
| v | แท็บแนวตั้ง |
| ooo | เลขฐานแปดหนึ่งถึงสามหลัก |
| xhh . . | เลขฐานสิบหกของตัวเลขอย่างน้อยหนึ่งหลัก |
คลาสสตอเรจ C++
คลาสการจัดเก็บอัตโนมัติ
เป็นคลาสการจัดเก็บเริ่มต้นสำหรับตัวแปรโลคัลทั้งหมด
SYNTAX
|_+_|การลงทะเบียน Storage Class
ใช้เพื่อกำหนดตัวแปรท้องถิ่นที่เก็บไว้ในรีจิสเตอร์แทนที่จะเป็น RAM หมายความว่าตัวแปรมีขนาดสูงสุดเท่ากับขนาดรีจิสเตอร์และไม่สามารถใช้ตัวดำเนินการ '&' ได้
SYNTAX
|_+_|คลาสสตอเรจแบบคงที่
มันบอกให้คอมไพเลอร์เก็บตัวแปรท้องถิ่นไว้ในระหว่างโปรแกรมแทนที่จะสร้างและทำลายมัน ดังนั้นการทำให้ตัวแปรโลคัลคงที่ทำให้พวกเขาสามารถรักษาค่าระหว่างการเรียกใช้ฟังก์ชันได้
ชั้นเก็บของภายนอก
ใช้เพื่ออ้างอิงตัวแปรส่วนกลางที่มองเห็นได้ในทุกไฟล์ของโปรแกรม เมื่อคุณใช้ 'extern' ตัวแปรจะไม่สามารถเริ่มต้นได้
คลาสสตอเรจที่เปลี่ยนแปลงได้
ตัวระบุที่ไม่แน่นอนนำไปใช้กับคลาสอ็อบเจ็กต์ เสนอสมาชิกของอ็อบเจ็กต์เพื่อแทนที่ฟังก์ชันสมาชิก const นั่นคือ สมาชิกที่เปลี่ยนแปลงได้สามารถแก้ไขได้โดยฟังก์ชันสมาชิก const
ประเภทตัวดัดแปลง C++
C ++ เสนอประเภทข้อมูล char, int และ double เพื่อให้มีตัวดัดแปลงนำหน้า ตัวดัดแปลงใช้เพื่อเปลี่ยนความหมายของประเภทฐานเพื่อให้ตรงกับความต้องการของสถานการณ์ต่างๆ ได้แม่นยำยิ่งขึ้น
ตัวแก้ไขประเภทข้อมูลถูกกล่าวถึงด้านล่าง−
ตัวแก้ไขที่ลงนาม ไม่ได้ลงนาม ยาว และสั้น ใช้กับประเภทฐานจำนวนเต็ม นอกจากนี้ การลงชื่อและไม่ได้ลงนามจะมีผลกับอักขระ และอักขระแบบยาวใช้กับอักขระสองเท่า
ตัวดัดแปลงที่เซ็นชื่อและไม่ได้ลงนามนั้นใช้เป็นคำนำหน้าตัวดัดแปลงแบบยาวหรือแบบสั้น
ประเภทของรอบคัดเลือก
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|ตัวดำเนินการใน C++
ตัวดำเนินการคือสัญลักษณ์ที่ช่วยให้คอมไพเลอร์ดำเนินการจัดการทางคณิตศาสตร์หรือตรรกะที่เฉพาะเจาะจง C++ มีโอเปอเรเตอร์ในตัวที่หลากหลายและมีโอเปอเรเตอร์ประเภทต่อไปนี้ −
ตัวดำเนินการเลขคณิต
ตัวดำเนินการเลขคณิตไม่มีอะไรเลยนอกจากตัวดำเนินการที่ใช้ในการดำเนินการทางคณิตศาสตร์ระหว่างตัวแปรหรือค่าสองค่า
| ผู้ประกอบการ | คำอธิบาย | ไวยากรณ์ |
| + | เพิ่มตัวถูกดำเนินการสองตัว | a+b |
| * | คูณสองตัวถูกดำเนินการ | ก*ข |
| – | ลบตัวถูกดำเนินการสองตัว | a-b |
| / | แบ่งตัวถูกดำเนินการแรกด้วยตัวที่สอง | a/b |
| % | ส่งคืนค่าที่เหลือเมื่อตัวถูกดำเนินการแรกหารด้วยตัวถูกที่สอง | a%b |
| ++ | มันเพิ่มค่าจำนวนเต็มหนึ่ง | ++ |
| — | ลดค่าจำนวนเต็มลงหนึ่ง | ถึง- |
ตัวดำเนินการตรรกะ
ตัวดำเนินการเชิงตรรกะใน C ++ รวมค่าจริงหรือเท็จของตัวแปรเพื่อให้คุณสามารถหาค่าความจริงที่เป็นผลลัพธ์ได้
| ผู้ประกอบการ | คำอธิบาย | ไวยากรณ์ |
| หรือ (||) | จริงถ้าตัวถูกดำเนินการตัวใดตัวหนึ่งเป็นจริง | (A || B) เป็นจริง |
| และ (&&) | True ถ้าตัวถูกดำเนินการทั้งคู่เป็นจริง | (A && B) เป็นเท็จ |
| ไม่ (!) | หากเงื่อนไขเป็นจริง ตัวดำเนินการ Logical NOT จะทำให้เป็นเท็จ | !(A && B) เป็นความจริง |
ตัวดำเนินการระดับบิต
ใน C++ ตัวดำเนินการระดับบิตจะทำการคำนวณระดับบิตกับจำนวนเต็ม ตัวดำเนินการระดับบิต: ส่งกลับ 1 ถ้าทั้งสองบิตเป็น 1 อย่างอื่น 0 ตัวอย่าง: a = 10 = 1010 (ไบนารี) b = 4 = 0100 (ไบนารี a & b = 1010 & 0100 = 0000 = 0 (ทศนิยม) Bitwise หรือตัวดำเนินการ: ส่งกลับ 1 ถ้าบิตใดบิตหนึ่งเป็น 1 อื่น 0
| ผู้ประกอบการ | คำอธิบาย | ไวยากรณ์ |
| >> | กะไบนารีขวา x>> | x>> |
| << | กะไบนารีซ้าย | x<< |
| ^ | ไบนารีXOR | x ^ y |
| & | ไบนารีและ | x & y |
| | | ไบนารีหรือ | x | Y |
| ~ | ไบนารีไม่ | ~x |
ผู้ปฏิบัติงานที่ได้รับมอบหมาย
ตัวดำเนินการมอบหมายกำหนดค่าให้กับตัวแปร a = 5 เป็นตัวดำเนินการกำหนดค่าที่ตั้งค่า 5 ทางด้านขวาให้กับตัวแปร a ทางด้านซ้าย
| ผู้ประกอบการ | คำอธิบาย | ไวยากรณ์ |
| = | กำหนดค่านิพจน์ด้านขวาให้กับตัวถูกดำเนินการด้านซ้าย | a=b+c |
| += | เพิ่มตัวถูกดำเนินการทางขวาของตัวถูกดำเนินการทางซ้าย จากนั้นกำหนดตัวถูกดำเนินการทางซ้าย | a+=b a=a+b |
| -= | ลบตัวถูกดำเนินการทางขวาออกจากตัวถูกดำเนินการทางซ้าย แล้วกำหนดให้กับตัวถูกดำเนินการทางซ้าย | a-=b a=a-b |
| /= | หารตัวถูกดำเนินการทางซ้ายด้วยตัวถูกดำเนินการทางขวา แล้วกำหนดตัวถูกดำเนินการทางซ้าย | a/=b a=a/b |
| %= | หาโมดูลัสโดยใช้ตัวถูกดำเนินการด้านซ้ายและขวา และกำหนดผลลัพธ์ให้กับตัวถูกดำเนินการทางซ้าย | a%=b a=a%b |
| *= | คำนวณค่าเลขชี้กำลังโดยใช้ตัวถูกดำเนินการและกำหนดค่าให้กับตัวถูกดำเนินการทางซ้าย | a*=b a=a*b |
| &= | ดำเนินการ Bitwise AND บนตัวถูกดำเนินการ และกำหนดค่าให้กับตัวถูกดำเนินการทางซ้าย | a&=b a=a&b |
| |= | ดำเนินการ Bitwise OR บนตัวถูกดำเนินการ และกำหนดค่าให้กับตัวถูกดำเนินการทางซ้าย | a|=b a=a|b |
| ^= | ดำเนินการ Bitwise OR บนตัวถูกดำเนินการ และกำหนดค่าให้กับตัวถูกดำเนินการทางซ้าย | a^=b a=a^b |
| >>= | ดำเนินการกะทางขวาของ Bitwise บนตัวถูกดำเนินการ และกำหนดค่าให้กับตัวถูกดำเนินการทางซ้าย | a>>=b a=a>>b |
| <<= | ดำเนินการกะทางซ้ายแบบ Bitwise บนตัวถูกดำเนินการ และกำหนดค่าให้กับตัวถูกดำเนินการทางซ้าย | ถึง<<= b a= a << b |
โอเปอเรเตอร์เชิงสัมพันธ์
ตัวดำเนินการเชิงสัมพันธ์คือตัวดำเนินการที่ใช้เพื่อเปรียบเทียบค่าหรืออ็อบเจกต์สองค่า
| ผู้ประกอบการ | คำอธิบาย | ไวยากรณ์ |
| > | มากกว่า | x > y |
| < | น้อยกว่า | x |
| == | เท่ากัน | x == y |
| != | ไม่เท่ากับ | x != y |
| >= | มากกว่าหรือเท่ากับ | x >= y |
| <= | น้อยกว่าหรือเท่ากับ | x<= y |
ตัวดำเนินการเบ็ดเตล็ด
| โอเปอเรเตอร์ | คำอธิบาย |
| สภาพ? X : อือ | หากเงื่อนไขเป็นจริง จะส่งคืนค่า X ไม่เช่นนั้นจะคืนค่า Y |
| , | มันทำให้เกิดลำดับของการดำเนินการที่จะดำเนินการ ค่าของลูกน้ำคือค่าของนิพจน์สุดท้ายของรายการที่คั่นด้วยเครื่องหมายจุลภาค |
| ขนาดของ | ส่งกลับขนาดของตัวแปร ตัวอย่างเช่น sizeof(a) โดยที่ 'a' เป็นจำนวนเต็มและจะส่งกลับ 4 |
| * | เป็นตัวชี้ไปยังตัวแปร ตัวอย่างเช่น *var; จะชี้ไปที่ตัวแปร var |
| หล่อ | มันแปลงข้อมูลประเภทหนึ่งเป็นอีกประเภทหนึ่ง |
| . (จุด) และ -> (ลูกศร) | ใช้เพื่ออ้างอิงถึงสมาชิกแต่ละรายของคลาส โครงสร้าง และสหภาพแรงงาน |
| & | ส่งคืนที่อยู่ของตัวแปร |
C++ ลูป
สำหรับวง
C++ for loop ใช้เพื่อวนซ้ำส่วนหนึ่งของโปรแกรมหลายครั้ง หากจำนวนการวนซ้ำคงที่ แนะนำให้ใช้ for loop มากกว่า while หรือ do-while loops
C++ for loop เหมือนกับ C/C# เราสามารถเริ่มต้นตัวแปร ตรวจสอบเงื่อนไข และเพิ่ม/ลดค่าได้
SYNTAX
|_+_|ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|ซ้อนกันสำหรับลูป
ใน C ++ คุณสามารถใช้ for วนซ้ำภายในอีกอันสำหรับลูป เรียกว่า nested for loop วงในจะดำเนินการอย่างเต็มที่เมื่อดำเนินการวนรอบนอกครั้งเดียว ดังนั้น หากวงนอกและวงในดำเนินการสี่ครั้ง วงในจะดำเนินการสี่ครั้งสำหรับแต่ละวงรอบนอก กล่าวคือ รวมเป็น 16 ครั้ง
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|ในขณะที่วง
ใน C ++ ในขณะที่ลูปใช้เพื่อวนซ้ำส่วนหนึ่งของโปรแกรมหลายครั้ง หากจำนวนการวนซ้ำไม่คงที่ ขอแนะนำให้ใช้ลูป while แทนการวนซ้ำ
SYNTAX
|_+_|ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|ซ้อนกันในขณะที่วนรอบ
ใน C ++ คุณสามารถใช้ while loop ใน while loop อื่น เรียกว่า nested while loop การซ้อน while loop จะถูกดำเนินการเมื่อทำการวนรอบนอกหนึ่งครั้ง
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|ทำในขณะที่ลูป
C++ do-while loop ใช้เพื่อวนซ้ำส่วนหนึ่งของโปรแกรมหลายครั้ง หากจำนวนการวนซ้ำไม่คงที่ และคุณต้องดำเนินการวนซ้ำอย่างน้อยหนึ่งครั้ง ขอแนะนำให้ใช้ลูป do-while
ลูป C++ do-while ถูกดำเนินการอย่างน้อยหนึ่งครั้งเนื่องจากเงื่อนไขถูกตรวจสอบหลังจากเนื้อหาของลูป
SYNTAX
|_+_|ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|ซ้อนกัน Do-While Loop
ใน C++ หากคุณใช้ลูป do-while ภายในลูป do-while อื่น จะเรียกว่าลูป do-while ที่ซ้อนกัน ลูป do-while ที่ซ้อนกันจะถูกดำเนินการอย่างเต็มที่สำหรับลูป do-while ภายนอกแต่ละอัน
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|คำชี้แจงการตัดสินใจ
มีบางสถานการณ์ในชีวิตจริงที่คุณต้องตัดสินใจบางอย่าง และจากการตัดสินใจเหล่านี้ คุณเป็นผู้ตัดสินใจว่าคุณควรจะทำอะไรต่อไป ปัญหาที่คล้ายคลึงกันเกิดขึ้นในการเขียนโปรแกรมเช่นกันซึ่งคุณต้องตัดสินใจบางอย่าง และจากการตัดสินใจเหล่านี้ คุณจะดำเนินการบล็อกโค้ดถัดไป
คำสั่งการตัดสินใจในภาษาโปรแกรมจะกำหนดทิศทางของการไหลของโปรแกรม คำชี้แจงการตัดสินใจที่มีอยู่ใน C ++ คือ:
ถ้าคำสั่ง
ถ้าคำสั่งเป็นคำสั่งง่ายๆในการตัดสินใจ มันถูกใช้เพื่อตัดสินใจว่าบล็อกของคำสั่งจะถูกดำเนินการหรือไม่ หากเงื่อนไขเป็นจริง บล็อกของคำสั่งจะถูกดำเนินการ มิฉะนั้น จะไม่ดำเนินการ
SYNTAX
|_+_|ที่นี่, เงื่อนไข หลังจากประเมินแล้วจะเป็นจริงหรือเท็จ ถ้าคำสั่งยอมรับค่าบูลีน
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|ถ้าอย่างอื่นคำสั่ง
คำสั่ง if บอกว่าถ้าเงื่อนไขใด ๆ เป็นจริง คำสั่งจะทำการบล็อกคำสั่ง และถ้าเงื่อนไขเป็นเท็จ จะไม่ดำเนินการ คุณสามารถใช้คำสั่ง else กับคำสั่ง if เพื่อรันบล็อกของโค้ดเมื่อเงื่อนไขเป็นเท็จ
SYNTAX
|_+_|ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|ซ้อนกันถ้างบ
ซ้อน if ใน C ++ เป็นคำสั่ง if ที่กำหนดเป้าหมายคำสั่ง if อื่น คำสั่งซ้อน if หมายความว่าคำสั่ง if ภายในคำสั่ง if อื่น ใช่ ทั้ง C และ C ++ เสนอคำสั่ง if ที่ซ้อนกันภายในคำสั่ง if นั่นคือคุณสามารถวางคำสั่ง if ไว้ในคำสั่ง if อื่นได้
SYNTAX
|_+_|ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|if-else-if บันได
ผู้ใช้สามารถตัดสินใจได้จากตัวเลือกต่างๆ คำสั่ง if ดำเนินการจากบนลงล่าง ทันทีที่เงื่อนไขควบคุม if เป็นจริง คำสั่งที่เกี่ยวข้องกับสิ่งนั้นจะถูกดำเนินการ และส่วนที่เหลืออื่น-if ถ้าแลดเดอร์ถูกยกเลิก หากเงื่อนไขไม่เป็นความจริง คำสั่งสุดท้ายและสุดท้ายจะถูกดำเนินการ
SYNTAX
|_+_|ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|ข้ามคำสั่ง
หยุดพัก
คำสั่งนี้ใช้เพื่อยุติการวนซ้ำ ทันทีที่พบคำสั่ง break จากภายในลูป การวนซ้ำของลูปจะหยุดอยู่ที่นั่นและการควบคุมจะย้อนกลับไปยังคำสั่งแรกหลังจากลูปทันที
SYNTAX
หยุดพัก;
คำสั่งแบ่งใช้ในสถานการณ์เมื่อเราไม่แน่ใจเกี่ยวกับจำนวนการวนซ้ำที่แท้จริงของลูปหรือยุติการวนซ้ำตามเงื่อนไขบางอย่าง
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|ดำเนินการต่อ
คำสั่ง Continue ตรงกันข้ามกับคำสั่ง break แทนที่จะยุติการวนซ้ำ มันจะบังคับการวนซ้ำครั้งต่อไปของลูป
คำสั่ง Continue บังคับให้ลูปรันการวนซ้ำครั้งต่อไป เมื่อรันคำสั่ง Continue โค้ดภายในลูปที่ตามหลังคำสั่ง Continue จะถูกข้ามไป และการวนซ้ำครั้งต่อไปจะเริ่มขึ้น
SYNTAX
|_+_|ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|ไปที่
คำสั่ง goto ใน C ++ หมายถึงคำสั่งข้ามที่ไม่มีเงื่อนไขซึ่งใช้ในการข้ามจากจุดหนึ่งไปยังอีกจุดหนึ่งในฟังก์ชัน
SYNTAX
|_+_|ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|กลับ
การส่งคืนใน C++ จะคืนค่าโฟลว์ของการดำเนินการไปยังฟังก์ชัน คำสั่งนี้ไม่ต้องการคำสั่งแบบมีเงื่อนไขใดๆ เมื่อดำเนินการคำสั่งแล้ว โฟลว์ของโปรแกรมจะหยุดทันทีและส่งคืนการควบคุมจากตำแหน่งที่เรียกใช้ คำสั่ง return อาจหรืออาจไม่ส่งคืนสิ่งใดๆ สำหรับฟังก์ชัน void แต่จะต้องส่งคืนค่าที่ส่งคืนสำหรับฟังก์ชันที่ไม่เป็นโมฆะ
SYNTAX
|_+_|ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|ฟังก์ชัน C++
ฟังก์ชันหมายถึงกลุ่มของคำสั่งที่รับอินพุต ประมวลผล และส่งกลับเอาต์พุต วัตถุประสงค์ของฟังก์ชันนี้คือการรวมงานที่ทำซ้ำแล้วซ้ำอีก หากคุณมีอินพุตที่หลากหลาย คุณไม่จำเป็นต้องเขียนโค้ดเดิมอีก คุณสามารถเรียกใช้ฟังก์ชันด้วยชุดข้อมูลอื่นที่เรียกว่าพารามิเตอร์
โปรแกรม C++ มีฟังก์ชันอย่างน้อยหนึ่งฟังก์ชัน นั่นคือฟังก์ชัน main()
การกำหนดฟังก์ชัน
นิยามฟังก์ชันใน C++ ประกอบด้วยส่วนหัวของฟังก์ชันและเนื้อหา
ตัวอย่าง
|_+_|ประกาศฟังก์ชั่น
ใน C++ ต้องประกาศฟังก์ชันก่อนใช้งาน คุณสามารถประกาศฟังก์ชันโดยระบุค่าที่ส่งกลับ ชื่อ และประเภทของอาร์กิวเมนต์ เงื่อนไขของอาร์กิวเมนต์เป็นทางเลือก นิยามฟังก์ชันนับเป็นการประกาศฟังก์ชัน
ตัวอย่าง
|_+_|เรียกฟังก์ชัน
ในขณะที่คุณสร้างฟังก์ชัน C++ คุณต้องกำหนดว่าฟังก์ชันนั้นต้องทำอะไร ในการใช้ฟังก์ชัน คุณต้องเรียกหรือเรียกใช้ฟังก์ชันนั้น
เมื่อโปรแกรมเรียกใช้ฟังก์ชัน การควบคุมโปรแกรมจะถูกโอนไปยังฟังก์ชันที่เรียก ฟังก์ชันที่เรียกทำงานตามที่กำหนดไว้ และเมื่อเรียกใช้คำสั่ง return หรือเมื่อถึงวงเล็บปิดที่สิ้นสุดฟังก์ชัน จะส่งคืนการควบคุมโปรแกรมไปยังโปรแกรมหลัก
ตัวอย่าง
|_+_|อาร์กิวเมนต์ฟังก์ชัน
หากฟังก์ชันใช้อาร์กิวเมนต์ ก็ควรประกาศตัวแปรที่ยอมรับค่าของอาร์กิวเมนต์ ตัวแปรเหล่านี้เรียกว่า พารามิเตอร์ทางการของฟังก์ชัน
เบอร์ C++
โดยปกติ เมื่อเราทำงานกับ Numbers เราใช้ชนิดข้อมูลพื้นฐาน เช่น int, short, long, float, double เป็นต้น จำนวนประเภทข้อมูล ค่าที่เป็นไปได้ และช่วงตัวเลขได้รับการอธิบายในขณะที่พูดถึงประเภทข้อมูล C++
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|ตัวดำเนินการทางคณิตศาสตร์ใน C++
| ใช่ไม่ใช่ | ฟังก์ชั่น | วัตถุประสงค์ |
| หนึ่ง | บาปสองครั้ง(สองเท่า); | มันใช้มุม (เป็นสองเท่า) และคืนค่าไซน์ |
| สอง | คู่ cos(สองเท่า); | มันใช้มุม (เป็นสองเท่า) และคืนค่าโคไซน์ |
| 3 | ตาลคู่(คู่); | มันใช้มุม (เป็นสองเท่า) และคืนค่าแทนเจนต์ |
| 4 | ดับเบิ้ลพาว(ดับเบิ้ล, ดับเบิ้ล); | ตัวแรกคือตัวเลขที่คุณต้องการเพิ่ม และตัวที่สองคือพลังที่คุณต้องการเพิ่ม t |
| 5 | บันทึกสองครั้ง(สองเท่า); | ใช้ตัวเลขและคืนค่าล็อกธรรมชาติของตัวเลขนั้น |
| 6 | ดับเบิ้ลไฮพอต(ดับเบิ้ล, ดับเบิ้ล); | หากคุณผ่านความยาวของสองด้านของสามเหลี่ยมมุมฉากไป มันจะคืนค่าความยาวของด้านตรงข้ามมุมฉาก |
| 7 | sqrt คู่ (คู่); | คุณส่งฟังก์ชันจำนวนหนึ่งและมันให้รากที่สองแก่คุณ |
| 8 | int เอบีเอส (int); | ส่งกลับค่าสัมบูรณ์ของจำนวนเต็มที่ส่งผ่านไป |
| 9 | ชั้นสอง(คู่); | ค้นหาจำนวนเต็มที่น้อยกว่าหรือเท่ากับอาร์กิวเมนต์ที่ส่งผ่าน |
| 10 | ดับเบิ้ลแฟบ(ดับเบิ้ล); | ส่งกลับค่าสัมบูรณ์ของตัวเลขทศนิยมที่ส่งไป |
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|อาร์เรย์ C++
อาร์เรย์ใน C ++ คือชุดของรายการที่จัดเก็บไว้ในตำแหน่งหน่วยความจำที่อยู่ติดกัน และองค์ประกอบต่างๆ สามารถเข้าถึงได้แบบสุ่มโดยใช้ดัชนีของอาร์เรย์ ใช้เพื่อจัดเก็บองค์ประกอบที่คล้ายคลึงกันเนื่องจากประเภทข้อมูลจะต้องเหมือนกันสำหรับองค์ประกอบทั้งหมด พวกเขาสามารถจัดเก็บประเภทข้อมูลดั้งเดิมเช่น char, int, float, double ฯลฯ เพื่อเพิ่มอาร์เรย์ใน C ++ สามารถจัดเก็บประเภทข้อมูลที่ได้รับเช่นโครงสร้างพอยน์เตอร์ ฯลฯ ด้านล่างคือการแสดงอาร์เรย์ที่งดงาม .
ประกาศอาร์เรย์
SYNTAX
|_+_|ตัวอย่าง
|_+_|ที่นี่,
เข้าถึงองค์ประกอบในอาร์เรย์
แต่ละองค์ประกอบในอาร์เรย์เชื่อมต่อกับตัวเลข ตัวเลขนี้เรียกว่าดัชนีอาร์เรย์ คุณสามารถเข้าถึงองค์ประกอบของอาร์เรย์ได้โดยใช้ดัชนี
SYNTAX
|_+_|ตัวอย่าง
|_+_|ต่อไปนี้เป็นแนวคิดที่สำคัญบางประการของอาร์เรย์ C ++
สตริง C++
เป็นการรวมตัวของตัวละคร มีสตริงสองประเภทที่ใช้ในภาษาการเขียนโปรแกรม C ++:
คลาสสตริง
ไลบรารี C++ มี a สตริง ประเภทคลาสที่รองรับการทำงานทั้งหมดที่กล่าวมาข้างต้น และยังมีฟังก์ชันอื่นๆ อีกมากมาย
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|สายซี
สตริงนี้มีต้นกำเนิดมาจากภาษา C และได้รับการสนับสนุนภายใน C++ สตริงนี้เป็นอาร์เรย์หนึ่งมิติของอักขระที่สิ้นสุดโดยอักขระ null ' ' ดังนั้นสตริงที่สิ้นสุดด้วยค่า null จึงมีอักขระที่ประกอบเป็นสตริงที่ตามด้วยค่า null
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|ฟังก์ชันบางอย่างที่จัดการสตริงที่สิ้นสุดด้วยค่า null
มันคัดลอกสตริง s2 ลงในสตริง s1
มันเชื่อมสตริง s2 เข้ากับส่วนท้ายของสตริง s1
ส่งคืนตัวชี้ไปยังการเกิดสตริง s2 ในสตริง s1
ส่งกลับความยาวของสตริง s1
คืนค่า 0 หาก s1 และ s2 เหมือนกัน น้อยกว่า 0 ถ้า s1s2
จะส่งกลับตัวชี้ไปที่การเกิดขึ้นของอักขระ ch ในสตริง s1
ตัวชี้ C++
พอยน์เตอร์เป็นตัวแทนของที่อยู่ ช่วยให้โปรแกรมสามารถจำลองการเรียกโดยการอ้างอิง และสร้างและจัดการโครงสร้างข้อมูลแบบไดนามิก
SYNTAX
|_+_|วิธีการใช้พอยน์เตอร์?
แนวคิดบางประการของพอยน์เตอร์
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|การอ้างอิง C++
ตัวแปรอ้างอิงคือชื่อของตัวแปรที่มีอยู่แล้ว เมื่อการอ้างอิงเริ่มต้นขึ้น อาจใช้ชื่อตัวแปรหรือชื่ออ้างอิงเพื่ออ้างถึงตัวแปร
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|C++ วันที่และเวลา
ไลบรารี C++ ไม่มีประเภทวันที่ที่เหมาะสม มันสืบทอดโครงสร้างและฟังก์ชันสำหรับการจัดการวันที่และเวลาจาก C ในการเข้าถึงฟังก์ชันและโครงสร้างที่เกี่ยวข้องกับวันที่และเวลา คุณจะต้องรวมไฟล์ส่วนหัวในโปรแกรม C++ ของคุณ
มีสี่ประเภทที่เกี่ยวข้องกับเวลา: clock_t, time_t, size_t และ tm ประเภท – clock_t, size_t และ time_t สามารถแสดงเวลาและวันที่ของระบบเป็นจำนวนเต็มได้
ตัวอย่าง
|_+_|หน้าที่ที่สำคัญบางประการ
ส่งกลับเวลาตามปฏิทินปัจจุบันในไม่กี่วินาทีที่ผ่านไปตั้งแต่วันที่ 1 มกราคม 1970 หากระบบไม่มีเวลา ระบบจะส่งกลับ .1
ส่งคืนตัวชี้ไปยังสตริงของ form วัน เดือน ปี ชั่วโมง:นาที:วินาที.
ส่งคืนตัวชี้ไปที่ tm โครงสร้างแทนเวลาท้องถิ่น
ส่งคืนค่าที่ใกล้เคียงกับเวลาที่โปรแกรมเรียกทำงานอยู่ ค่า .1 จะถูกส่งกลับหากไม่มีเวลา
ส่งคืนตัวชี้ไปยังสตริงที่มีข้อมูลที่จัดเก็บไว้ในโครงสร้างที่ชี้ตามเวลาที่แปลงเป็นรูปแบบ: วัน เดือน วันที่ ชั่วโมง:นาที: วินาที
ส่งกลับตัวชี้ไปยังเวลาในรูปแบบของโครงสร้าง tm
ส่งกลับเวลาตามปฏิทินที่พบในโครงสร้างที่ชี้ตามเวลา
มันคำนวณความแตกต่างในหน่วยวินาทีระหว่าง time1 และ time2
สามารถใช้เพื่อจัดรูปแบบวันที่และเวลาในรูปแบบเฉพาะได้
โครงสร้างข้อมูล C++
อาร์เรย์ C++ ให้คุณกำหนดตัวแปรที่รวมรายการข้อมูลหลายรายการที่เป็นประเภทเดียวกัน ยังคง โครงสร้าง เป็นประเภทข้อมูลที่ผู้ใช้กำหนดเองอีกประเภทหนึ่ง ซึ่งจะช่วยให้คุณรวมรายการข้อมูลประเภทต่างๆ ได้ โครงสร้างถูกใช้เพื่อแสดงเร็กคอร์ด
การกำหนดโครงสร้าง
ในการกำหนดโครงสร้าง คุณควรใช้คำสั่ง struct คำสั่ง struct กำหนดประเภทข้อมูลที่มีสมาชิกมากกว่าหนึ่งรายสำหรับโปรแกรม
|_+_|ดิ แท็กโครงสร้าง เป็นทางเลือก ที่ส่วนท้ายของคำจำกัดความ ก่อนเครื่องหมายอัฒภาคสุดท้าย คุณควรระบุตัวแปรโครงสร้างตั้งแต่หนึ่งตัวขึ้นไป
การเข้าถึงสมาชิกโครงสร้าง
ในการเข้าถึงสมาชิกใดๆ ของโครงสร้าง คุณสามารถใช้ ตัวดำเนินการเข้าถึงสมาชิก (.) . ตัวดำเนินการเข้าถึงสมาชิกถูกเข้ารหัสเป็นช่วงเวลาระหว่างชื่อตัวแปรโครงสร้างและสมาชิกโครงสร้างที่เราต้องการเข้าถึง คุณจะใช้ โครงสร้าง คีย์เวิร์ดเพื่อกำหนดตัวแปรประเภทโครงสร้าง
โครงสร้างเป็นอาร์กิวเมนต์ฟังก์ชัน
คุณสามารถส่งผ่านโครงสร้างเป็นอาร์กิวเมนต์ของฟังก์ชันได้ในลักษณะเดียวกับที่คุณส่งผ่านตัวแปรหรือตัวชี้อื่นๆ
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|C++ คลาสและวัตถุ
ทุกอย่างใน C++ เกี่ยวข้องกับคลาสและอ็อบเจ็กต์ พร้อมด้วยแอตทริบิวต์และเมธอด ตัวอย่างเช่น ในชีวิตจริง รถบัสคือ an วัตถุ . รถโดยสารประจำทางมี คุณลักษณะ เช่น น้ำหนักและสี และ วิธีการ เช่น ระบบขับเคลื่อนและเบรก
คุณสมบัติและวิธีการคือ ตัวแปร และ ฟังก์ชั่น ที่อยู่ในชั้นเรียน พวกเขาเรียกว่าสมาชิกคลาส คลาสเป็นชนิดข้อมูลที่กำหนดโดยผู้ใช้ ซึ่งคุณสามารถใช้ในโปรแกรม และทำงานเป็นตัวสร้างอ็อบเจ็กต์หรือพิมพ์เขียวสำหรับสร้างอ็อบเจ็กต์
สร้างชั้นเรียน
ถ้าคุณต้องการสร้างชั้นเรียน คุณต้องใช้ ระดับ คำสำคัญ:
ตัวอย่าง
|_+_|สร้างวัตถุ
ใน C ++ อ็อบเจ็กต์จะถูกสร้างขึ้นจากคลาส
ในการสร้างวัตถุ คุณต้องระบุชื่อคลาส ตามด้วยชื่อวัตถุ ในการเข้าถึงแอตทริบิวต์ของคลาส ให้ใช้รูปแบบจุด (.) บนวัตถุ:
ตัวอย่าง
|_+_|รายละเอียดแนวคิดเล็กน้อย
มรดก C++
การสืบทอดเป็นกระบวนการที่อ็อบเจ็กต์ได้รับคุณสมบัติและพฤติกรรมทั้งหมดของออบเจกต์หลักโดยอัตโนมัติ คุณสามารถแก้ไขแอ็ตทริบิวต์และแอ็คชันที่กำหนดไว้ในคลาสอื่น
คลาสที่สืบทอดสมาชิกของคลาสอื่นเรียกว่าคลาสที่ได้รับ และคลาสที่สมาชิกได้รับการสืบทอดเรียกว่าคลาสฐาน คลาสที่ได้รับคือคลาสเฉพาะสำหรับคลาสฐาน
ประเภทของมรดก
'A' เป็นคลาสพื้นฐาน
'B' เป็นคลาสที่ได้รับ
คลาส D สืบทอดคุณสมบัติและพฤติกรรมของคลาส C และคลาส B เช่นเดียวกับคลาส A คลาส C และคลาส B สืบทอดคลาส A คลาส A เป็นพาเรนต์สำหรับคลาส B และคลาส C และคลาส D
ตัวแก้ไขการเข้าถึง C++
ตัวแก้ไขการเข้าถึงใช้เพื่อปรับใช้ส่วนสำคัญของการเขียนโปรแกรมเชิงวัตถุที่เรียกว่าการซ่อนข้อมูล Access Modifiers ในคลาสใช้เพื่อกำหนดการเข้าถึงให้กับสมาชิกคลาส มันกำหนดข้อ จำกัด บางประการเกี่ยวกับสมาชิกคลาสไม่ให้เข้าถึงโดยตรงจากฟังก์ชั่นภายนอก
มีตัวแก้ไขการเข้าถึงสามประเภทที่มีอยู่ใน C ++:
ให้เราพูดถึงรายละเอียดเหล่านี้:
สาธารณะ
สมาชิกคลาสทั้งหมดที่ถูกประกาศภายใต้ตัวระบุสาธารณะจะพร้อมใช้งานสำหรับทุกคน ฟังก์ชันของสมาชิกที่ประกาศเป็นสาธารณะสามารถเข้าถึงได้โดยคลาสและฟังก์ชันอื่นๆ ด้วย สมาชิกสาธารณะของชั้นเรียนสามารถเข้าถึงได้จากทุกที่ในโปรแกรมโดยใช้ตัวดำเนินการการเข้าถึง (.) กับวัตถุของชั้นเรียนนั้น
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|ส่วนตัว
ฟังก์ชันของสมาชิกในคลาสจะเข้าถึงได้เฉพาะสมาชิกคลาสที่ประกาศเป็นส่วนตัวเท่านั้น ไม่สามารถเข้าถึงได้โดยตรงจากวัตถุหรือฟังก์ชันภายนอกชั้นเรียน เฉพาะฟังก์ชันเพื่อนเท่านั้นที่ได้รับอนุญาตให้เข้าถึงข้อมูลส่วนตัวของสมาชิกในชั้นเรียน
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|มีการป้องกัน
ตัวดัดแปลงการเข้าถึงที่มีการป้องกันนั้นเหมือนกับตัวแก้ไขการเข้าถึงส่วนตัวเนื่องจากไม่สามารถเข้าถึงได้นอกคลาสของมัน เว้นแต่ด้วยความช่วยเหลือของคลาสเพื่อน ความแตกต่างคือสมาชิกคลาสที่ถูกประกาศว่าได้รับการคุ้มครองสามารถเข้าถึงได้โดยคลาสที่ได้รับ ของชั้นนั้นด้วย
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|C++ โอเวอร์โหลด
ภาษาโปรแกรม C++ ให้คุณระบุคำจำกัดความสำหรับ a . ได้มากกว่าหนึ่งคำ การทำงาน ชื่อหรือ an โอเปอเรเตอร์ ในขอบเขตเดียวกันเรียกว่า ฟังก์ชั่นโอเวอร์โหลด และ โอเปอเรเตอร์โอเวอร์โหลด ตามลำดับ
การประกาศที่โอเวอร์โหลดจะถูกประกาศด้วยชื่อเดียวกับการประกาศที่ประกาศก่อนหน้านี้ในขอบเขตเดียวกัน ยกเว้นว่าการประกาศทั้งสองมีอาร์กิวเมนต์และคำจำกัดความต่างกัน
ฟังก์ชั่นโอเวอร์โหลด
ฟังก์ชั่นโอเวอร์โหลดเป็นคุณสมบัติที่ให้คุณมีฟังก์ชันมากกว่าหนึ่งฟังก์ชันที่มีชื่อเดียวกัน แต่มีรายการพารามิเตอร์ต่างกัน
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|C++ Polymorphism
ตัวดำเนินการโอเวอร์โหลด
คุณสามารถทำให้โอเปอเรเตอร์ทำงานให้กับคลาสที่กำหนดโดยผู้ใช้ได้ ซึ่งหมายความว่า C ++ สามารถให้ตัวดำเนินการมีความหมายพิเศษสำหรับชนิดข้อมูล สิ่งนี้เรียกว่าโอเปอเรเตอร์โอเวอร์โหลด
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|เป็นแนวคิดที่สำคัญของการเขียนโปรแกรมเชิงวัตถุ หมายถึงมากกว่าหนึ่งรูปแบบ นั่นคือ เอนทิตีเดียวกันมีพฤติกรรมแตกต่างกันในสถานการณ์ที่ต่างกัน
การแทนที่ฟังก์ชัน
คุณสามารถมีฟังก์ชันเดียวกันในคลาสฐานเช่นเดียวกับคลาสที่ได้รับ เมื่อคุณเรียกใช้ฟังก์ชันโดยใช้อ็อบเจ็กต์ของคลาสที่ได้รับ ฟังก์ชันของคลาสที่ได้รับจะถูกดำเนินการแทนคลาสพื้นฐาน
ดังนั้น ฟังก์ชันต่างๆ จะถูกดำเนินการขึ้นอยู่กับอ็อบเจ็กต์ที่เรียกใช้ฟังก์ชัน สิ่งนี้เรียกว่าการแทนที่ฟังก์ชัน
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|ฟังก์ชันเสมือน C++
ใน C++ คุณอาจไม่สามารถแทนที่ฟังก์ชันได้หากเราใช้ตัวชี้คลาสพื้นฐานเพื่อชี้ไปที่วัตถุของคลาสที่ได้รับ
การใช้ฟังก์ชันเสมือนในคลาสฐานทำให้แน่ใจได้ว่าฟังก์ชันสามารถแทนที่ได้ในกรณีเหล่านี้ ดังนั้น ฟังก์ชันเสมือนจึงอยู่ภายใต้การแทนที่ฟังก์ชัน
ฟังก์ชั่นเสมือนบริสุทธิ์
เป็นไปได้ว่าคุณต้องการรวมฟังก์ชันเสมือนในคลาสฐานเพื่อให้สามารถกำหนดใหม่ในคลาสที่ได้รับเพื่อให้เหมาะกับออบเจกต์ของคลาสนั้น แต่ไม่มีคำจำกัดความที่มีความหมายที่คุณสามารถกำหนดให้กับฟังก์ชันในคลาสฐาน .
ตัวอย่าง
|_+_|นามธรรมข้อมูล C++
Data abstraction เป็นหนึ่งในคุณสมบัติที่สำคัญของการเขียนโปรแกรมเชิงวัตถุใน C++ สิ่งที่เป็นนามธรรมหมายถึงการแสดงเฉพาะข้อมูลที่เกี่ยวข้องและซ่อนรายละเอียด การแยกข้อมูลหมายถึงการให้เฉพาะข้อมูลที่จำเป็นเกี่ยวกับข้อมูลของโลกภายนอก การซ่อนรายละเอียดเบื้องหลังหรือการนำไปใช้
นามธรรมโดยใช้คลาส
คุณสามารถใช้ Abstraction ใน C ++ ด้วยความช่วยเหลือของคลาส ชั้นเรียนช่วยให้คุณจัดกลุ่มสมาชิกข้อมูลและฟังก์ชันของสมาชิกโดยใช้ตัวระบุการเข้าถึงที่มีอยู่ คลาสสามารถตัดสินใจได้ว่าสมาชิกข้อมูลใดจะมองเห็นได้ต่อโลกภายนอกและสิ่งใดที่ไม่สามารถมองเห็นได้
นามธรรมโดยใช้ตัวระบุการเข้าถึง
ตัวระบุการเข้าถึงมีบทบาทสำคัญในการนำสิ่งที่เป็นนามธรรมไปใช้ใน C ++ คุณสามารถใช้ตัวระบุการเข้าถึงเพื่อบังคับใช้ข้อจำกัดกับสมาชิกคลาส ตัวอย่างเช่น:
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|การห่อหุ้มข้อมูล C++
เป็นกระบวนการของการรวมฟังก์ชันและสมาชิกข้อมูลในหน่วยเดียวที่เรียกว่าคลาส ทั้งนี้เพื่อป้องกันการเข้าถึงข้อมูลโดยตรง เข้าถึงได้จากฟังก์ชันของชั้นเรียน เป็นหนึ่งในคุณสมบัติยอดนิยมของ Object-Oriented Programming ที่ช่วยในการซ่อนข้อมูล
เพื่อนำไปปฏิบัติ
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|คลาสนามธรรม C++
คลาส C ++ ถูกทำให้เป็นนามธรรมโดยประกาศหนึ่งในหน้าที่ของมันเป็นสำคัญ>ฟังก์ชันเสมือนบริสุทธิ์ มีการกล่าวถึงฟังก์ชันเสมือนจริงโดยใส่ = 0 ในการประกาศ คลาสที่ได้รับจะต้องจัดให้มีการนำไปใช้
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|ไฟล์ C++ และสตรีม
| ใช่ไม่ใช่ | ประเภทข้อมูล | คำอธิบาย |
| หนึ่ง | ของกระแสน้ำ | แสดงถึงสตรีมไฟล์เอาต์พุต และใช้เพื่อสร้างไฟล์และเขียนข้อมูลลงในไฟล์ |
| สอง | ifstream | มันแสดงถึงสตรีมไฟล์อินพุตและใช้เพื่ออ่านข้อมูลจากไฟล์ |
| 3 | สตรีม | มันแสดงถึงสตรีมไฟล์โดยทั่วไปและมีความสามารถทั้งของสตรีมและ ifstream |
การเปิดไฟล์
ควรเปิดไฟล์ก่อนจึงจะสามารถอ่านหรือเขียนได้ อาจใช้วัตถุ fstream หรือ ofstream เพื่อเปิดไฟล์สำหรับเขียน ออบเจ็กต์ ifstream ใช้เพื่อเปิดไฟล์เพื่อการอ่านเท่านั้น
| ใช่ไม่ใช่ | โหมดแฟล็ก | คำอธิบาย |
| หนึ่ง | ios::กิน | เอาต์พุตทั้งหมดไปยังไฟล์ที่จะต่อท้าย |
| สอง | ios::app | จะเปิดไฟล์สำหรับเอาต์พุตและย้ายตัวควบคุมการอ่านหรือเขียนไปยังจุดสิ้นสุดของไฟล์ |
| 3 | ios::trunc | หากไฟล์มีอยู่แล้ว เนื้อหาจะถูกตัดทอนก่อนที่จะเปิดไฟล์ |
| 4 | ios::ออก | มันเปิดไฟล์สำหรับเขียน |
| 5 | ios::in | มันเปิดไฟล์สำหรับอ่าน |
SYNTAX
|_+_|การปิดไฟล์
เมื่อโปรแกรม C++ ถูกยกเลิก โปรแกรมจะล้างข้อมูลสตรีมทั้งหมดโดยอัตโนมัติ ปล่อยหน่วยความจำที่จัดสรรไว้ทั้งหมด และปิดไฟล์ทั้งหมดที่เปิดอยู่
SYNTAX
|_+_|การอ่านจากไฟล์
คุณสามารถอ่านข้อมูลจากไฟล์ลงในโปรแกรมของคุณได้โดยใช้ตัวดำเนินการการแยกสตรีม (>>) ข้อแตกต่างเพียงอย่างเดียวคือคุณใช้อ็อบเจ็กต์ fstream หรือ ifstream แทนอ็อบเจ็กต์ cin
อ่านและเขียนตัวอย่าง
|_+_|ผลลัพธ์
|_+_|ตัวชี้ตำแหน่งไฟล์
ทั้ง ostream และ istream มีฟังก์ชันสมาชิกสำหรับการจัดตำแหน่งตัวชี้ตำแหน่งไฟล์ ฟังก์ชันสมาชิกเหล่านี้คือ Seep สำหรับ ostream และ Seekg สำหรับ istream อาร์กิวเมนต์ที่จะแสวงหาและแสวงหาเป็นจำนวนเต็มยาว อาร์กิวเมนต์ที่สองสามารถกล่าวถึงเพื่อระบุทิศทางการค้นหา
การจัดการข้อยกเว้น C++
การจัดการข้อยกเว้นใน C++ เป็นกระบวนการในการจัดการข้อผิดพลาดรันไทม์ คุณดำเนินการจัดการข้อยกเว้นเพื่อให้สามารถรักษาขั้นตอนปกติของแอปพลิเคชันได้แม้หลังจากข้อผิดพลาดรันไทม์
ใน C ++ ข้อยกเว้นคือเหตุการณ์หรืออ็อบเจ็กต์ที่ส่งเมื่อรันไทม์ ข้อยกเว้นทั้งหมดมาจากคลาส std::exception หากเราไม่จัดการกับข้อยกเว้น มันจะพิมพ์ข้อความแสดงข้อยกเว้นและยุติโปรแกรม
| ข้อยกเว้น | คำอธิบาย |
| std::bad_exception | ใช้เพื่อจัดการกับข้อยกเว้นที่ไม่คาดคิด |
| std::logic_failure | สามารถตรวจพบได้โดยการอ่านรหัส |
| std::bad_typeid | โดยทั่วไปจะถูกโยนโดย typeid |
| std::runtime_error | ไม่สามารถตรวจพบได้โดยการอ่านรหัส |
| มาตรฐาน::ข้อยกเว้น | เป็นข้อยกเว้นและคลาสพาเรนต์ของข้อยกเว้น C++ มาตรฐานทั้งหมด |
| std::bad_cast | โดยทั่วไปจะถูกโยนโดย dynamic_cast |
| std::bad_alloc | โดยทั่วไปจะถูกโยนใหม่ |
การจัดการข้อยกเว้น C++ ขึ้นอยู่กับคำหลักสามคำ: ลองจับ และ โยน .
ตัวอย่าง
|_+_|หน่วยความจำไดนามิก C++
หน่วยความจำแบ่งออกเป็นสองส่วน −
โปรแกรมเมอร์สามารถจัดสรรพื้นที่จัดเก็บแบบไดนามิกในขณะที่โปรแกรมกำลังทำงาน อย่างไรก็ตาม โปรแกรมเมอร์ไม่สามารถสร้างชื่อตัวแปรใหม่ได้ และด้วยเหตุนี้ การจัดสรรแบบไดนามิกจึงต้องใช้เกณฑ์สองข้อ:
การยกเลิกการจัดสรรหน่วยความจำเป็นส่วนหนึ่งของแนวคิดนี้เช่นกัน ซึ่งเป็นที่ที่การล้างพื้นที่สำหรับจัดเก็บข้อมูลอื่นๆ สำหรับการยกเลิกการจัดสรรหน่วยความจำแบบไดนามิก คุณสามารถใช้ตัวดำเนินการลบได้ ดังนั้น การจัดสรรหน่วยความจำแบบไดนามิกหมายถึงการจัดการหน่วยความจำสำหรับการจัดสรรหน่วยความจำแบบไดนามิกด้วยตนเอง
ใหม่และลบ Operators
ในที่นี้ ชนิดข้อมูลอาจเป็นชนิดข้อมูลที่มีอยู่แล้วภายในที่มีอาร์เรย์ หรือชนิดข้อมูลที่กำหนดโดยผู้ใช้มีคลาสหรือโครงสร้าง ให้เราเริ่มต้นด้วยประเภทข้อมูลในตัว
SYNTAX
|_+_|เมื่อคุณรู้สึกว่าตัวแปรที่ไม่ได้รับการจัดสรรแบบไดนามิกและไม่จำเป็นอีกต่อไป คุณสามารถเพิ่มหน่วยความจำในร้านค้าว่างได้ด้วย 'ลบ' โอเปอเรเตอร์
SYNTAX
|_+_|ตัวอย่าง
|_+_|การจัดสรรหน่วยความจำแบบไดนามิกของอาร์เรย์
หากคุณเป็นโปรแกรมเมอร์ ต้องการจัดสรรหน่วยความจำสำหรับอาร์เรย์ของอักขระโดยใช้รูปแบบเดียวกับที่คุณสามารถทำได้
ตัวอย่าง
|_+_|เนมสเปซให้คุณจัดกลุ่มเอนทิตีที่มีชื่อซึ่งมี ขอบเขตทั่วโลก ให้อยู่ในขอบเขตที่แคบลง ให้ ขอบเขตเนมสเปซ . นอกจากนี้ยังช่วยให้จัดระเบียบองค์ประกอบของโปรแกรมในขอบเขตตรรกะต่างๆ ที่อ้างอิงถึงชื่อต่างๆ เนมสเปซเป็นคุณลักษณะที่มีอยู่ใน C ++ และไม่มีอยู่ใน C อนุญาตให้ใช้หลายบล็อกเนมสเปซที่มีชื่อเดียวกัน การประกาศทั้งหมดภายในบล็อคถูกประกาศในขอบเขตที่มีชื่อ
SYNTAX
|_+_|ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|เนมสเปซที่ไม่ต่อเนื่องกัน
เนมสเปซถูกกำหนดในหลายส่วน และเนมสเปซประกอบด้วยผลรวมของส่วนต่าง ๆ ที่กำหนดไว้ ส่วนที่แยกจากกันของเนมสเปซจะกระจายไปทั่วหลายไฟล์
SYNTAX
|_+_|เนมสเปซที่ซ้อนกัน
ที่นี่คุณสามารถกำหนดเนมสเปซหนึ่งภายในเนมสเปซอื่น
SYNTAX
|_+_|ตัวอย่าง
|_+_|เทมเพลต C++
เทมเพลตนี้เป็นคุณลักษณะของ C++ ซึ่งให้คุณเขียนโปรแกรมทั่วไปได้ ในอีกแง่หนึ่ง คุณสามารถสร้างฟังก์ชันเดียวหรือคลาสเพื่อทำงานกับข้อมูลประเภทต่างๆ โดยใช้เทมเพลต เทมเพลตใช้ใน codebase ที่ใหญ่ขึ้นเพื่อความยืดหยุ่นของโค้ดและการนำโปรแกรมกลับมาใช้ใหม่ได้
แนวคิดเหล่านี้ใช้ในสองวิธี:
เทมเพลตฟังก์ชัน
เทมเพลตฟังก์ชันทำงานเหมือนกับฟังก์ชันปกติ โดยมีข้อแตกต่างที่สำคัญเพียงข้อเดียว
เทมเพลตฟังก์ชันเดียวอาจทำงานกับประเภทข้อมูลที่แตกต่างกัน แต่ฟังก์ชันปกติเดียวอาจทำงานกับประเภทข้อมูลชุดเดียว
โดยทั่วไป หากคุณต้องการดำเนินการที่เหมือนกันกับข้อมูลหลายประเภท คุณสามารถใช้ฟังก์ชันโอเวอร์โหลดเพื่อสร้างฟังก์ชันด้วยการประกาศฟังก์ชันได้
แม้ว่าแนวทางที่ดีกว่าคือการใช้เทมเพลตฟังก์ชันเพราะคุณสามารถทำงานเดียวกันโดยเขียนโค้ดน้อยลงและสามารถบำรุงรักษาได้
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|เทมเพลตคลาส
เช่นเดียวกับเทมเพลตฟังก์ชัน คุณสามารถสร้างเทมเพลตคลาสสำหรับการดำเนินการของคลาสได้ โดยปกติ คุณจะต้องสร้างคลาสที่แตกต่างกันสำหรับข้อมูลแต่ละประเภท หรือสร้างตัวแปรและฟังก์ชันสมาชิกอื่นภายในคลาสเดียว
สิ่งนี้จะทำให้ codebase ของคุณขยายออกไปโดยไม่จำเป็น และจะดูแลรักษายาก เนื่องจากต้องทำการเปลี่ยนแปลงในคลาส/ฟังก์ชันเดียวในทุกคลาส/ฟังก์ชัน แม้ว่าเทมเพลตของชั้นเรียนจะทำให้ง่ายต่อการนำรหัสเดิมมาใช้ซ้ำสำหรับข้อมูลทุกประเภท
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|ตัวประมวลผลล่วงหน้า C++
คำสั่งตัวประมวลผลล่วงหน้าคือบรรทัดที่รวมอยู่ในรหัสของโปรแกรมที่นำหน้าด้วยเครื่องหมายแฮช (#) บรรทัดเหล่านี้ไม่ใช่คำสั่งที่ตั้งโปรแกรมไว้ แต่เป็นคำสั่งสำหรับตัวประมวลผลล่วงหน้า ตัวประมวลผลล่วงหน้าจะตรวจสอบโค้ดก่อนที่การรวบรวมโค้ดจะเริ่มต้นขึ้น และแก้ไขคำสั่งทั้งหมดก่อนที่คำสั่งปกติจะสร้างโค้ดใดๆ
คำสั่งตัวประมวลผลล่วงหน้าขยายข้ามโค้ดบรรทัดเดียว ทันทีที่พบอักขระขึ้นบรรทัดใหม่ คำสั่งตัวประมวลผลล่วงหน้าจะสิ้นสุด
คำสั่งพรีโปรเซสเซอร์มี 4 ประเภทหลัก:
มาโคร
มาโครเป็นส่วนของรหัสที่กำหนดชื่อ เมื่อใดก็ตามที่คอมไพเลอร์พบชื่อนี้ มันจะแทนที่ชื่อด้วยโค้ดจริง คำสั่ง '#define' ใช้เพื่อกำหนดมาโคร
ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|มาโคร C++ ที่กำหนดไว้ล่วงหน้า
ประกอบด้วยหมายเลขบรรทัดของโปรแกรมเมื่อคอมไพล์โปรแกรม
ประกอบด้วยชื่อไฟล์ปัจจุบันของโปรแกรมเมื่อมีการคอมไพล์
ประกอบด้วยสตริงที่เป็นวันที่ของการแปลไฟล์ต้นฉบับเป็นโค้ดอ็อบเจ็กต์
ประกอบด้วยสตริงของ hour:minute: second ซึ่งเป็นเวลาที่คอมไพล์โปรแกรม
การรวมไฟล์
คำสั่งพรีโปรเซสเซอร์นี้บอกให้คอมไพเลอร์รวมไฟล์ไว้ในโปรแกรม ไฟล์มีสองประเภทที่ผู้ใช้เก็บไว้ในโปรแกรม:
การรวบรวมแบบมีเงื่อนไข
ช่วยรวบรวมบางส่วนของโปรแกรมหรือข้ามการรวบรวมบางส่วนของโปรแกรมตามเงื่อนไขบางประการ
SYNTAX
|_+_|คำสั่งอื่นๆ
นอกเหนือจากคำสั่งที่กล่าวถึงข้างต้นแล้ว ยังมีคำสั่งอีกสองคำสั่งที่ไม่ได้ใช้กันทั่วไป เหล่านี้คือ:
การจัดการสัญญาณ C++
สัญญาณเป็นการหยุดชะงักที่ระบบปฏิบัติการจัดเตรียมให้กับกระบวนการที่จะสิ้นสุดโปรแกรมก่อนเวลาอันควร โดยการกด Ctrl+C บน UNIX ลินุกซ์ , Mac OS X หรือเครื่อง Windows คุณสามารถสร้างอินเตอร์รัปต์ได้
มีสัญญาณที่ซอฟต์แวร์ตรวจไม่พบ แต่มีรายการสัญญาณที่คุณสามารถจับได้ในโปรแกรมของคุณและดำเนินการตามสัญญาณที่ยอมรับได้ ไฟล์ส่วนหัว C++ อธิบายสัญญาณเหล่านี้
| ใช่ไม่ใช่ | สัญญาณ | คำอธิบาย |
| หนึ่ง | SIGFPE | การดำเนินการทางคณิตศาสตร์ที่ผิดพลาด เช่น การหักศูนย์หรือการดำเนินการล้น |
| สอง | SIGABRT | การยุติโปรแกรมที่ผิดปกติ เช่น การเรียกให้ยกเลิก |
| 3 | SIGINT | รับสัญญาณของการโฟกัสแบบโต้ตอบ |
| 4 | ผนึก | การค้นพบคำสั่งที่ไม่ชอบด้วยกฎหมาย |
| 5 | SIGTERM | ยื่นคำร้องขอยุติโครงการ |
| 6 | SIGSEGV | การเข้าถึงดิสก์ไม่ถูกต้อง |
ฟังก์ชันสัญญาณ()
ไลบรารีการจัดการสัญญาณ C++ มีคุณสมบัติสัญญาณเพื่อดักจับเหตุการณ์ที่คาดเดาไม่ได้
SYNTAX
|_+_|ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|ฟังก์ชันยก()
ด้วยฟังก์ชัน rise() ซึ่งใช้หมายเลขสัญญาณจำนวนเต็มเป็นอาร์กิวเมนต์ คุณสามารถสร้างสัญญาณได้
SYNTAX
|_+_|ตัวอย่าง
|_+_|ผลลัพธ์
|_+_|Multithreading เป็นประเภทพิเศษของการทำงานหลายอย่างพร้อมกัน และฟังก์ชันที่ช่วยให้เครื่องของคุณสามารถเรียกใช้โปรแกรมตั้งแต่สองโปรแกรมขึ้นไปพร้อมกันเป็นฟังก์ชันมัลติทาสกิ้ง การทำงานหลายอย่างพร้อมกันโดยทั่วไปมีสองประเภท: แบบอิงตามกระบวนการและแบบอิงตามเธรด การทำงานแบบขนานของโปรแกรมได้รับการจัดการโดยการทำงานหลายอย่างพร้อมกันแบบอิงตามกระบวนการ มัลติทาสกิ้งที่อิงตามเธรดเกี่ยวข้องกับการประมวลผลส่วนต่างๆ ของโปรแกรมเดียวกันแบบขนาน มีส่วนประกอบสองหรือสามส่วนของโปรแกรมแบบมัลติเธรดที่จะทำงานพร้อมกัน
SYNTAX
|_+_|| ใช่ไม่ใช่ | พารามิเตอร์ | คำอธิบาย |
| หนึ่ง | โกรธ | คำสั่งเดียวที่สามารถส่งต่อไปยังรูทีนสตาร์ทได้ จะต้องโอนเป็นตัวชี้ประเภทเป็นโมฆะโดยการเปรียบเทียบ NULL สามารถใช้เมื่อไม่มีอาร์กิวเมนต์ให้ย้าย |
| สอง | เกลียว | ตัวระบุพิเศษแบบทึบสำหรับเธรดปัจจุบันที่รูทีนย่อยส่งคืน |
| 3 | attr | แอตทริบิวต์ของวัตถุที่มองไม่เห็นซึ่งสามารถใช้สำหรับการตั้งค่าแอตทริบิวต์ของเธรด คุณอาจกำหนดวัตถุที่มีคุณสมบัติของเธรด หรือ NULL ด้วยค่าเริ่มต้น |
| 4 | start_routine | รูทีน C++ ที่เมื่อสร้างแล้ว เธรดจะทำงาน |
สิ้นสุดกระทู้
เราใช้รูทีนต่อไปนี้เพื่อยุติเธรด POSIX:
|_+_|ที่นี่ pthread exit ใช้เพื่อออกจากเธรดโดยตรง โดยปกติ เมื่อเธรดทำงานเสร็จแล้วและไม่ต้องการทำงานอีกต่อไป จะมีชื่อรูทีน pthread exit()
หาก main() ยุติและออกด้วย pthread exit() ก่อนสร้างเธรด เธรดอื่นสามารถเริ่มทำงานได้ มิฉะนั้นเมื่อ main() สิ้นสุดลง พวกมันจะถูกยกเลิกทันที
กระทู้เข้าและออก
มีการปฏิบัติตามสองรูทีนที่เราสามารถใช้เพื่อป้อนหรือลบเธรด
|_+_|รูทีนย่อย pthread join() บล็อกเธรดที่เรียกจนกว่าเธรด 'threadid' จะถูกยกเลิก คุณลักษณะหนึ่งกำหนดว่าจะเข้าร่วมหรือแยกออกเมื่อมีการสร้างเธรด สามารถเข้าร่วมได้เฉพาะเธรดที่สร้างเป็นแบบเข้าร่วมได้เท่านั้น ไม่สามารถเข้าร่วมได้หากเธรดถูกแยกออก
การเขียนโปรแกรมเว็บ C++
และ CGI คืออะไร?
ชุดของแนวทางปฏิบัติที่อธิบายว่าข้อมูลถูกแบ่งปันระหว่างเว็บเซิร์ฟเวอร์และสคริปต์ที่กำหนดเองคือ Typical Gateway Interface หรือ CGI สำหรับระบบเกตเวย์ภายนอก Generic Gateway Interface หรือ CGI เป็นมาตรฐานสำหรับการเชื่อมต่อกับเซิร์ฟเวอร์ข้อมูล เช่น เซิร์ฟเวอร์ HTTP CGI/1.1 เป็นเวอร์ชันล่าสุด และ CGI/1.2 อยู่ในระหว่างการพัฒนา
ท่องอินเทอร์เน็ต
มาดูกันว่าจะเกิดอะไรขึ้นเมื่อเรากดไฮเปอร์ลิงก์เพื่อเรียกดูหน้าเว็บหรือ URL เพื่อทำความเข้าใจแนวคิดของ CGI เบราว์เซอร์ของคุณติดต่อเว็บเซิร์ฟเวอร์ HTTP และต้องการ URL เช่น ชื่อไฟล์ตามชื่อไฟล์ เว็บเซิร์ฟเวอร์แยกวิเคราะห์ URL และค้นหาชื่อไฟล์ หากพบไฟล์ที่ร้องขอ เว็บเซิร์ฟเวอร์จะโอนไฟล์กลับไปยังเบราว์เซอร์ มิฉะนั้น จะส่งข้อความแสดงข้อผิดพลาดโดยแจ้งว่าคุณขอไฟล์ที่ไม่ถูกต้อง
อินเทอร์เฟซเกตเวย์ยอดนิยม (CGI) เป็นโปรโตคอลพื้นฐานที่ช่วยให้แอปพลิเคชันสามารถสื่อสารกับเว็บเซิร์ฟเวอร์และกับไคลเอ็นต์ได้ เป็นไปได้ที่จะเขียนโปรแกรม CGI เหล่านี้ใน Python, PERL, Shell, C หรือ C++ เป็นต้น
ตัวอย่าง
|_+_|การกำหนดค่าเว็บเซิร์ฟเวอร์
ตรวจสอบให้แน่ใจว่าเว็บเซิร์ฟเวอร์ยอมรับ CGI ก่อนดำเนินการเขียนโปรแกรม CGI และได้รับการออกแบบมาเพื่อรองรับโปรแกรม CGI โปรแกรม CGI จำนวนมากที่เซิร์ฟเวอร์ HTTP ทำงานอยู่ในไดเร็กทอรีที่กำหนดไว้ล่วงหน้า ไดเร็กทอรีนี้เรียกว่าไดเร็กทอรี CGI และมีชื่อว่า /var/www/cgi-bin ตามแบบแผน ไฟล์ CGI จะมีนามสกุลเป็น .cgi ตามแบบแผน แม้ว่าจะปฏิบัติการได้ด้วย C++
ส่วนหัว HTTP
กำหนดค่าคุกกี้ที่ผ่านสตริง
วันที่อัปเดตล่าสุดของทรัพยากร
ความยาวเป็นไบต์ของข้อมูลที่ส่งคืน ในการรายงานเวลาในการโหลดไฟล์โดยประมาณ เบราว์เซอร์จะใช้ค่านี้
สตริง MIME ที่ระบุรูปแบบของสตริง
URL ที่ควรส่งคืน แทนที่จะเป็น URL ที่ร้องขอ ไฟล์นี้จะใช้เพื่อเปลี่ยนเส้นทางคำขอไปยังไฟล์อื่น
วันที่ข้อมูลกลายเป็นไร้ประโยชน์ เบราว์เซอร์ควรใช้ตัวเลือกนี้เพื่อตัดสินใจว่าจะต้องรีเฟรชเว็บไซต์หรือไม่
ตัวแปรสภาพแวดล้อม
GET และ POST วิธีการ
เมื่อคุณพยายามถ่ายโอนรายละเอียดใดๆ จากเบราว์เซอร์ของคุณไปยังเว็บเซิร์ฟเวอร์และสุดท้ายไปยังแอปพลิเคชัน CGI ของคุณ คุณจะต้องเจอสถานการณ์บางอย่าง เบราว์เซอร์มักใช้สองวิธีในการถ่ายโอนข้อมูลนี้ไปยังเว็บเซิร์ฟเวอร์ วิธีการเหล่านั้นคือวิธี GET และวิธี POST
URL EXAMPLE GET Method
|_+_|การใช้คุกกี้
โปรโตคอล HTTP เป็นโปรโตคอลที่ไม่มีสถานะ แต่สิ่งสำคัญสำหรับเว็บไซต์เชิงพาณิชย์ในการเก็บข้อมูลเซสชันระหว่างไซต์ต่างๆ ตัวอย่างเช่น การลงทะเบียนผู้ใช้รายหนึ่งสิ้นสุดลงหลังจากเสร็จสิ้นหลายหน้า แต่วิธีการเก็บรายละเอียดเซสชั่นสำหรับผู้ใช้ในทุกเว็บไซต์ วิธีที่เชื่อถือได้มากที่สุดในการจดจำและติดตามความสนใจ การขาย ค่าคอมมิชชั่น และรายละเอียดอื่นๆ ที่จำเป็นสำหรับประสบการณ์ของผู้เยี่ยมชมหรือสถิติเว็บไซต์ที่ดีขึ้นคือการใช้คุกกี้ในบางกรณี
ในรูปแบบของคุกกี้ เซิร์ฟเวอร์ของคุณจะถ่ายโอนข้อมูลบางส่วนไปยังหน้าต่างของผู้เยี่ยมชม คุกกี้จะได้รับการอนุมัติจากเบราว์เซอร์ หากเป็นเช่นนั้น ระบบจะบันทึกลงในฮาร์ดไดรฟ์ของผู้เข้าชมเป็นไฟล์ข้อความธรรมดา ตอนนี้คุกกี้พร้อมสำหรับการกู้คืนเมื่อผู้ใช้เข้าชมหน้าอื่นในเว็บของคุณ เมื่อกู้คืน เซิร์ฟเวอร์จะรู้จัก/จดจำสิ่งที่เก็บไว้
ตัวอย่างไฟล์อัพโหลด
|_+_|บทสรุป
ด้วยเหตุนี้เราจึงมาถึงจุดสิ้นสุดของบทช่วยสอน C ++ นี้ หวังว่านี่จะช่วยให้คุณเข้าใจพื้นฐานเกี่ยวกับการเขียนโปรแกรม C++