ในบทความนี้ เราจะพิจารณาตัวสร้างประเภทนี้ทั้งหมดพร้อมตัวอย่าง
ตัวอย่าง 1
นี่คือภาพประกอบของคอนสตรัคเตอร์เริ่มต้น อย่างที่เราทราบดีว่าตัวสร้างนั้นถูกสร้างขึ้นโดยอัตโนมัติเมื่อเราสร้างวัตถุของคลาส สิ่งนี้เรียกว่าการสร้างโดยนัย ตัวสร้างมีชื่อเดียวกับชื่อของคลาส พิจารณาไฟล์ที่มีโค้ด c++ ของคอนสตรัคเตอร์ เนื่องจากเรารู้ว่าคลาสมีสองตัวเลือก ส่วนตัวและสาธารณะ ส่วนส่วนตัวประกอบด้วยตัวแปรข้อมูล ในขณะที่ส่วนสาธารณะมีไว้สำหรับฟังก์ชันที่ดึงมาจากวัตถุใดๆ ดังนั้นคอนสตรัคเตอร์จึงถูกกำหนดไว้ในส่วนสาธารณะด้วย
จำนวนเต็ม()
{
NS=ห้าสิบ;
และ=ยี่สิบ;
};
ในตัวสร้างนี้ ค่าถูกกำหนดให้กับตัวแปร ถ้าเราต้องการดึงค่าออกมาเป็นผลลัพธ์ เราต้องพิมพ์มันในโปรแกรมหลัก
หลังจากกำหนดคอนสตรัคเตอร์แล้ว คลาสจะปิด ขณะเข้าสู่โปรแกรมหลัก เราจะพิมพ์ค่าโดยใช้วัตถุ วัตถุเข้าถึงตัวสร้างเสมอเนื่องจากเป็นส่วนของคลาส การสร้างวัตถุนั้นง่ายมาก ทำได้โดยการแนะนำชื่อชั้นเรียน นั่นคือจำนวนเต็มในตัวอย่างนี้ ค่าจะถูกดึงผ่านเมธอด dot เช่น a.x.
เราสามารถเห็นผลลัพธ์ของซอร์สโค้ดจากเทอร์มินัลใน Ubuntu วิธีการที่ใช้ในการรับผลลัพธ์นั้นค่อนข้างง่าย ขั้นแรกให้คอมไพล์โค้ดแล้วจึงดำเนินการ เราใช้คอมไพเลอร์ G++ สำหรับกระบวนการคอมไพล์ เช่นเดียวกับในกรณีของ C เราใช้ GCC
$ G++ -หรือ filec filec.ค
./filec
-O ใช้สำหรับบันทึกเอาต์พุตในไฟล์
ตัวอย่าง 2
ในภาพประกอบนี้ เราจะอธิบายตัวสร้างพารามิเตอร์ ต่างจากตัวอย่างก่อนหน้านี้ เราสามารถส่งต่ออาร์กิวเมนต์ไปยังคอนสตรัคเตอร์จากโปรแกรมหลักได้ เมื่อวัตถุถูกสร้างขึ้น ค่าเหล่านี้จะถูกส่งต่อโดยอัตโนมัติไปยังตัวแปรที่มีอยู่ในตัวสร้างเพื่อรับค่า การใช้คอนสตรัคเตอร์แบบกำหนดพารามิเตอร์บางส่วนคือ
- มันถูกใช้เพื่อเริ่มต้นตัวแปรต่าง ๆ ด้วยค่าต่าง ๆ ภายในตัวสร้างเมื่อเริ่มต้น
- มันถูกใช้ในคอนสตรัคโอเวอร์โหลด มันถูกกำหนดไว้ในภายหลังในบทความ
ตอนนี้ ให้เราพิจารณาภาพประกอบที่เราได้อธิบายไว้เพื่ออธิบายแนวคิดนี้อย่างละเอียดถี่ถ้วน คลาสมีชื่อจำนวนเต็ม ดังนั้นแน่นอนว่าชื่อคอนสตรัคเตอร์ก็จะเหมือนกัน ในพารามิเตอร์ของตัวสร้าง มีค่าประเภทจำนวนเต็มสองค่า สิ่งเหล่านี้ถูกเตรียมใช้งานเพื่อยอมรับค่าที่ส่งจากโปรแกรมหลักเป็นการเรียกฟังก์ชัน
จำนวนเต็ม( intNS,intและ){
ถึง=NS;
NS=และ;
};
ในตัวอย่างก่อนหน้านี้ ตัวแปรภายในคอนสตรัคเตอร์ได้รับค่า ในขณะที่ตัวสร้างนี้ ตัวแปรถูกกำหนดด้วยตัวแปรที่มีค่า
หากเราต้องการแสดงผล เราจำเป็นต้องกำหนดฟังก์ชันที่จะคืนค่าเนื่องจากไม่สามารถเข้าถึงตัวแปรเริ่มต้นนั้นได้โดยตรงจากตัวสร้าง
intgetX(){
กลับถึง;
};
ตอนนี้เราจะเห็นส่วนหลักของโปรแกรม เมื่อวัตถุถูกสร้างขึ้น คุณสามารถดูค่าในส่วนพารามิเตอร์ได้ที่นี่
จำนวนเต็ม v(70,55); {โดยปริยาย}จำนวนเต็ม v=จำนวนเต็ม(10,สิบห้า); {ชัดเจน}
และเพื่อแสดงผลลัพธ์ เราจะเรียกฟังก์ชันที่สร้างขึ้นภายในคลาสโดยใช้วัตถุ เช่น v.getx()
วิธีการดึงบันทึกจะเหมือนกับที่เคยแนะนำมาก่อน
ตัวอย่างที่ 3
ตัวอย่างนี้เกี่ยวข้องกับการคัดลอกคอนสตรัคเตอร์ของคลาส คอนสตรัคเตอร์ที่คัดลอกมาใช้เพื่อเริ่มต้นวัตถุด้วยวัตถุอื่นที่มีคลาสที่คล้ายกันซึ่งเป็นของ ตัวสร้างนี้คัดลอกข้อมูลที่มีอยู่ในวัตถุหนึ่งไปยังอีกวัตถุหนึ่ง พารามิเตอร์ของตัวสร้างนี้มีที่อยู่ของวัตถุของคลาส พิจารณาตัวอย่างที่ให้มา ซึ่งเราได้แนะนำตัวแปรสองตัวที่เป็นประเภทข้อมูลเดียวกัน เพื่อให้สิ่งเหล่านี้สามารถเข้าถึงได้โดยฟังก์ชันใดๆ ภายในคลาส ตัวสร้างจะได้รับค่าผ่านตัวแปร ในเวลาเดียวกัน คอนสตรัคเตอร์ที่คัดลอกจะได้รับเฉพาะอ็อบเจ็กต์เท่านั้น และด้วยความช่วยเหลือของวัตถุนี้ ค่าจะถูกดึงออกมา
กำแพง(กำแพง&วัตถุ){
ความยาว=วัตถุระยะเวลา;
ส่วนสูง=วัตถุความสูง;
}
เราต้องคำนวณพื้นที่ ดังนั้นฟังก์ชันสำหรับการคำนวณนี้จึงถูกกำหนดไว้ที่นี่ ซึ่งจะคืนค่ากลับไปเป็นฟังก์ชันหลักเมื่อมีการเรียก ตอนนี้เราจะสังเกตโปรแกรมหลักของรหัส
การเรียกใช้ฟังก์ชันของ Constructor ที่คัดลอกจะเป็นแบบนี้
ผนัง ผนัง2=wall1;ออบเจ็กต์เรียกคอนสตรัคเตอร์ที่คัดลอกและข้อมูลผ่านออบเจกต์แรกจะถูกคัดลอกผ่าน นอกจากนี้ เราจะเรียกใช้ฟังก์ชันเพื่อคำนวณพื้นที่ผ่านวัตถุทั้งสอง
จากผลลัพธ์ คุณสามารถดูได้ว่าผลลัพธ์จากตัวสร้างทั้งสองเหมือนกัน หมายความว่าข้อมูลทั้งหมดถูกคัดลอกโดยวัตถุสำเร็จ
ตัวอย่างที่ 4
นี่คือภาพประกอบของการโอเวอร์โหลดคอนสตรัคเตอร์ มันเกิดขึ้นเมื่อเราต้องใช้มากกว่าหนึ่งฟังก์ชันในชั้นเรียน คอนสตรัคเตอร์โอเวอร์โหลดทำตามคำแนะนำของคอนสตรัคเตอร์แบบกำหนดพารามิเตอร์ ตัวสร้างทั้งหมดในคลาสมีชื่อคล้ายกับคลาส แต่คอนสตรัคเตอร์แต่ละตัวได้รับการกำหนดค่าพารามิเตอร์ที่แตกต่างกัน ตัวสร้างแต่ละตัวถูกเรียกตามอาร์กิวเมนต์เมื่อเราสร้างวัตถุ
พิจารณาตัวอย่างที่ให้มา ซึ่งเราใช้ตัวสร้างสามตัว หนึ่งคือไม่มีข้อโต้แย้งใดๆ อันที่สองมีอาร์กิวเมนต์เดียว ในขณะที่อันที่สามมีสองอาร์กิวเมนต์ ภาพประกอบนี้คล้ายกับภาพก่อนหน้า ขณะที่เราคำนวณพื้นที่ในฟังก์ชันแยกตามที่อธิบายไว้ในชั้นเรียน
// ตัวสร้างที่มีสองอาร์กิวเมนต์รูปร่าง(intNS,intและ)
{
ถึง=NS;
NS=และ;
};
ตอนนี้ ย้ายไปยังโปรแกรมหลัก เราจะเห็นว่าเมื่อเราเริ่มต้นคลาสอ็อบเจ็กต์ คอนสตรัคเตอร์ที่ไม่มีอาร์กิวเมนต์จะถูกเรียกโดยค่าเริ่มต้น ตอนนี้เราจำเป็นต้องเรียกตัวสร้างอื่นด้วยวัตถุต่าง ๆ ที่มีอาร์กิวเมนต์ต่างกัน
รูปร่าง s;รูปร่าง s2(8);
รูปร่าง s3(4,2);
ฟังก์ชั่นที่เราสามารถแสดงค่าได้นั้นถูกเรียกผ่านวัตถุเดียวกันที่สร้างขึ้น
ในการดูผลลัพธ์ เราจะใช้วิธีเทอร์มินัลคำสั่งเดียวกันโดยรวบรวมและรันโค้ดที่มีอยู่ในไฟล์
จากผลลัพธ์ เราจะเห็นว่าคำตอบสำหรับตัวสร้างแต่ละตัวเหมือนกัน
บทสรุป
ในบทช่วยสอนนี้ เราได้เห็นพื้นฐานของตัวสร้างและฟังก์ชันการทำงานของมันแล้ว รวมถึงวิธีการโอเวอร์โหลดพวกมัน ตัวสร้างใช้เพื่อเริ่มต้นตัวแปรด้วยค่าต่างๆ