จุดเริ่มต้นของภาษา C++ เกิดขึ้นในปี 1983 ไม่นานหลังจากนั้นเมื่อ 'บีจาร์ สตรูสทรัพ' ทำงานร่วมกับคลาสในภาษา C รวมถึงคุณสมบัติเพิ่มเติมบางอย่าง เช่น โอเปอเรเตอร์โอเวอร์โหลด นามสกุลไฟล์ที่ใช้คือ '.c' และ '.cpp' C ++ สามารถขยายได้และไม่ขึ้นอยู่กับแพลตฟอร์มและรวมถึง STL ซึ่งเป็นคำย่อของ Standard Template Library ดังนั้น โดยพื้นฐานแล้ว ภาษา C++ ที่รู้จักกันนั้นจริง ๆ แล้วรู้จักกันในชื่อภาษาที่คอมไพล์ซึ่งมีไฟล์ต้นฉบับที่คอมไพล์เข้าด้วยกันเพื่อสร้างไฟล์อ็อบเจ็กต์ ซึ่งเมื่อรวมกับตัวเชื่อมโยงจะสร้างโปรแกรมที่รันได้

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

ส่วนประกอบของภาษา C++:

#include

คำสั่งนี้เป็นไฟล์ส่วนหัวที่ประกอบด้วยคำสั่ง 'cout' อาจมีไฟล์ส่วนหัวมากกว่าหนึ่งไฟล์ขึ้นอยู่กับความต้องการและความชอบของผู้ใช้

int หลัก ()

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

ประกาศ:

มีการประกาศตัวแปรและตั้งชื่อให้กับตัวแปรเหล่านั้น

คำชี้แจงปัญหา:

นี่เป็นสิ่งจำเป็นในโปรแกรมและอาจเป็นลูป 'while', 'for' หรือเงื่อนไขอื่น ๆ

ผู้ประกอบการ:

ตัวดำเนินการใช้ในโปรแกรม C ++ และบางส่วนมีความสำคัญเนื่องจากถูกนำไปใช้กับเงื่อนไข ตัวดำเนินการที่สำคัญสองสามตัว ได้แก่ &&, ||, !, &, !=, |, &=, |=, ^, ^=

C ++ อินพุตเอาต์พุต:

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

อินพุตสตรีม:

ในกรณีที่ไบต์ถูกสตรีมจากอุปกรณ์ไปยังหน่วยความจำหลัก จะเป็นอินพุตสตรีม

กระแสข้อมูลขาออก:

หากไบต์ถูกสตรีมในทิศทางตรงกันข้าม จะเป็นสตรีมเอาต์พุต

ไฟล์ส่วนหัวใช้เพื่ออำนวยความสะดวกอินพุตและเอาต์พุตใน C ++ มันเขียนเป็น ซึ่งมีวิธีการเช่นสตูว์และการตั้งค่าความแม่นยำ คำสั่งอินพุตและเอาต์พุต ได้แก่ cin, cout, cerr และ clog ที่นี่ 'cin' หมายถึงอินพุตมาตรฐานและ 'cout' หมายถึงอุปกรณ์เอาต์พุตมาตรฐานที่ใช้กับตัวดำเนินการแทรกสตรีม (<<) เพื่อแสดงคำสั่งบนหน้าจอ

ตัวอย่าง:

เราจะแสดงข้อความสตริงโดยใช้สตริงประเภทอักขระ

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

ผลลัพธ์ที่สร้างแสดงไว้ด้านล่าง:

ตัวอย่าง:

ในกรณีนี้ เราจะแสดงอายุของผู้ใช้ในข้อความสตริงอย่างง่าย

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

ข้อความนี้จะปรากฏบนหน้าจอหลังจากรันโปรแกรมเพื่อให้ผู้ใช้ได้รับอายุแล้วกด ENTER

ตัวอย่าง:

ที่นี่ เราสาธิตวิธีพิมพ์สตริงโดยใช้ 'cout'

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

ประเภทข้อมูล C++:

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

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

ภาษา C++ ช่วยความหลากหลายของประเภทข้อมูลเพื่อให้โปรแกรมเมอร์สามารถเลือกประเภทข้อมูลที่เหมาะสมที่เขาอาจต้องการ

C ++ อำนวยความสะดวกในการใช้งานประเภทข้อมูลที่ระบุไว้ด้านล่าง:

1. ประเภทข้อมูลที่ผู้ใช้กำหนด
2. ประเภทข้อมูลที่ได้รับ
3. ชนิดข้อมูลในตัว

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

ประเภทข้อมูลทั่วไปสองสามประเภท: ขนาดที่พวกเขาระบุและประเภทของข้อมูลที่ตัวแปรจะจัดเก็บแสดงไว้ด้านล่าง:

• Char: ด้วยขนาดหนึ่งไบต์ มันจะเก็บค่าอักขระตัวเดียว ตัวอักษร ตัวเลข หรือ ASCII
• บูลีน: ด้วยขนาด 1 ไบต์ จะจัดเก็บและคืนค่าเป็นค่าจริงหรือเท็จ
• Int: ด้วยขนาด 2 หรือ 4 ไบต์ จะเก็บจำนวนเต็มที่ไม่มีทศนิยม
• จุดลอยตัว: ด้วยขนาด 4 ไบต์ จะเก็บตัวเลขเศษส่วนที่มีทศนิยมตั้งแต่หนึ่งตำแหน่งขึ้นไป ซึ่งเพียงพอสำหรับการจัดเก็บทศนิยมได้ถึง 7 หลัก
• จุดทศนิยมสองเท่า: ด้วยขนาด 8 ไบต์ จะเก็บตัวเลขเศษส่วนที่มีทศนิยมตั้งแต่หนึ่งตำแหน่งขึ้นไป ซึ่งเพียงพอสำหรับการจัดเก็บทศนิยมสูงสุด 15 หลัก
• โมฆะ: เมื่อไม่มีขนาดที่ระบุ โมฆะก็มีบางสิ่งที่ไร้ค่า ดังนั้นจึงใช้สำหรับฟังก์ชันที่คืนค่า null
• อักขระแบบกว้าง: ด้วยขนาดที่มากกว่า 8 บิต ซึ่งปกติจะมีความยาว 2 หรือ 4 ไบต์ จะแสดงด้วย wchar_t ซึ่งคล้ายกับอักขระ char และด้วยเหตุนี้จึงเก็บค่าอักขระไว้ด้วย

ขนาดของตัวแปรที่กล่าวถึงข้างต้นอาจแตกต่างกันไปขึ้นอยู่กับการใช้งานโปรแกรมหรือคอมไพเลอร์

ตัวอย่าง:

มาเขียนโค้ดอย่างง่ายใน C ++ ที่จะให้ขนาดที่แน่นอนของประเภทข้อมูลบางประเภทที่อธิบายไว้ข้างต้น:

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

เอาต์พุตได้รับเป็นไบต์ดังแสดงในรูป:

ตัวอย่าง:

ที่นี่เราจะเพิ่มขนาดของข้อมูลสองประเภทที่แตกต่างกัน

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

มีอีกคำหนึ่งที่ต้องพูดถึงในที่นี้ก็คือ 'ตัวแก้ไขข้อมูล' . ชื่อนี้แนะนำว่า 'ตัวดัดแปลงข้อมูล' ถูกใช้ตามประเภทข้อมูลในตัวเพื่อปรับเปลี่ยนความยาวที่ข้อมูลบางประเภทสามารถรองรับได้ตามความต้องการหรือความต้องการของคอมไพเลอร์

ต่อไปนี้เป็นตัวดัดแปลงข้อมูลที่สามารถเข้าถึงได้ใน C++:

1. ลงนาม
2. ไม่ได้ลงนาม
3. ยาว
4. สั้น

ขนาดที่แก้ไขและช่วงที่เหมาะสมของชนิดข้อมูลในตัวจะถูกกล่าวถึงด้านล่างเมื่อรวมกับตัวดัดแปลงชนิดข้อมูล:

• Short int: มีขนาด 2 ไบต์ ปรับเปลี่ยนได้ตั้งแต่ -32,768 ถึง 32,767
• int สั้นที่ไม่ได้ลงนาม: มีขนาด 2 ไบต์ มีช่วงของการแก้ไขตั้งแต่ 0 ถึง 65,535
• Unsigned int: มีขนาด 4 ไบต์ มีช่วงการแก้ไขตั้งแต่ 0 ถึง 4,294,967,295
• Int: มีขนาด 4 ไบต์ มีช่วงการแก้ไขตั้งแต่ -2,147,483,648 ถึง 2,147,483,647
• Long int: มีขนาด 4 ไบต์ มีช่วงการแก้ไขตั้งแต่ -2,147,483,648 ถึง 2,147,483,647
• unsigned long int: มีขนาด 4 ไบต์ มีช่วงของการแก้ไขตั้งแต่ 0 ถึง 4,294,967.295
• Long long int: มีขนาด 8 ไบต์ มีช่วงการแก้ไขตั้งแต่ –(2^63) ถึง (2^63)-1
• unsigned long long int: มีขนาด 8 ไบต์ มีช่วงของการแก้ไขตั้งแต่ 0 ถึง 18,446,744,073,709,551,615
• ถ่านที่ลงนาม: มีขนาด 1 ไบต์ มีช่วงการแก้ไขตั้งแต่ -128 ถึง 127
• Unsigned char: มีขนาด 1 ไบต์ มีช่วงการแก้ไขตั้งแต่ 0 ถึง 255

การแจงนับ C ++:

ในภาษาการเขียนโปรแกรม C ++ 'การแจงนับ' เป็นประเภทข้อมูลที่กำหนดโดยผู้ใช้ การแจงนับถูกประกาศเป็น ' enum' ใน C++ ใช้เพื่อกำหนดชื่อเฉพาะให้กับค่าคงที่ใดๆ ที่ใช้ในโปรแกรม ปรับปรุงความสามารถในการอ่านและการใช้งานของโปรแกรม

