C++ รองรับตัวดำเนินการยูนินารีหลายตัว โดยแต่ละตัวมีจุดประสงค์เฉพาะในการจัดการกับตัวแปร เริ่มต้นด้วยตัวดำเนินการเพิ่มและลดซึ่งมักใช้ในลูปและอัลกอริธึมต่างๆ
ตัวอย่างที่ 1: ตัวดำเนินการการเพิ่มขึ้น (++) และการลด (–)
ตัวดำเนินการเอกภาคการเพิ่มขึ้น (++) และการลด (–) เป็นเครื่องมือพื้นฐานในภาษา C++ สำหรับการแก้ไขค่าของตัวแปรโดยการเพิ่มหรือลดลง 1 ตามลำดับ ตัวดำเนินการเพิ่ม (++) บวก 1 เข้ากับค่าของตัวแปร ในขณะที่ตัวดำเนินการลด (–) ลบ 1 ตัวดำเนินการเหล่านี้สามารถนำไปใช้กับตัวแปรจำนวนเต็ม จุดลอยตัว และตัวชี้ได้ ซึ่งให้ความยืดหยุ่นในการใช้งาน
มาสำรวจโอเปอเรเตอร์เหล่านี้ผ่านตัวอย่างเชิงปฏิบัติกันดีกว่า:
#รวม
โดยใช้ เนมสเปซ มาตรฐาน ;
ภายใน หลัก ( )
{
ภายใน เคาน์เตอร์ = 0 ;
// ตัวดำเนินการเพิ่ม
ศาล << 'ค่าเริ่มต้น: ' << เคาน์เตอร์ << สิ้นสุด ;
เคาน์เตอร์ ++ ;
ศาล << 'มูลค่าหลังการเพิ่ม:' << เคาน์เตอร์ << สิ้นสุด ;
// ตัวดำเนินการลด
เคาน์เตอร์ -- ;
ศาล << 'มูลค่าหลังการลดลง:' << เคาน์เตอร์ << สิ้นสุด ;
กลับ 0 ;
}
โปรแกรม C++ แบบง่ายนี้มีไลบรารีสตรีมอินพุต/เอาต์พุตที่จำเป็นพร้อม “#include
หลังจากการดำเนินการนี้ ค่าที่อัปเดตของ 'ตัวนับ' จะแสดงโดยใช้คำสั่ง 'cout' อื่น จากนั้น เราใช้ตัวดำเนินการลด (ตัวนับ—) เพื่อลดค่าของ 'ตัวนับ' ลง 1 ผลลัพธ์จะแสดงบนคอนโซลในภายหลัง ท้ายที่สุด โปรแกรมจะลงท้ายด้วย “return 0” คำสั่งที่บ่งบอกถึงการดำเนินการที่ประสบความสำเร็จ
รูปภาพเอาต์พุตจะแสดงค่าเริ่มต้น ค่าหลังการเพิ่ม และค่าที่ลดลง
ตัวอย่างที่ 2: ตัวดำเนินการเชิงบวก (+) และเชิงลบ (-)
แม้ว่าตัวดำเนินการเอกนารีเชิงบวกจะไม่ค่อยได้ใช้ ตัวดำเนินการเชิงลบก็เป็นพื้นฐานในการเปลี่ยนเครื่องหมายของตัวแปร
#รวมโดยใช้ เนมสเปซ มาตรฐาน ;
ภายใน หลัก ( ) {
ภายใน ค่าบวก = 10 ;
ภายใน ค่าลบ = - - ค่าบวก ;
ศาล << 'ค่าบวก:' << ค่าบวก << สิ้นสุด ;
ศาล << 'ค่าลบ:' << ค่าลบ << สิ้นสุด ;
กลับ 0 ;
}
เราเริ่มต้นตัวแปรจำนวนเต็มสองตัวสำหรับโค้ดตัวอย่างนี้ซึ่งก็คือ 'positiveValue' และ 'negativeValue' “positiveValue” ถูกกำหนดด้วยค่า 10 ต่อมา เราประกาศ “negativeValue” และกำหนดด้วยการปฏิเสธ “positiveValue” โดยใช้ตัวดำเนินการ unary ลบ ตัวดำเนินการนี้จะเปลี่ยนเครื่องหมายของค่าดั้งเดิมได้อย่างมีประสิทธิภาพ จากนั้นเราใช้คำสั่ง 'cout' เพื่อแสดงทั้งเอาต์พุตเชิงบวกและเชิงลบบนคอนโซล ในที่สุด โปรแกรมจะคืนค่า 0 ซึ่งบ่งชี้ถึงความสมบูรณ์ของฟังก์ชันหลัก
เมื่อดำเนินการ โปรแกรมนี้จะส่งเอาต์พุตค่าบวกและลบ
ตัวอย่างที่ 3: ตัวดำเนินการตรรกะ NOT (!)
ตัวดำเนินการเอกนารีในภาษา C++ ซึ่งแสดงด้วยเครื่องหมาย “!” สัญลักษณ์นี้เรียกว่าตัวดำเนินการ NOT แบบลอจิคัล ได้รับการออกแบบมาเพื่อกลับค่าความจริงของนิพจน์ที่กำหนด มันทำงานบนตัวถูกดำเนินการตัวเดียว ซึ่งโดยทั่วไปจะเป็นนิพจน์เชิงตรรกะหรือเงื่อนไข การดำเนินการ NOT แบบลอจิคัลให้ผลลัพธ์ที่ 'จริง' เมื่อตัวถูกดำเนินการเป็น 'เท็จ' และให้ผลลัพธ์ 'เท็จ' เมื่อตัวถูกดำเนินการเป็น 'จริง'
นี่คือตัวอย่างง่ายๆ ที่สาธิตการใช้ตัวดำเนินการ NOT แบบลอจิคัล:
#รวมโดยใช้ เนมสเปซ มาตรฐาน ;
ภายใน หลัก ( ) {
บูล เป็นความจริง = จริง ;
บูล เป็นเท็จ = เท็จ ;
บูล ผลลัพธ์ไม่เป็นความจริง = ! เป็นความจริง ;
บูล ผลลัพธ์ไม่ใช่เท็จ = ! เป็นเท็จ ;
ศาล << 'มูลค่าดั้งเดิม:' << เป็นความจริง << ', หลังจากไม่: ' << ผลลัพธ์ไม่เป็นความจริง << สิ้นสุด ;
ศาล << 'มูลค่าดั้งเดิม:' << เป็นเท็จ << ', หลังจากไม่: ' << ผลลัพธ์ไม่ใช่เท็จ << สิ้นสุด ;
กลับ 0 ;
}
ในตัวอย่างนี้ เราประกาศตัวแปรบูลีนสองตัว “isTrue” และ “isFalse” จากนั้นเราจะใช้ตัวดำเนินการ NOT แบบลอจิคัลกับตัวแปรแต่ละตัว โดยจัดเก็บผลลัพธ์ไว้ใน “resultNotTrue” และ “resultNotFalse” ตามลำดับ ต่อมาโปรแกรมจะพิมพ์ค่าดั้งเดิมและผลลัพธ์ของการดำเนินการ NOT แบบลอจิคัลสำหรับตัวแปรทั้งสอง
เมื่อรันโปรแกรมนี้ เราจะสังเกตเห็นว่าตัวดำเนินการ NOT แบบลอจิคัลกลับค่าความจริงของ 'isTrue' (เริ่มแรกตั้งค่าเป็นจริง) โดยแสดงผลเป็นเท็จ ในทำนองเดียวกัน จะกลับค่าความจริงของ 'isFalse' (แต่เดิมเป็นเท็จ) ให้เป็นค่าจริง
ผลลัพธ์แสดงให้เห็นอย่างชัดเจนถึงการผกผันของค่าความจริงที่ได้รับจากตัวดำเนินการ NOT แบบลอจิคัล
ตัวอย่างที่ 4: ตัวดำเนินการ Bitwise ไม่ใช่ (~)
ตัวดำเนินการระดับบิต NOT (~) ในภาษา C++ คือตัวดำเนินการเอกภาคที่ดำเนินการปฏิเสธระดับบิตของแต่ละบิตของตัวถูกดำเนินการ มันทำงานกับชนิดข้อมูลพื้นฐาน โดยเฉพาะอินทิกรัล เช่น จำนวนเต็ม ผลลัพธ์สามารถทำได้โดยการกลับบิตทุกๆ บิตในตัวถูกดำเนินการ โดยแปลง 0s เป็น 1s และ 1s เป็น 0s
เพื่อแสดงให้เห็นการใช้งาน ให้พิจารณาข้อมูลโค้ดต่อไปนี้:
#รวมโดยใช้ เนมสเปซ มาตรฐาน ;
ภายใน หลัก ( ) {
ภายใน ค่าเดิม = 5 ;
ภายใน ผลลัพธ์ระดับบิตไม่ = ~ค่าดั้งเดิม ;
ศาล << 'มูลค่าดั้งเดิม:' << ค่าเดิม << ' หลังจาก Bitwise ไม่: ' << ผลลัพธ์ระดับบิตไม่ << สิ้นสุด ;
กลับ 0 ;
}
ในตัวอย่างนี้ เราประกาศตัวแปรจำนวนเต็ม 'OriginalValue' ที่มีค่าเป็น '5' ต่อไป เราใช้ตัวดำเนินการระดับบิต NOT (~) กับตัวแปรนี้ ผลลัพธ์ของตัวแปรนี้ถูกจัดเก็บไว้ใน “resultBitwiseNot” จากนั้นโปรแกรมจะพิมพ์ค่าดั้งเดิมและผลลัพธ์หลังจากการดำเนินการระดับบิต NOT โดยใช้คำสั่ง 'cout'
เมื่อเรารันโปรแกรมนี้ เราจะเห็นว่าตัวดำเนินการ NOT ในระดับบิตจะกลับค่าแต่ละบิตของการแทนค่าไบนารี่ของ 'OriginalValue' ส่งผลให้เกิดค่าใหม่
ตัวอย่างที่ 5: ตัวดำเนินการที่อยู่และทางอ้อม
ที่อยู่ของตัวดำเนินการซึ่งแสดงด้วยสัญลักษณ์ '&' มีจุดประสงค์ในการดึงข้อมูลตำแหน่งหน่วยความจำของตัวแปร มันจะส่งคืนพอยน์เตอร์ไปยังตัวแปรซึ่งทำให้สามารถเข้าถึงค่าของมันทางอ้อมได้ ตัวดำเนินการทางอ้อมหรือตัวดำเนินการอ้างอิง (*) รับค่าที่จัดเก็บไว้ในตำแหน่งหน่วยความจำที่ระบุโดยตัวชี้ โดยให้วิธีการทำงานกับข้อมูลจริงผ่านตัวชี้ทางอ้อม
มาทำความเข้าใจแนวคิดด้วยตัวอย่าง:
#รวมโดยใช้ เนมสเปซ มาตรฐาน ;
ภายใน หลัก ( ) {
ภายใน ค่า = 99 ;
ศาล << 'มูลค่าดั้งเดิม:' << ค่า << สิ้นสุด ;
ภายใน * ปตท = & ค่า ;
ศาล << 'ที่อยู่หน่วยความจำ: ' << ปตท << สิ้นสุด ;
ภายใน ดึงค่าออกมา = * ปตท ;
ศาล << 'ค่าที่ดึงมา:' << ดึงค่าออกมา << สิ้นสุด ;
กลับ 0 ;
}
รหัสนี้เป็นตัวอย่างการใช้ตัวดำเนินการที่อยู่และทางอ้อม ขั้นแรก ตัวแปรจำนวนเต็มชื่อ 'value' จะถูกเตรียมใช้งานด้วยค่า 99 จากนั้นค่าดั้งเดิมของ 'value' จะถูกส่งออกไปยังคอนโซล ต่อมาจะมีการประกาศตัวแปรตัวชี้ “ptr” และใช้ที่อยู่ของตัวดำเนินการ (&) เพื่อกำหนดที่อยู่หน่วยความจำ “value” ให้กับ “ptr” จากนั้นโปรแกรมจะส่งออกที่อยู่หน่วยความจำนี้ โดยแสดงการทำงานพื้นฐานของตัวดำเนินการ 'ที่อยู่'
หลังจากนั้นจะมีการประกาศตัวแปรจำนวนเต็มใหม่ซึ่งก็คือ 'retrivedValue' และใช้ตัวดำเนินการทางอ้อม (*) เพื่อดึงค่าที่จัดเก็บไว้ในที่อยู่หน่วยความจำที่ชี้โดย 'ptr' ค่าที่ดึงออกมาจะถูกส่งออกไปยังคอนโซล
บทสรุป
บทความนี้นำเสนอการสำรวจตัวดำเนินการ unary ในภาษา C++ อย่างครอบคลุม เราเริ่มต้นด้วยการแบ่งประเภทของตัวดำเนินการ unary ออกเป็นประเภทต่างๆ รวมถึงเลขคณิต ตรรกะ ระดับบิต และประเภทที่เกี่ยวข้องกับที่อยู่และทางอ้อม สถานการณ์ในโลกแห่งความเป็นจริงได้รับการยกตัวอย่างเพื่อสาธิตการใช้งานที่เป็นประโยชน์ของตัวดำเนินการเหล่านี้ โอเปอเรเตอร์เหล่านี้มีบทบาทสำคัญในการเขียนโปรแกรม C++ ซึ่งช่วยให้นักพัฒนาทำงานกับพอยน์เตอร์ได้อย่างมีประสิทธิภาพและจัดการหน่วยความจำ