ไวยากรณ์:

เราประกาศการแจงนับใน C ++ ดังนี้:

ข้อดีของการแจงนับใน C ++:

สามารถใช้ Enum ด้วยวิธีต่อไปนี้:

• สามารถใช้บ่อยในคำสั่ง switch case
• สามารถใช้ตัวสร้าง ฟิลด์ และวิธีการ
• มันสามารถขยายคลาส 'enum' เท่านั้น ไม่สามารถขยายคลาสอื่นได้
• สามารถเพิ่มเวลาในการรวบรวม
• สามารถข้ามไปได้

ข้อเสียของการแจงนับใน C ++:

Enum ยังมีข้อเสียเล็กน้อย:

หากระบุชื่อแล้วจะไม่สามารถใช้ได้อีกในขอบเขตเดียวกัน

ตัวอย่างเช่น:

Enum ไม่สามารถส่งต่อได้

ตัวอย่างเช่น:

พวกมันดูเหมือนชื่อ แต่เป็นจำนวนเต็ม ดังนั้นพวกเขาสามารถแปลงเป็นประเภทข้อมูลอื่น ๆ ได้โดยอัตโนมัติ

ตัวอย่างเช่น:

ตัวอย่าง:

ในตัวอย่างนี้ เราจะเห็นการใช้การแจงนับ C++:

ในการรันโค้ดนี้ ก่อนอื่น เราเริ่มต้นด้วย #include เป็นหนึ่งในไลบรารี่ที่หลากหลายใน C++ เป็นห้องสมุดในตัว มันเกี่ยวข้องกับกระแสข้อมูลอินพุตและเอาต์พุต . หลังจากนี้ เราใช้เนมสเปซมาตรฐาน จากนั้น เราจึงประกาศชื่อเฉพาะ 'enum' เป็นหัวเรื่อง และมอบหมายสามวิชา ได้แก่ คณิตศาสตร์ ภาษาอังกฤษ และภาษาอูรดู คณิตศาสตร์ถูกกำหนดเป็นค่า 1 เป้าหมายของเราคือการพิมพ์ค่าของ Subject ที่ประกาศเป็น enum จากนั้นเราเรียกใช้ หลัก() การทำงาน. ใน หลัก() เรามี cout<< โดยที่ 'c' หมายถึง 'ตัวละคร' และ out หมายถึง 'เอาต์พุต' 'Cout' ใช้เพื่อแสดงเอาต์พุต . << หมายถึงตัวดำเนินการแทรก โดยใช้ 'cout<<' เราพิมพ์ค่า enum ต่อไป เราจะใช้คำสั่ง 'return 0' คำสั่งนี้ส่งคืนผลลัพธ์ซึ่งอยู่ในรูปของค่า

นี่คือผลลัพธ์ของโปรแกรมที่ดำเนินการ:

ดังที่คุณเห็นว่าเรามีค่าของ Subject: Math, Urdu, English; นั่นคือ 1,2,3

ตัวอย่าง:

นี่เป็นอีกตัวอย่างหนึ่งที่เราเข้าใจแนวคิดของเราเกี่ยวกับ enum:

ในโปรแกรมนี้ เราเริ่มต้นด้วยการรวมไฟล์ส่วนหัว เป็นห้องสมุดในตัว มันเกี่ยวข้องกับกระแสข้อมูลอินพุตและเอาต์พุต หลังจากนี้ เราต้องใช้เนมสเปซมาตรฐาน จากนั้นเรากำหนดค่า enum ให้กับค่าคงที่ที่เป็นผู้เล่น เป้าหมายของเราคือแสดงให้เห็นว่าใครอยู่เหนือมัน ต่อไปเรียกเราว่า หลัก() การทำงาน. ใน หลัก() ฟังก์ชั่นที่เรากำหนดค่าคงที่สองค่า: Shadab ซึ่งมีค่าเท่ากับ 20 ให้กับตัวแปร 'bowler1' enum; และ Afridi ซึ่งมีค่าเท่ากับ 25 ให้กับตัวแปร enum 'bowler2'

เราต้องใช้คำสั่ง if-else . เรายังใช้ตัวดำเนินการเปรียบเทียบในคำสั่ง 'if' ซึ่งหมายความว่าเรากำลังเปรียบเทียบว่า 'bowler2' มากกว่า 'bowler1' จากนั้นบล็อก 'if' จะทำงานซึ่งหมายความว่าเป็นการสิ้นสุดของ Afridi จากนั้นเราป้อน 'cout<<' เพื่อแสดงผลลัพธ์ ขั้นแรก เราพิมพ์ข้อความว่า 'It is over of' แล้วค่าของ 'bowler2' ถ้าไม่เช่นนั้น บล็อก else จะถูกเรียกใช้ ซึ่งหมายความว่าเป็นการสิ้นสุดของ Shadab จากนั้นโดยใช้คำสั่ง 'cout<<' เราจะแสดงข้อความว่า 'It is over of' แล้วค่าของ 'bowler1'

ตามคำสั่ง if-else เรามีมากกว่า 25 ซึ่งเป็นค่าของ Afridi หมายความว่าค่าของตัวแปร enum 'bowler2' มากกว่า 'bowler1' นั่นคือสาเหตุที่คำสั่ง 'if' ถูกดำเนินการ

C++ หากเป็นอย่างอื่น ให้เปลี่ยน:

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

คำสั่ง 'if':

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

นี่คือคำสั่ง 'if' ง่ายๆ ที่ใช้ โดยเราจะเริ่มต้นตัวแปร 'int' เป็น 10 จากนั้น ค่าจะถูกดึงมาจากผู้ใช้ และจะถูกตรวจสอบข้ามในคำสั่ง 'if' หากเป็นไปตามเงื่อนไขที่ใช้ในคำสั่ง 'if' ผลลัพธ์จะปรากฏขึ้น

เนื่องจากตัวเลขที่เลือกคือ 40 ผลลัพธ์คือข้อความ

คำสั่ง 'if-else':

ในโปรแกรมที่ซับซ้อนมากขึ้นซึ่งคำสั่ง 'if' มักจะไม่ให้ความร่วมมือ เราใช้คำสั่ง 'if-else' ในกรณีที่กำหนด เราใช้คำสั่ง 'if- else' เพื่อตรวจสอบเงื่อนไขที่ใช้

ขั้นแรก เราจะประกาศตัวแปรของประเภทข้อมูล 'int' ชื่อ 'x' ซึ่งค่าที่ได้มาจากผู้ใช้ ตอนนี้ คำสั่ง 'if' ถูกใช้ในกรณีที่เราใช้เงื่อนไขว่าถ้าค่าจำนวนเต็มที่ป้อนโดยผู้ใช้คือ 2 ผลลัพธ์จะเป็นค่าที่ต้องการและข้อความ 'NICE TRY' แบบง่ายจะปรากฏขึ้น มิฉะนั้น หากตัวเลขที่ป้อนไม่ใช่ 2 ผลลัพธ์จะแตกต่างออกไป

เมื่อผู้ใช้เขียนหมายเลข 2 ผลลัพธ์ต่อไปนี้จะปรากฏขึ้น

เมื่อผู้ใช้เขียนตัวเลขอื่นๆ ยกเว้น 2 ผลลัพธ์ที่ได้คือ:

คำสั่ง if-else-if:

คำสั่ง if-else-if ที่ซ้อนกันค่อนข้างซับซ้อนและถูกใช้เมื่อมีหลายเงื่อนไขที่ใช้ในโค้ดเดียวกัน มาไตร่ตรองเรื่องนี้โดยใช้ตัวอย่างอื่น:

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

ที่นี่ ผู้ใช้เลือกค่า 195 นี่คือเหตุผลที่ผลลัพธ์แสดงว่านี่คือค่าที่แท้จริงของ 'm'

คำสั่งเปลี่ยน:

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

คำหลัก 'ตัวแบ่ง':

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

ในบรรทัดแรกของโค้ดที่แชร์ เราจะรวมไลบรารี่ด้วย หลังจากนั้น เรากำลังเพิ่ม 'เนมสเปซ' เราเรียกใช้ หลัก() การทำงาน. จากนั้นเราจะประกาศเกรดประเภทข้อมูลของตัวละครเป็น 'F' เกรดนี้อาจเป็นความปรารถนาของคุณและผลลัพธ์จะแสดงตามลำดับสำหรับกรณีที่เลือก เราใช้คำสั่ง switch เพื่อให้ได้ผลลัพธ์

ถ้าเราเลือกเกรด 'F' ผลลัพธ์จะเป็น 'โชคดีในครั้งต่อไป' เพราะนี่คือข้อความที่เราต้องการพิมพ์ในกรณีที่เกรดเป็น 'F'

มาเปลี่ยนเกรดเป็น X แล้วดูว่าเกิดอะไรขึ้น ฉันเขียน 'X' เป็นเกรดและผลลัพธ์ที่ได้รับแสดงอยู่ด้านล่าง:

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

คำสั่ง if-else และ switch มีคุณสมบัติทั่วไปบางประการ:

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

คำสั่ง if-else และ switch ต่างกันในบางวิธี:

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

C ++ ลูป:

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

ประเภทของลูป:

ลูปมีสามประเภท:

• สำหรับลูป
• ในขณะที่ลูป
• ทำในขณะที่ห่วง

สำหรับลูป:

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

ไวยากรณ์ของการดำเนินการวนรอบ 'for':

ตัวอย่าง:

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

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

ตัวอย่างโปรแกรม C++ เพื่อตรวจสอบลูป 'For':

ตัวอย่าง:

ตัวอย่างนี้แสดงการพิมพ์ค่าจำนวนเต็มตั้งแต่ 0 ถึง 10

ในสถานการณ์สมมตินี้ เราควรพิมพ์จำนวนเต็มตั้งแต่ 0 ถึง 10 ขั้นแรก เราเริ่มต้นตัวแปรสุ่ม i โดยมีค่าเป็น '0' จากนั้นพารามิเตอร์เงื่อนไขที่เราใช้แล้วจะตรวจสอบเงื่อนไขว่า i<=10 และเมื่อมันเป็นไปตามเงื่อนไขและเป็นจริง การดำเนินการวนรอบ 'for' จะเริ่มต้นขึ้น หลังจากการดำเนินการ ระหว่างพารามิเตอร์การเพิ่มหรือลดสองพารามิเตอร์ พารามิเตอร์หนึ่งจะถูกดำเนินการ และจนกว่าเงื่อนไขที่ระบุ i<=10 จะกลายเป็นเท็จ ค่าของตัวแปร i จะเพิ่มขึ้น

จำนวนการวนซ้ำโดยมีเงื่อนไข i<10:

ตัวอย่าง:

อินสแตนซ์ต่อไปนี้แสดงค่าของจำนวนเต็ม:

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

จำนวนการทำซ้ำ:

ในขณะที่วนซ้ำ:

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

ในบรรทัดแรก เรารวมไฟล์ส่วนหัว และเนมสเปซมาตรฐาน เราเรียก หลัก() การทำงาน. ที่นี่เราเริ่มต้นตัวแปร 'a' ในบรรทัดถัดไป เราใช้เงื่อนไข while ภายในเงื่อนไข while เราใช้คำสั่ง 'cout' เพื่อแสดงค่าที่เขียน จากนั้น เราใช้ตัวดำเนินการเพิ่มเพื่อเพิ่มจำนวน ในบรรทัดสุดท้าย เราใช้คำสั่ง 'return 0' เพื่อสิ้นสุดโปรแกรม

ทำในขณะที่วนซ้ำ:

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

ที่นี่ เรารวมไฟล์ส่วนหัว เราใช้ หลัก() ฟังก์ชันในโปรแกรม จากนั้น เราเริ่มต้นจำนวนเต็มสี่จำนวนและใช้คำสั่ง 'cin' เพื่อให้ผู้ใช้สามารถป้อนค่าได้ ในบรรทัดถัดไป เราเริ่มต้นจำนวนเต็มสองจำนวนที่ต่างกัน เราใช้คำสั่ง 'do' ภายในคำสั่งเราใช้ฟังก์ชันเลขคณิตสองฟังก์ชัน อันดับแรก เราใช้ตัวดำเนินการการคูณ และประการที่สอง เราใช้ตัวดำเนินการการบวก จากนั้น เราใช้เงื่อนไข 'while' ในโปรแกรมนอกคำสั่ง 'do' นอกจากนี้เรายังเพิ่มคำสั่ง 'cout' เพื่อพิมพ์ผลลัพธ์ผ่านจำนวนเต็ม 'result' ในบรรทัดสุดท้าย ในการปิดโปรแกรม เราใช้คำสั่ง return 0

C++ ดำเนินการต่อ/หยุด:

C ++ ต่อคำชี้แจง:

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

ด้วยลูป:

ในตัวอย่างนี้ เราใช้ 'for loop' กับคำสั่ง continue จาก C++ เพื่อให้ได้ผลลัพธ์ที่ต้องการในขณะที่ผ่านข้อกำหนดที่ระบุบางอย่าง

เราเริ่มต้นด้วยการรวมไลบรารี และใช้ 'namespace std' จากนั้นเราจะเรียก หลัก() การทำงาน. เราใช้สำหรับการวนซ้ำ Inside for loop เราประกาศตัวแปร 'k' ที่ถือว่าอยู่ระหว่าง 3 ถึง 8 เราใช้เงื่อนไขเพื่อดำเนินการวนซ้ำแม้ว่า (k = = 5) จากนั้นใช้คำสั่ง 'ดำเนินการต่อ' หลังจากระบุเงื่อนไขแล้ว ในตอนท้าย เพื่อแสดงผลลัพธ์ เราใช้คำสั่ง 'cout' ร่วมกับคำสั่ง 'return 0'

ด้วยวงในขณะที่:

ตลอดการสาธิตนี้ เราใช้ทั้งคำสั่ง 'while loop' และ 'continue' ของ C++ รวมถึงเงื่อนไขบางประการเพื่อดูว่ามีการสร้างเอาต์พุตประเภทใด

ในตัวอย่างนี้ เราตั้งเงื่อนไขให้เพิ่มตัวเลขเป็น 40 เท่านั้น หากจำนวนเต็มที่ป้อนเป็นจำนวนลบ การวนซ้ำ 'while' จะถูกยกเลิก ในทางกลับกัน หากตัวเลขมากกว่า 40 จำนวนนั้นจะถูกข้ามจากการวนซ้ำ

เราจะรวมไลบรารี โดยใช้ 'namespace std' แล้วเรียก หลัก() การทำงาน. เราเริ่มต้นตัวแปร 's' 'ตัวเลข' ตัวแปรอื่นจะถูกประกาศในขั้นตอนต่อไป เราใช้ลูป 'while' ตอนนี้เราระบุเงื่อนไขว่าค่าที่ต้องการจะสูงกว่าหรือเท่ากับศูนย์ ในการเพิ่มจำนวนบวกทั้งหมด เราใช้คำสั่ง 's += number' คำสั่ง 'cout' จะถูกนำมาใช้เพื่อแสดงข้อความบนคอนโซล 'Enter any number' เราได้รับจำนวนเต็มจากผู้ใช้โดยใช้คำสั่ง 'cin' เรายังใช้คำสั่ง 'if' เมื่อใดก็ตามที่จำนวนที่กำหนดไว้มากกว่า 40 ข้อความจะปรากฏขึ้น จากนั้นเราใช้คำสั่ง 'ดำเนินการต่อ' หลังจากขั้นตอนเหล่านี้ทั้งหมด คำสั่ง 'ดำเนินการต่อ' จะถูกดำเนินการ เพื่อแสดงผลรวมของตัวเลขทั้งหมด เราใช้คำสั่ง 'cout'

คำสั่งแบ่ง C ++:

เมื่อใดก็ตามที่คำสั่ง break ถูกใช้ในลูปใน C ++ การวนซ้ำจะสิ้นสุดลงทันทีและการควบคุมโปรแกรมจะรีสตาร์ทที่คำสั่งหลังจากลูป นอกจากนี้ยังสามารถยุติกรณีและปัญหาภายในคำสั่ง 'เปลี่ยน'

ด้วยลูป:

ในที่นี้ เราจะใช้ลูป 'for' กับคำสั่ง 'break' เพื่อสังเกตผลลัพธ์โดยการวนซ้ำค่าต่างๆ

ขั้นแรก เรารวมไฟล์ส่วนหัว ต่อไป เราใช้ 'namespace std' หลังจากเรียกใช้ฟังก์ชัน main() เราก็ใช้สำหรับการวนซ้ำ ที่นี่ เราจะเริ่มต้นตัวแปร 'm' เราจะใช้เงื่อนไขที่ค่าของ 'm' อยู่ระหว่าง 10 ถึง 20 เงื่อนไข 'break' จะถูกดำเนินการราวกับว่า (m == 17) ในการพิมพ์ผลลัพธ์ เราใช้ 'cout' จากนั้นจะใช้คำสั่ง 'return 0'

ด้วยวงในขณะที่:

เราจะใช้ลูป 'while' ร่วมกับคำสั่ง break

เราเริ่มต้นด้วยการนำเข้าไลบรารี 'namespace std' จะรวมอยู่ด้วย ภายในเมธอด main() ตัวแปรสองตัวแปร 'nbr' และ 'x' จะเริ่มต้นขึ้น เราใช้ลูป 'while' และส่งผ่าน 'true' เป็นอาร์กิวเมนต์ เพื่อให้ได้คุณค่าจากผู้ใช้ เราใช้คำสั่ง 'cin' ต่อไปเราใช้คำสั่ง 'if' นอกจากนี้ เงื่อนไข 'break' ยังใช้เพื่อระบุเงื่อนไข if (nbr < 0) ในการเพิ่มค่าบวกทั้งหมด เราใช้สูตร 'x += nbr' เพื่อแสดงผลรวมนี้ เราได้เพิ่มคำสั่ง 'cout'

ฟังก์ชัน C++:

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

การสร้างฟังก์ชัน:

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

ไวยากรณ์:

โมฆะเป็นประเภทส่งคืนของฟังก์ชัน ชื่อแรงงานคือชื่อที่กำหนดและวงเล็บปีกกาจะล้อมรอบเนื้อหาของฟังก์ชันที่เราเพิ่มรหัสสำหรับการดำเนินการ

เรียกใช้ฟังก์ชัน:

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

ตัวอย่าง:

มาประกาศและสร้างฟังก์ชันที่ผู้ใช้กำหนดในสถานการณ์นี้กันเถอะ

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

นี่เป็นข้อความธรรมดาที่กำหนดไว้ในฟังก์ชันที่ผู้ใช้กำหนดเองซึ่งแสดงไว้ที่นี่โดยใช้คำสั่ง หลัก() การทำงาน.

เป็นโมฆะ:

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

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

พารามิเตอร์จริง:

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

ตัวอย่าง:

ในตัวอย่างนี้ เรากำลังจะเปลี่ยนหรือแทนที่ค่าจำนวนเต็มสองค่าผ่านฟังก์ชัน

ในตอนเริ่มต้น เราจะใช้ไฟล์ส่วนหัว ฟังก์ชันที่ผู้ใช้กำหนดคือการประกาศและกำหนดชื่อ ย่อย (). ฟังก์ชันนี้ใช้สำหรับการแทนที่ค่าจำนวนเต็มสองค่าที่เป็น i และ n ถัดไป ตัวดำเนินการเลขคณิตใช้สำหรับการแลกเปลี่ยนจำนวนเต็มสองตัวนี้ ค่าของจำนวนเต็มแรก 'i' จะถูกเก็บไว้แทนค่า 'n' และค่าของ n จะถูกบันทึกแทนค่าของ 'i' จากนั้น ผลลัพธ์หลังจากเปลี่ยนค่าจะถูกพิมพ์ ถ้าเราพูดถึง หลัก() เรากำลังนำค่าของจำนวนเต็มสองตัวจากผู้ใช้มาแสดง ในขั้นตอนสุดท้าย ฟังก์ชันที่ผู้ใช้กำหนด ย่อย () ถูกเรียกและเปลี่ยนค่าทั้งสอง

ในกรณีแทนเลขสองตัวนี้ เราจะเห็นได้ชัดเจนว่าในขณะที่ใช้ตัว ย่อย () ฟังก์ชัน ค่าของ 'i' และ 'n' ในรายการพารามิเตอร์เป็นพารามิเตอร์ที่เป็นทางการ พารามิเตอร์จริงคือพารามิเตอร์ที่ส่งผ่านที่ส่วนท้ายของ หลัก() ฟังก์ชันที่มีการเรียกฟังก์ชันการแทนที่

ตัวชี้ C++:

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

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

โดยปกติ ตัวดำเนินการ '&' (เครื่องหมายและ) จะใช้เพื่อเข้าถึงที่อยู่ของวัตถุใดๆ ในหน่วยความจำ

พอยน์เตอร์และประเภท:

ตัวชี้มีหลายประเภทดังต่อไปนี้:

• ตัวชี้ค่าว่าง: สิ่งเหล่านี้คือพอยน์เตอร์ที่มีค่าศูนย์ที่เก็บไว้ในไลบรารี C++
• ตัวชี้เลขคณิต: ประกอบด้วยตัวดำเนินการเลขคณิตหลักสี่ตัวที่สามารถเข้าถึงได้ ได้แก่ ++, –, +, -
• อาร์เรย์ของพอยน์เตอร์: เป็นอาร์เรย์ที่ใช้เก็บพอยน์เตอร์บางตัว
• ตัวชี้ไปยังตัวชี้: เป็นที่ที่ใช้ตัวชี้อยู่เหนือตัวชี้

ตัวอย่าง:

ไตร่ตรองถึงตัวอย่างที่ตามมาซึ่งพิมพ์แอดเดรสของตัวแปรสองสามตัว

หลังจากรวมไฟล์ส่วนหัวและเนมสเปซมาตรฐานแล้ว เรากำลังเริ่มต้นตัวแปรสองตัว หนึ่งคือค่าจำนวนเต็มที่แสดงโดย i' และอีกค่าหนึ่งคืออาร์เรย์ประเภทอักขระ 'I' ที่มีขนาด 10 อักขระ ที่อยู่ของตัวแปรทั้งสองจะแสดงโดยใช้คำสั่ง 'cout'

ผลลัพธ์ที่เราได้รับแสดงไว้ด้านล่าง:

ผลลัพธ์นี้แสดงที่อยู่ของตัวแปรทั้งสอง

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

การประกาศตัวชี้:

ตัวชี้ถูกประกาศในลักษณะนี้:

ชนิดพื้นฐานของตัวชี้จะแสดงด้วย 'ประเภท' ในขณะที่ชื่อตัวชี้จะแสดงด้วย 'var-name' และเพื่อให้สิทธิ์ตัวแปรใช้เครื่องหมายดอกจัน (*) ของตัวชี้

วิธีการกำหนดพอยน์เตอร์ให้กับตัวแปร:

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

ตัวอย่าง:

ตัวอย่างต่อไปนี้จะแสดงให้เห็นว่าพอยน์เตอร์แทนที่ตัวดำเนินการ '&' และจัดเก็บที่อยู่ของตัวแปรอย่างไร

เราจะรวมการสนับสนุนไลบรารีและไดเร็กทอรี จากนั้นเราจะเรียกใช้ หลัก() ฟังก์ชั่นที่เราประกาศและเริ่มต้นตัวแปร 'n' ของประเภท 'int' ด้วยค่า 55 ในบรรทัดถัดไป เราจะเริ่มต้นตัวแปรตัวชี้ที่ชื่อ 'p1' หลังจากนี้ เรากำหนดที่อยู่ของตัวแปร 'n' ให้กับตัวชี้ 'p1' จากนั้นเราแสดงค่าของตัวแปร 'n' ที่อยู่ของ 'n' ที่เก็บไว้ในตัวชี้ 'p1' จะปรากฏขึ้น หลังจากนั้น ค่าของ '*p1' จะถูกพิมพ์บนหน้าจอโดยใช้คำสั่ง 'cout' ผลลัพธ์จะเป็นดังนี้:

ที่นี่เราจะเห็นว่าค่าของ 'n' คือ 55 และที่อยู่ของ 'n' ที่เก็บไว้ในตัวชี้ 'p1' จะแสดงเป็น 0x6ffe14 พบค่าของตัวแปรพอยน์เตอร์และมีค่าเท่ากับ 55 ซึ่งเท่ากับค่าของตัวแปรจำนวนเต็ม ดังนั้น ตัวชี้จะเก็บที่อยู่ของตัวแปร และตัวชี้ * ก็มีค่าของจำนวนเต็มที่จัดเก็บไว้ซึ่งจะส่งผลให้คืนค่าของตัวแปรที่จัดเก็บไว้ตั้งแต่แรก

ตัวอย่าง:

ลองพิจารณาอีกตัวอย่างหนึ่งที่เราใช้ตัวชี้ที่เก็บที่อยู่ของสตริง

ในโค้ดนี้ เรากำลังเพิ่มไลบรารีและเนมสเปซก่อน ใน หลัก() ฟังก์ชั่นเราต้องประกาศสตริงชื่อ 'makeup' ที่มีค่า 'Mascara' อยู่ในนั้น ตัวชี้ประเภทสตริง '*p2' ใช้เพื่อจัดเก็บที่อยู่ของตัวแปรแต่งหน้า ค่าของตัวแปร 'makeup' จะแสดงบนหน้าจอโดยใช้คำสั่ง 'cout' หลังจากนี้ ที่อยู่ของตัวแปร 'makeup' จะถูกพิมพ์ และในท้ายที่สุด ตัวแปรตัวชี้ 'p2' จะแสดงที่อยู่หน่วยความจำของตัวแปร 'makeup' พร้อมตัวชี้

ผลลัพธ์ที่ได้รับจากโค้ดด้านบนจะเป็นดังนี้:

บรรทัดแรกมีค่าของตัวแปร 'แต่งหน้า' ที่แสดงอยู่ บรรทัดที่สองแสดงที่อยู่ของตัวแปร 'การแต่งหน้า' ในบรรทัดสุดท้าย ที่อยู่หน่วยความจำของตัวแปร 'makeup' พร้อมการใช้ตัวชี้จะแสดงขึ้น

การจัดการหน่วยความจำ C++:

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

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

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

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

ตัวดำเนินการ C ++ ใหม่:

ตัวดำเนินการใหม่มีหน้าที่ในการจัดสรรหน่วยความจำและใช้งานดังนี้:

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

หน่วยความจำได้รับการจัดสรรให้กับตัวแปร 'int' สำเร็จด้วยการใช้ตัวชี้

ตัวดำเนินการลบ C ++:

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

ตัวอย่างที่เรากำลังจะทบทวนในตอนนี้คือการรวมโอเปอเรเตอร์ทั้งสองไว้ด้วย

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

การใช้อาร์เรย์สำหรับการจัดสรรหน่วยความจำ:

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

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

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

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

ข้อดี:

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

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

อาร์เรย์ C++:

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

ประกาศอาร์เรย์:

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

ตัวอย่างเช่น:

ตัวแปรนี้ได้รับการประกาศโดยแสดงว่ามีห้าสตริงในอาร์เรย์ชื่อ 'makeup' ในการระบุและแสดงค่าสำหรับอาร์เรย์นี้ เราจำเป็นต้องใช้วงเล็บปีกกา โดยแต่ละองค์ประกอบจะอยู่ในเครื่องหมายจุลภาคกลับด้านแยกกัน โดยแต่ละองค์ประกอบคั่นด้วยเครื่องหมายจุลภาคเพียงอันเดียว

ตัวอย่างเช่น:

ในทำนองเดียวกัน หากคุณรู้สึกอยากสร้างอาร์เรย์อื่นที่มีประเภทข้อมูลอื่นที่ควรจะเป็น 'int' ขั้นตอนก็จะเหมือนเดิม คุณเพียงแค่ต้องเปลี่ยนประเภทข้อมูลของตัวแปรดังที่แสดงด้านล่าง:

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

เข้าถึงองค์ประกอบในอาร์เรย์ได้อย่างไร?

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

ตัวอย่าง:

พิจารณาตัวอย่างพื้นฐานและง่ายมากที่เราจะเริ่มต้นตัวแปรในอาร์เรย์

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

นี่คือผลลัพธ์ที่ได้รับจากโค้ดด้านบน คำหลัก 'endl' จะย้ายรายการอื่นไปยังบรรทัดถัดไปโดยอัตโนมัติ

ตัวอย่าง:

ในโค้ดนี้ เราใช้ลูป 'for' เพื่อพิมพ์รายการของอาร์เรย์

ในกรณีข้างต้น เรากำลังเพิ่มไลบรารีที่จำเป็น กำลังเพิ่มเนมสเปซมาตรฐาน ดิ หลัก() ฟังก์ชั่นคือฟังก์ชันที่เราจะใช้งานฟังก์ชันทั้งหมดสำหรับการทำงานของโปรแกรมเฉพาะ ต่อไป เราจะประกาศอาร์เรย์ประเภท int ชื่อ 'Num' ซึ่งมีขนาด 10 ค่าของตัวแปรทั้งสิบนี้นำมาจากผู้ใช้โดยใช้ลูป 'for' สำหรับการแสดงอาร์เรย์นี้ จะใช้ลูป 'for' อีกครั้ง จำนวนเต็ม 10 ตัวที่เก็บไว้ในอาร์เรย์จะแสดงโดยใช้คำสั่ง 'cout'

นี่คือผลลัพธ์ที่เราได้รับจากการเรียกใช้โค้ดด้านบน โดยแสดงจำนวนเต็ม 10 ตัวที่มีค่าต่างกัน

ตัวอย่าง:

ในสถานการณ์นี้ เรากำลังจะหาคะแนนเฉลี่ยของนักเรียนคนหนึ่งและเปอร์เซ็นต์ที่เขาได้รับในชั้นเรียน

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

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

ข้อดีของการใช้อาร์เรย์:

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

ข้อเสียของการใช้อาร์เรย์:

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

วัตถุ C ++ และคลาส:

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

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

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

กำหนดคลาส:

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

ประกาศวัตถุ:

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

การเข้าถึงข้อมูลสมาชิก:

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

ตัวอย่าง:

ในตัวอย่างนี้ เราจะกำหนดฟังก์ชันบางอย่างและเข้าถึงฟังก์ชันคลาสและสมาชิกข้อมูลด้วยความช่วยเหลือของออบเจ็กต์

ในขั้นตอนแรก เรากำลังรวมไลบรารี หลังจากนั้นเราจำเป็นต้องรวมไดเร็กทอรีสนับสนุน คลาสถูกกำหนดไว้อย่างชัดเจนก่อนที่จะเรียก หลัก() การทำงาน. คลาสนี้เรียกว่า 'ยานพาหนะ' สมาชิกของข้อมูลคือ 'ชื่อของยานพาหนะและ 'id' ของยานพาหนะนั้น ซึ่งเป็นหมายเลขทะเบียนสำหรับยานพาหนะนั้นที่มีสตริง และประเภทข้อมูล int ตามลำดับ มีการประกาศฟังก์ชันทั้งสองสำหรับสมาชิกข้อมูลทั้งสองนี้ ดิ รหัส () ฟังก์ชั่นแสดง id ของรถ เนื่องจากข้อมูลของสมาชิกของชั้นเรียนเป็นแบบสาธารณะ เราจึงสามารถเข้าถึงข้อมูลเหล่านี้นอกชั้นเรียนได้ ดังนั้นเราจึงเรียก ชื่อ() ทำงานนอกชั้นเรียนแล้วนำค่าสำหรับ 'VehicleName' จากผู้ใช้และพิมพ์ในขั้นตอนต่อไป ใน หลัก() เรากำลังประกาศอ็อบเจ็กต์ของคลาสที่ต้องการซึ่งจะช่วยในการเข้าถึงข้อมูลสมาชิกและฟังก์ชันจากคลาส นอกจากนี้ เรากำลังเริ่มต้นค่าสำหรับชื่อรถและรหัส เฉพาะในกรณีที่ผู้ใช้ไม่ได้ระบุค่าของชื่อรถ

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

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

ตัวสร้าง C++ และตัวทำลาย:

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

ตัวสร้าง:

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

ไวยากรณ์:

ประเภทของตัวสร้าง:

ตัวสร้างพารามิเตอร์:

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

ตัวอย่าง:

ในกรณีนี้ เราจะสร้างคอนสตรัคเตอร์ของคลาสและประกาศพารามิเตอร์

เรากำลังรวมไฟล์ส่วนหัวไว้ในขั้นตอนแรก ขั้นตอนต่อไปของการใช้เนมสเปซคือการสนับสนุนไดเร็กทอรีของโปรแกรม คลาสชื่อ 'digits' ถูกประกาศในตอนแรก ตัวแปรจะถูกเตรียมใช้งานแบบสาธารณะเพื่อให้สามารถเข้าถึงได้ตลอดทั้งโปรแกรม มีการประกาศตัวแปรชื่อ 'dig1' ด้วยจำนวนเต็มของประเภทข้อมูล ต่อไป เราได้ประกาศตัวสร้างที่มีชื่อคล้ายกับชื่อของคลาส ตัวสร้างนี้มีตัวแปรจำนวนเต็มส่งผ่านเป็น 'n' และตัวแปรคลาส 'dig1' ถูกตั้งค่าเท่ากับ n ใน หลัก() ฟังก์ชันของโปรแกรม สามอ็อบเจ็กต์สำหรับ 'ตัวเลข' ของคลาสจะถูกสร้างขึ้นและกำหนดค่าสุ่มบางส่วน จากนั้นวัตถุเหล่านี้จะใช้เพื่อเรียกตัวแปรคลาสที่กำหนดด้วยค่าเดียวกันโดยอัตโนมัติ

ค่าจำนวนเต็มจะแสดงบนหน้าจอเป็นเอาต์พุต

คัดลอกตัวสร้าง:

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

ตัวอย่าง:

ในกรณีนี้ ตัวสร้างการคัดลอกจะถูกประกาศ

ขั้นแรก เรากำลังผสานรวมไลบรารีและไดเร็กทอรี มีการประกาศคลาสชื่อ 'ใหม่' โดยที่จำนวนเต็มเริ่มต้นเป็น 'e' และ 'o' ตัวสร้างถูกเปิดเผยต่อสาธารณะโดยที่ตัวแปรทั้งสองถูกกำหนดค่าและตัวแปรเหล่านี้ถูกประกาศในคลาส จากนั้น ค่าเหล่านี้จะแสดงด้วยความช่วยเหลือของ หลัก() ทำงานโดยมี 'int' เป็นประเภทส่งคืน ดิ แสดง() ฟังก์ชันจะถูกเรียกและกำหนดหลังจากนั้นโดยที่ตัวเลขจะปรากฏบนหน้าจอ ข้างใน หลัก() ฟังก์ชั่น อ็อบเจ็กต์ถูกสร้างขึ้นและอ็อบเจ็กต์ที่กำหนดเหล่านี้จะถูกเริ่มต้นด้วยค่าสุ่ม จากนั้น แสดง() มีการใช้วิธีการ

ผลลัพธ์ที่ได้รับจากการใช้ตัวสร้างการคัดลอกแสดงไว้ด้านล่าง

เรือพิฆาต:

ตามชื่อที่กำหนด destructors ถูกใช้เพื่อทำลายวัตถุที่สร้างขึ้นโดยตัวสร้าง เมื่อเปรียบเทียบกับคอนสตรัคเตอร์ ตัวทำลายล้างมีชื่อเหมือนกันกับคลาส แต่มีเครื่องหมายตัวหนอนเพิ่มเติม (~) ตามมา

ไวยากรณ์:

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

ตัวอย่าง:

ในสถานการณ์นี้ เรากำลังใช้ตัวทำลายล้างเพื่อลบวัตถุ

นี่คือคลาส 'รองเท้า' คอนสตรัคเตอร์ถูกสร้างขึ้นซึ่งมีชื่อคล้ายกับคลาส ในคอนสตรัคเตอร์ ข้อความจะแสดงขึ้นเมื่อสร้างอ็อบเจ็กต์ หลังจากตัวสร้าง ตัวทำลายถูกสร้างขึ้นซึ่งกำลังลบวัตถุที่สร้างด้วยตัวสร้าง ใน หลัก() ฟังก์ชั่นวัตถุตัวชี้ถูกสร้างขึ้นชื่อ 's' และคำหลัก 'ลบ' ใช้เพื่อลบวัตถุนี้

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

ความแตกต่างระหว่างตัวสร้างและตัวทำลาย:

การสืบทอด C++:

ตอนนี้ เราจะมาเรียนรู้เกี่ยวกับ C++ Inheritance และขอบเขตของ C++

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

การสืบทอดหมายถึงความสัมพันธ์ (คือ a) เราเรียกความสัมพันธ์ใดๆ ว่ามรดก หากใช้ 'is-a' ระหว่างสองคลาส

ตัวอย่างเช่น:

• นกแก้วก็คือนก
• คอมพิวเตอร์คือเครื่องจักร

ไวยากรณ์:

ในการเขียนโปรแกรม C++ เราใช้หรือเขียน Inheritance ดังนี้

โหมดของการสืบทอด C ++:

การสืบทอดเกี่ยวข้องกับ 3 โหมดในการสืบทอดคลาส:

• สาธารณะ: ในโหมดนี้ ถ้าคลาสลูกถูกประกาศ สมาชิกของคลาสพาเรนต์จะถูกสืบทอดโดยคลาสย่อยเหมือนกับในคลาสพาเรนต์
• ป้องกัน: ฉัน ในโหมดนี้ สมาชิกสาธารณะของคลาสพาเรนต์จะกลายเป็นสมาชิกที่มีการป้องกันในคลาสย่อย
• ส่วนตัว : ในโหมดนี้ สมาชิกทั้งหมดของคลาสพาเรนต์จะกลายเป็นส่วนตัวในคลาสย่อย

ประเภทของมรดก C++:

ต่อไปนี้เป็นประเภทของมรดก C ++:

1. มรดกเดี่ยว:

ด้วยการสืบทอดประเภทนี้ คลาสที่มาจากคลาสพื้นฐานหนึ่งคลาส

ไวยากรณ์:

2. การสืบทอดหลายรายการ:

ในการสืบทอดประเภทนี้ คลาสอาจสืบเชื้อสายมาจากคลาสพื้นฐานที่แตกต่างกัน

ไวยากรณ์:

3. การสืบทอดหลายระดับ:

คลาสย่อยนั้นสืบเชื้อสายมาจากคลาสย่อยอื่นในรูปแบบการสืบทอดนี้

ไวยากรณ์:

4. การสืบทอดตามลำดับชั้น:

คลาสย่อยหลายคลาสถูกสร้างขึ้นจากคลาสฐานเดียวในวิธีการสืบทอดนี้

ไวยากรณ์:

5. มรดกไฮบริด:

ในการสืบทอดประเภทนี้ จะรวมการสืบทอดหลายรายการเข้าด้วยกัน

ไวยากรณ์:

ตัวอย่าง:

เราจะรันโค้ดเพื่อสาธิตแนวคิดของ Multiple Inheritance ในการเขียนโปรแกรม C++

เมื่อเราเริ่มต้นด้วยไลบรารีอินพุต-เอาท์พุตมาตรฐาน เราก็ได้ตั้งชื่อคลาสพื้นฐานว่า 'Bird' และทำให้เป็นสาธารณะเพื่อให้สามารถเข้าถึงสมาชิกของคลาสได้ จากนั้นเราก็มีคลาสพื้นฐาน 'สัตว์เลื้อยคลาน' และเราได้เผยแพร่สู่สาธารณะด้วย จากนั้นเรามี 'cout' เพื่อพิมพ์ผลลัพธ์ หลังจากนี้ เราได้สร้าง 'เพนกวิน' คลาสเด็ก ใน หลัก() ฟังก์ชั่นเราได้สร้างวัตถุของคลาสเพนกวิน 'p1' ขั้นแรกคลาส 'Bird' จะดำเนินการแล้วตามด้วยคลาส 'Reptile'

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

ตัวอย่าง:

ที่นี่ เราจะรันโปรแกรมเพื่อแสดงวิธีใช้ Multilevel Inheritance

เราเริ่มต้นโปรแกรมของเราโดยใช้สตรีมอินพุต-เอาต์พุต จากนั้นเราได้ประกาศคลาสพาเรนต์ 'M' ซึ่งกำหนดให้เป็นสาธารณะ เราได้เรียก แสดง() ฟังก์ชั่นและคำสั่ง 'cout' เพื่อแสดงคำสั่ง ต่อไป เราได้สร้างคลาสลูก 'N' ที่มาจากคลาสหลัก 'M' เรามีคลาสลูกใหม่ 'O' ที่ได้มาจากคลาสย่อย 'N' และเนื้อหาของคลาสที่ได้รับทั้งสองนั้นว่างเปล่า ในที่สุดเราก็เรียกใช้ หลัก() ฟังก์ชั่นที่เราต้องเริ่มต้นวัตถุของคลาส 'O' ดิ แสดง() หน้าที่ของวัตถุถูกใช้เพื่อแสดงผลลัพธ์

ในรูปนี้ เราได้ผลลัพธ์ของคลาส 'M' ซึ่งเป็นคลาสหลัก เพราะเรามี แสดง() ทำงานในนั้น ดังนั้นคลาส 'N' จึงมาจากคลาสพาเรนต์ 'M' และคลาส 'O' จากคลาสพาเรนต์ 'N' ซึ่งหมายถึงการสืบทอดหลายระดับ

C ++ ความแตกต่าง:

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

หมวดหมู่ของความหลากหลาย:

Polymorphism ส่วนใหญ่เกิดขึ้นในสองวิธี:

1. รวบรวมความแตกต่างของเวลา
2. Run Time Polymorphism

มาอธิบายกัน

6. รวบรวมความแตกต่างของเวลา:

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

• ฟังก์ชั่นโอเวอร์โหลด
• ผู้ประกอบการโอเวอร์โหลด

มาดูวิธีที่เราใช้ทั้งสองหมวดหมู่นี้กัน

7. ฟังก์ชั่นโอเวอร์โหลด:

หมายความว่าฟังก์ชันสามารถทำงานต่างๆ ได้ ฟังก์ชันนี้เรียกว่าโอเวอร์โหลดเมื่อมีหลายฟังก์ชันที่มีชื่อคล้ายกัน แต่มีอาร์กิวเมนต์ที่แตกต่างกัน

อันดับแรก เราใช้ไลบรารี เช่นเดียวกับเนมสเปซมาตรฐาน จากนั้นเราจะประกาศคลาสที่ผู้ใช้กำหนด 'เพิ่ม' ภายในคลาส เรากำหนดฟังก์ชัน ADD() โดยมีพารามิเตอร์สองตัวเป็นสาธารณะ อีกครั้ง ประกาศฟังก์ชันใหม่ภายในเนื้อหาของคลาสที่มีชื่อเดียวกัน แต่ฟังก์ชันนี้ไม่มีพารามิเตอร์ ที่นี่เราเริ่มต้นสามสตริง สองสตริงแรกมีค่าบางอย่างและสตริงสุดท้ายใช้เพื่อเชื่อมสองสตริงแรก เราใช้คำสั่ง 'cout' เพื่อพิมพ์ผลลัพธ์ ต่อไปเราเรียกว่า หลัก() วิธีการนอกชั้นเรียน เราสร้างวัตถุของคลาสที่ต้องการ 'เพิ่ม' ตอนนี้ เราเรียกฟังก์ชันแรกด้วยสองพารามิเตอร์ จากนั้นเรียกใช้ฟังก์ชันที่สองด้วย ในขั้นตอนสุดท้าย เรารวมคำสั่ง 'return 0' เพื่อสิ้นสุดโปรแกรม

ผู้ประกอบการโอเวอร์โหลด:

กระบวนการกำหนดฟังก์ชันการทำงานหลายอย่างของตัวดำเนินการเรียกว่าตัวดำเนินการโอเวอร์โหลด

ตัวอย่างข้างต้นรวมถึงไฟล์ส่วนหัว จากนั้น เราใช้เนมสเปซมาตรฐาน เรากำหนดคลาส 'จำนวนเต็ม' ภายในคลาสนี้ เราระบุจำนวนเต็มเป็นสมาชิกส่วนตัวของคลาส ต่อไป เราประกาศตัวสร้าง Parameterized เป็นสมาชิกสาธารณะและเริ่มต้นค่าของจำนวนเต็มในนั้น เรากำหนดคอนสตรัคเตอร์ด้วยโอเปอเรเตอร์คำนำหน้าโอเวอร์โหลด ภายใน Constructor นี้ เราทำการดำเนินการคำนำหน้า นอกจากนี้เรายังสร้างฟังก์ชันที่แสดงค่าที่เพิ่มขึ้นโดยใช้คำสั่ง 'cout' ในขณะเดียวกัน เราเรียก หลัก() การทำงาน. ที่นี่ เราสร้างวัตถุสองคลาส วัตถุแรกส่งผ่านค่าของจำนวนเต็ม จากนั้นใช้คำสั่ง 'cout' เพื่อพิมพ์บรรทัด 'ก่อนที่จะเพิ่มค่าเป็น' ต่อไปเราเรียกว่า แสดง() ฟังก์ชันสำหรับวัตถุแรก วัตถุที่สองใช้ตัวดำเนินการเพิ่มล่วงหน้า เราใช้คำสั่ง 'cout' เพื่อแสดงบรรทัด 'หลังจากเพิ่มค่าล่วงหน้าแล้ว ค่าคือ' จากนั้น เราใช้ แสดง() ฟังก์ชันสำหรับวัตถุที่สอง

8. รันไทม์พหุสัณฐาน:

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

การแทนที่ฟังก์ชัน:

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

ในบรรทัดแรก เรารวมไลบรารี เพื่อดำเนินการอินพุตและเอาต์พุต นอกจากนี้เรายังเพิ่มเนมสเปซมาตรฐาน ในบรรทัดถัดไป เราประกาศคลาสหลัก 'Man' ภายในคลาส เรากำหนดฟังก์ชันที่มีสองพารามิเตอร์เป็นสาธารณะ จากนั้นเราใช้คำสั่ง 'cout' เพื่อแสดงข้อความว่า 'เดิน' นอกคลาส เราสร้างคลาสลูก 'Animal' ที่มาจากคลาสพาเรนต์ ที่นี่ เราสร้างฟังก์ชันที่มีชื่อคล้ายกับที่เคยประกาศไว้ในคลาสหลัก จากนั้นใช้คำสั่ง 'cout' เพื่อแสดงข้อความ 'กำลังกิน' เราใช้ หลัก() การทำงาน. ในขณะเดียวกัน เราสร้างคลาสอ็อบเจ็กต์ 'm' จากนั้น เราเรียกฟังก์ชันของคลาสหลักและฟังก์ชันของคลาสย่อย ใช้คำสั่ง 'return 0'

สตริง C ++:

ตอนนี้ เราจะค้นพบวิธีการประกาศและเริ่มต้นสตริงใน C++ String ใช้สำหรับเก็บกลุ่มตัวอักษรในโปรแกรม มันเก็บค่าตัวอักษร ตัวเลข และสัญลักษณ์ชนิดพิเศษในโปรแกรม มันสงวนอักขระเป็นอาร์เรย์ในโปรแกรม C ++ อาร์เรย์ใช้เพื่อจองคอลเล็กชันหรือชุดอักขระในการเขียนโปรแกรม C++ สัญลักษณ์พิเศษที่เรียกว่าอักขระ null ใช้เพื่อยุติอาร์เรย์ มันถูกแทนด้วย Escape Sequence (\0) และใช้เพื่อระบุจุดสิ้นสุดของสตริง

รับสตริงโดยใช้คำสั่ง 'cin':

ใช้สำหรับป้อนตัวแปรสตริงโดยไม่มีช่องว่าง ในตัวอย่างที่กำหนด เราใช้โปรแกรม C++ ที่ได้รับชื่อของผู้ใช้โดยใช้คำสั่ง 'cin'

ในขั้นตอนแรก เราใช้ไลบรารี ในขณะเดียวกัน เราได้รวมเนมสเปซมาตรฐานไว้ด้วย ต่อไปเราจะประกาศ หลัก() การทำงาน. เราเริ่มต้นสตริงประเภทอักขระภายในเนื้อหาของ หลัก() การทำงาน. จากนั้นเราใช้คำสั่ง 'cout' เพื่อพิมพ์ 'ป้อนชื่อของคุณ' เราใช้คำสั่ง 'cin' เพื่อถามสตริงจากผู้ใช้ คำสั่ง 'cout' ใช้เพื่อพิมพ์ชื่อที่ผู้ใช้จะเขียน มีการเพิ่มคำสั่ง return 0 เพื่อยุติโปรแกรม

ผู้ใช้ป้อนชื่อ 'Ahmed Chaudry' แต่เราได้เพียง 'Ahmed' เป็นเอาต์พุตแทนที่จะเป็น 'Ahmed Chaudry' ที่สมบูรณ์เพราะคำสั่ง 'cin' ไม่สามารถเก็บสตริงที่มีช่องว่างได้ เก็บเฉพาะค่าก่อนเว้นวรรคเท่านั้น

รับสตริงโดยใช้ฟังก์ชัน cin.get():

ดิ รับ() ฟังก์ชันของคำสั่ง cin ใช้เพื่อรับสตริงจากแป้นพิมพ์ที่อาจมีช่องว่าง

ตัวอย่างข้างต้นรวมถึงไลบรารี เพื่อดำเนินการอินพุตและเอาต์พุต จากนั้น เราใช้เนมสเปซมาตรฐาน ดิ หลัก() เรียกว่าฟังก์ชัน หลังจากนั้น เราเริ่มต้นสตริงชื่อ 's' ในขั้นตอนต่อไป คำสั่ง 'cout' จะใช้เพื่อแสดงคำสั่ง 'Enter a String' ดิ cin.get() ถูกใช้เพื่อรับสตริงจากผู้ใช้ โดยใช้ cin.get() ฟังก์ชั่นเราส่งค่าสตริงและระบุขนาดของสตริงเป็นพารามิเตอร์ คำสั่ง 'cout' ถูกใช้อีกครั้งเพื่อแสดงผลลัพธ์ของโปรแกรม ในท้ายที่สุดเราบวกผลตอบแทน 0

ผู้ใช้ป้อนสตริง 'ชื่อของฉันคืออาลี' เราได้รับสตริงที่สมบูรณ์ 'ชื่อของฉันคืออาลี' เป็นผลลัพธ์เนื่องจากฟังก์ชัน cin.get() ยอมรับสตริงที่มีช่องว่าง

การใช้อาร์เรย์ 2 มิติ (สองมิติ) ของสตริง:

ในกรณีนี้ เรารับอินพุต (ชื่อสามเมือง) จากผู้ใช้โดยใช้อาร์เรย์ 2 มิติของสตริง

ขั้นแรก เรารวมไฟล์ส่วนหัว และเนมสเปซมาตรฐาน เราเรียกใช้ หลัก() การทำงาน. จากนั้น เราเริ่มต้นอาร์เรย์อักขระสองมิติที่มีสามแถวและสิบห้าคอลัมน์ ในขั้นตอนต่อไป for loop ใช้เพื่อนับตัวแปร 'i' เพื่อวนซ้ำสตริงที่ต้องการจนกว่าจะระบุอักขระ null ภายในเนื้อหาของลูป 'for' เราใช้คำสั่ง 'cout' เพื่อแสดงบรรทัด 'ป้อนชื่อเมือง' จากนั้นใช้คำสั่ง 'cin' เพื่อรับชื่อเมือง เราใช้คำสั่ง 'for' loop และ 'cout' เพื่อแสดงชื่อเมืองตามลำดับจนกว่าการวนซ้ำจะสิ้นสุดลง ถัดไป ใช้คำสั่ง 'return 0'

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

ไลบรารีมาตรฐาน C++:

ไลบรารี C++ เป็นคลัสเตอร์หรือการจัดกลุ่มของฟังก์ชัน คลาส ค่าคงที่ และรายการที่เกี่ยวข้องทั้งหมดที่อยู่ในชุดเดียวที่เหมาะสม เกือบจะกำหนดและประกาศไฟล์ส่วนหัวที่เป็นมาตรฐานเสมอ การใช้งานเหล่านี้รวมถึงไฟล์ส่วนหัวใหม่สองไฟล์ซึ่งไม่จำเป็นโดยมาตรฐาน C++ ชื่อ และ มีรายการไฟล์ส่วนหัวที่จำเป็นจำนวนมากซึ่งขึ้นอยู่กับความต้องการของคอมไพเลอร์ ไฟล์ส่วนหัวประกอบด้วยรายการส่วนหัวที่มีเนื้อหาทั้งหมดจากไลบรารีมาตรฐาน C++ รวมถึงมีไฟล์ส่วนหัวเฉพาะสำหรับเทมเพลต Stand Library (STL)

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

ไลบรารีมาตรฐาน C++ รองรับสองประเภทต่อไปนี้:

• การใช้งานแบบโฮสต์ที่จัดเตรียมไฟล์ส่วนหัวของไลบรารีมาตรฐานที่จำเป็นทั้งหมดซึ่งอธิบายโดยมาตรฐาน C++ ISO
• การใช้งานแบบสแตนด์อโลนที่ต้องการเพียงบางส่วนของไฟล์ส่วนหัวจากไลบรารีมาตรฐาน เซตย่อยที่เหมาะสมคือ:

ไฟล์ส่วนหัวบางส่วนได้รับความผิดหวังตั้งแต่ 11 C ++ ที่ผ่านมา: นั่นคือ , และ

ความแตกต่างระหว่างการใช้งานแบบโฮสต์และแบบอิสระมีดังนี้:

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

ประเภท:

ทั้งแบบอิสระและโฮสต์ได้รับการสนับสนุนโดย C ++ ไฟล์ส่วนหัวแบ่งออกเป็นสองส่วนต่อไปนี้:

• ส่วนไอโอสตรีม
• ส่วน C++ STL (ไลบรารีมาตรฐาน)

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

เมื่อพิจารณาถึงประวัติศาสตร์แล้ว STL นั้นเริ่มแรกเรียกว่าไลบรารีเทมเพลตมาตรฐาน จากนั้น ส่วนของไลบรารี STL จะถูกกำหนดมาตรฐานในไลบรารีมาตรฐานของ C++ ที่ใช้ในปัจจุบัน ซึ่งรวมถึงไลบรารีรันไทม์ ISO C++ และส่วนย่อยบางส่วนจากไลบรารี Boost รวมถึงฟังก์ชันที่สำคัญอื่นๆ ในบางครั้ง STL จะหมายถึงคอนเทนเนอร์หรืออัลกอริธึมของไลบรารีมาตรฐาน C++ บ่อยครั้ง ตอนนี้ STL หรือไลบรารีเทมเพลตมาตรฐานพูดถึงไลบรารีมาตรฐาน C ++ ที่รู้จักทั้งหมด

std เนมสเปซและไฟล์ส่วนหัว:

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

สมมติว่ามีคนใช้รายการและสตริง เขาต้องเพิ่มไฟล์ส่วนหัวต่อไปนี้:

วงเล็บเหลี่ยมเหล่านี้ '<>' หมายถึงต้องค้นหาไฟล์ส่วนหัวนี้ในไดเร็กทอรีที่กำหนดและรวมไว้ นอกจากนี้ยังสามารถเพิ่มส่วนขยาย '.h' ลงในไลบรารีนี้ซึ่งทำได้หากต้องการหรือต้องการ หากเราไม่รวมไลบรารี '.h' เราต้องเพิ่ม 'c' ก่อนเริ่มต้นชื่อไฟล์ เช่นเดียวกับการบ่งชี้ว่าไฟล์ส่วนหัวนี้เป็นของไลบรารี C ตัวอย่างเช่น คุณสามารถเขียน (#include หรือ #include )

เมื่อพูดถึงเนมสเปซ ไลบรารีมาตรฐาน C++ ทั้งหมดจะอยู่ภายในเนมสเปซนี้ซึ่งแสดงเป็น std นี่คือเหตุผลว่าทำไมผู้ใช้จึงต้องกำหนดชื่อไลบรารีมาตรฐานอย่างเหมาะสม ตัวอย่างเช่น:

C ++ เวกเตอร์:

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

ประกาศ:

การประกาศเวกเตอร์แสดงไว้ด้านล่าง

ในที่นี้ vector เป็นคีย์เวิร์ดที่ใช้ DT กำลังแสดงประเภทข้อมูลของเวกเตอร์ซึ่งสามารถแทนที่ด้วย int, float, char หรือประเภทข้อมูลอื่นๆ ที่เกี่ยวข้อง การประกาศข้างต้นสามารถเขียนใหม่เป็น:

ไม่ได้ระบุขนาดของเวกเตอร์ เนื่องจากขนาดอาจเพิ่มขึ้นหรือลดลงระหว่างการดำเนินการ

การเริ่มต้นของเวกเตอร์:

สำหรับการเริ่มต้นของเวกเตอร์ มีมากกว่าหนึ่งวิธีใน C++

เทคนิคหมายเลข 1:

ในขั้นตอนนี้ เราจะกำหนดค่าให้กับเวกเตอร์ทั้งสองโดยตรง ค่าที่กำหนดให้กับทั้งคู่จะคล้ายกันทุกประการ

เทคนิคหมายเลข 2:

ในกระบวนการเริ่มต้นนี้ 3 กำลังกำหนดขนาดของเวกเตอร์และ 15 คือข้อมูลหรือค่าที่เก็บไว้ในนั้น เวกเตอร์ของประเภทข้อมูล 'int' ที่มีขนาดที่กำหนดเป็น 3 ที่เก็บค่า 15 ถูกสร้างขึ้น ซึ่งหมายความว่าเวกเตอร์ 'v3' กำลังจัดเก็บสิ่งต่อไปนี้:

การดำเนินงานที่สำคัญ:

การดำเนินการหลักที่เราจะนำไปใช้กับเวกเตอร์ภายในคลาสเวกเตอร์คือ:

• เพิ่มมูลค่า
• การเข้าถึงค่า
• การเปลี่ยนแปลงค่า
• การลบค่า

การเพิ่มและการลบ:

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

ฟังก์ชั่นที่ใช้:

ในการเปลี่ยนแปลงหรือเปลี่ยนค่าที่เก็บไว้ภายในเวกเตอร์ มีฟังก์ชันที่กำหนดไว้ล่วงหน้าบางอย่างที่เรียกว่าตัวปรับแต่ง มีดังนี้

• แทรก (): ใช้สำหรับการเพิ่มค่าภายในคอนเทนเนอร์เวกเตอร์ที่ตำแหน่งเฉพาะ
• Erase(): ใช้สำหรับลบหรือลบค่าภายในคอนเทนเนอร์เวกเตอร์ที่ตำแหน่งเฉพาะ
• Swap(): ใช้สำหรับการสลับค่าภายในคอนเทนเนอร์เวกเตอร์ที่เป็นของประเภทข้อมูลเดียวกัน
• Assign(): ใช้สำหรับการจัดสรรค่าใหม่ให้กับค่าที่เก็บไว้ก่อนหน้านี้ภายในคอนเทนเนอร์เวกเตอร์
• Begin(): ใช้สำหรับส่งคืนตัววนซ้ำภายในลูปที่ระบุค่าแรกของเวกเตอร์ภายในองค์ประกอบแรก
• Clear(): ใช้สำหรับลบค่าทั้งหมดที่เก็บไว้ในคอนเทนเนอร์เวกเตอร์
• Push_back(): ใช้สำหรับการเพิ่มค่าที่ส่วนท้ายของคอนเทนเนอร์เวกเตอร์
• Pop_back(): ใช้สำหรับลบค่าเมื่อสิ้นสุดคอนเทนเนอร์เวกเตอร์

ตัวอย่าง:

ในตัวอย่างนี้ ตัวดัดแปลงถูกใช้ตามเวกเตอร์

อันดับแรก เราจะรวมไฟล์ส่วนหัว และ หลังจากนี้ เนมสเปซ std จะถูกรวมเพื่อเพิ่มคลาสทั้งหมดพร้อมกัน สำหรับการเขียนลอจิกของโปรแกรมทั้งหมด เรากำลังเรียกใช้ฟังก์ชัน main() โดยที่เวกเตอร์ชื่อ 'digits' ถูกเตรียมใช้งาน การกำหนดเวกเตอร์นี้เสร็จสิ้นในขั้นตอนต่อไปโดยที่ 'ตัวเลข' ให้ค่าเป็น 6 และ 24 ซึ่งหมายความว่าองค์ประกอบ 6 รายการจะถูกเก็บไว้ในคอนเทนเนอร์เวกเตอร์ โดยแต่ละรายการมีค่า 24 จากนั้นค่าเหล่านี้จะแสดงโดยใช้ 'cout ' สั่งการ. วง 'for' ใช้สำหรับฟังก์ชันตัวแก้ไข push_back() สำหรับการเพิ่มองค์ประกอบภายในคอนเทนเนอร์ ตอนนี้ ค่า 3 ถูกเพิ่มลงในตัวเลขในตอนท้าย เราเริ่มต้นตัวแปร 'x' เพื่อเก็บบันทึกขนาดของคอนเทนเนอร์เวกเตอร์ ตอนนี้ ค่าขององค์ประกอบสุดท้ายจะแสดงและ pop_back() ฟังก์ชั่นจะลบหมายเลข '3' ที่เก็บไว้ในคอนเทนเนอร์ สำหรับการแสดงองค์ประกอบทั้งหมด เราใช้การวนซ้ำ 'for' กับ แทรก() ตัวแก้ไขที่จะแทรกค่า ที่นี่ 4 จะถูกแทรกที่จุดเริ่มต้นของคอนเทนเนอร์เวกเตอร์และแสดงบนหน้าจอ ดิ แจ่มใส() ตัวแก้ไขจะล้างหรือลบค่าทั้งหมดที่เก็บไว้ในคอนเทนเนอร์ ขนาดของเวกเตอร์จะแสดงหลังจากการหักบัญชีเสร็จสิ้น

ผลลัพธ์แสดงอยู่ด้านล่าง

ไฟล์ C ++ เอาต์พุตอินพุต:

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

อินพุตและเอาต์พุตในไฟล์มีลักษณะเป็นสามคลาสหลัก:

• คลาส 'istream' ใช้สำหรับรับอินพุต
• คลาส 'ostream' ใช้สำหรับแสดงผล
• สำหรับอินพุตและเอาต์พุต ให้ใช้คลาส 'iostream'

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

• นอกสตรีม: เป็นคลาสสตรีมที่ใช้สำหรับเขียนลงในไฟล์
• อิฟสตรีม: เป็นคลาสสตรีมที่ใช้อ่านเนื้อหาจากไฟล์
• ลำธาร: เป็นคลาสสตรีมที่ใช้สำหรับทั้งการอ่านและการเขียนในไฟล์หรือจากไฟล์

คลาส 'istream' และ 'ostream' เป็นบรรพบุรุษของคลาสทั้งหมดที่กล่าวถึงข้างต้น สตรีมไฟล์นั้นใช้งานง่ายพอๆ กับคำสั่ง 'cin' และ 'cout' โดยมีความแตกต่างเพียงแค่การเชื่อมโยงสตรีมไฟล์เหล่านี้กับไฟล์อื่นๆ ให้เราดูตัวอย่างเพื่อศึกษาสั้น ๆ เกี่ยวกับคลาส 'fstream':

ตัวอย่าง:

ในกรณีนี้ เรากำลังเขียนข้อมูลในไฟล์

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

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

การเปิดไฟล์:

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

ที่นี่โหมดนี้ไม่บังคับ

การปิดไฟล์:

เมื่อการดำเนินการอินพุตและเอาต์พุตทั้งหมดเสร็จสิ้น เราต้องปิดไฟล์ที่เปิดไว้เพื่อทำการแก้ไข เราต้องจ้าง a ปิด() ทำหน้าที่ในสถานการณ์นี้

เมื่อเสร็จแล้ว ไฟล์จะไม่พร้อมใช้งาน หากภายใต้สถานการณ์ใด ๆ วัตถุถูกทำลาย แม้จะเชื่อมโยงกับไฟล์ destructor จะเรียกใช้ฟังก์ชัน close() ตามธรรมชาติ

ไฟล์ข้อความ:

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

ตัวอย่าง:

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

ที่นี่ เรากำลังเขียนข้อมูลในไฟล์ชื่อ 'example' โดยใช้ฟังก์ชัน New_File() เราเปิดไฟล์ 'ตัวอย่าง' โดยใช้ เปิด() กระบวนการ. 'ofstream' ใช้เพื่อเพิ่มข้อมูลลงในไฟล์ หลังจากทำงานทั้งหมดภายในไฟล์แล้ว ไฟล์ที่ต้องการจะถูกปิดโดยใช้คำสั่ง ปิด() การทำงาน. หากไฟล์ไม่เปิดข้อความแสดงข้อผิดพลาด 'ไม่รองรับไฟล์ เกิดข้อผิดพลาดขณะโหลดไฟล์'

ไฟล์จะเปิดขึ้นและข้อความจะแสดงบนคอนโซล

การอ่านไฟล์ข้อความ:

การอ่านไฟล์จะแสดงโดยใช้ตัวอย่างที่ตามมา

ตัวอย่าง:

'ifstream' ใช้สำหรับอ่านข้อมูลที่จัดเก็บไว้ในไฟล์

ตัวอย่างรวมถึงไฟล์ส่วนหัวหลัก ในตอนเริ่มต้น จากนั้นใช้ 'ifstream' ภายใน หลัก() การทำงาน. ด้วยความช่วยเหลือของ 'ifstream' เราจะอ่านข้อมูลด้วยไฟล์ 'New_File' ที่แสดงข้อความที่จัดเก็บไว้ในไฟล์ข้อความ 'ตัวอย่าง' เราใช้ เปิด() วิธีการเปิดไฟล์. ต่อไป เราจะใช้การวนรอบ 'while' หลังจากอ่านข้อมูลจากไฟล์ข้อความ 'ตัวอย่าง' แล้ว ปิด() ฟังก์ชั่นใช้เพื่อปิดไฟล์ที่ต้องการ หากระบบไม่มีไฟล์นั้น เราก็จะได้รับข้อความ 'Unable to open file'

ข้อมูลทั้งหมดที่เก็บไว้ในไฟล์ข้อความจะแสดงบนหน้าจอตามที่แสดง

บทสรุป

ในคำแนะนำข้างต้น เราได้เรียนรู้เกี่ยวกับภาษา C++ อย่างละเอียด นอกจากตัวอย่างแล้ว ยังมีการสาธิตและอธิบายทุกหัวข้อ ตลอดจนการดำเนินการแต่ละอย่างอย่างละเอียด