ฉันมีคำถามเกี่ยวกับความแตกต่างระหว่างความผันผวนและความผันแปร ฉันสังเกตว่าทั้งสองอย่างนั้นหมายความว่ามันสามารถเปลี่ยนแปลงได้ อะไรอีก? พวกเดียวกันหรือเปล่า? อะไรคือความแตกต่าง? ใช้ได้ที่ไหน? เหตุใดจึงเสนอแนวคิดทั้งสองนี้ วิธีการใช้งานที่แตกต่างกัน?
ขอบคุณมาก.
คำตอบ:
mutableฟิลด์สามารถเปลี่ยนแปลงได้แม้ในวัตถุเข้าถึงได้ผ่านทางconstตัวชี้หรือการอ้างอิงหรือในconstวัตถุเป็นคอมไพเลอร์รู้ว่าไม่ต้องเก็บสะสมไว้ในหน่วยความจำ R / O volatileสถานที่หนึ่งที่สามารถเปลี่ยนแปลงได้โดยรหัสคอมไพเลอร์ไม่ทราบเกี่ยวกับ (เช่นบางเคอร์เนลไดรเวอร์ระดับ) ดังนั้นคอมไพเลอร์รู้ไม่ได้ที่จะเพิ่มประสิทธิภาพเช่นลงทะเบียนการโอนค่าที่อยู่ภายใต้สมมติฐานที่ไม่ถูกต้องว่าค่า "ไม่อาจมี เปลี่ยนแปลง "เนื่องจากโหลดครั้งสุดท้ายในรีจิสเตอร์นั้น ข้อมูลที่แตกต่างกันมากที่มอบให้กับคอมไพเลอร์เพื่อหยุดการเพิ่มประสิทธิภาพที่ไม่ถูกต้องประเภทต่างๆ
volatileไม่เพียงหมายความว่าวัตถุสามารถเปลี่ยนแปลงภายนอกความรู้ของคอมไพเลอร์เท่านั้น แต่ยังหมายความว่าการเขียนไปยังวัตถุนั้นไม่สามารถกำจัดได้โดยคอมไพเลอร์แม้ว่าการเขียนเหล่านั้นดูเหมือนจะไร้ประโยชน์ก็ตาม ตัวอย่างเช่น: x = 1; x = 0; หากxมีความผันผวนคอมไพเลอร์จะต้องปล่อยการดำเนินการเขียนทั้งสองอย่าง (ซึ่งอาจมีนัยสำคัญในระดับฮาร์ดแวร์) อย่างไรก็ตามสำหรับวัตถุที่ไม่ลบเลือนคอมไพเลอร์สามารถเลือกที่จะไม่ยุ่งกับการเขียน1เนื่องจากไม่เคยใช้
constและvolatile! คุณไม่สามารถเปลี่ยนวัตถุ แต่สามารถเปลี่ยนด้านหลังของคุณได้
mutable: คีย์เวิร์ดที่เปลี่ยนแปลงได้จะแทนที่คำสั่ง const ที่อยู่รอบ ๆ สมาชิกที่ไม่แน่นอนของวัตถุ const สามารถแก้ไขได้
volatile: คีย์เวิร์ดระเหยเป็นตัวปรับเปลี่ยนที่ขึ้นกับการใช้งานซึ่งใช้เมื่อประกาศตัวแปรซึ่งป้องกันไม่ให้คอมไพลเลอร์ปรับตัวแปรเหล่านั้นให้เหมาะสม Volatile ควรใช้กับตัวแปรที่ค่าสามารถเปลี่ยนแปลงในรูปแบบที่ไม่คาดคิด (เช่นผ่านการขัดจังหวะ) ซึ่งอาจขัดแย้งกับการเพิ่มประสิทธิภาพที่คอมไพเลอร์อาจดำเนินการ
Volatile should be used with variables whose value can change in unexpected waysเราควรใช้แบบสุ่มหรือไม่?
พวกเขาไม่ใช่สิ่งเดียวกันแน่นอน ไม่สามารถโต้ตอบกับ const หากคุณมีตัวชี้ const ปกติแล้วคุณจะไม่สามารถเปลี่ยนสมาชิกได้ เปลี่ยนแปลงไม่ได้ให้ข้อยกเว้นสำหรับกฎนั้น
ในทางกลับกันความผันผวนไม่เกี่ยวข้องกับการเปลี่ยนแปลงที่เกิดขึ้นโดยโปรแกรม หมายความว่าหน่วยความจำอาจเปลี่ยนแปลงได้ด้วยเหตุผลที่อยู่นอกเหนือการควบคุมของคอมไพเลอร์ดังนั้นคอมไพเลอร์จึงต้องอ่านหรือเขียนที่อยู่หน่วยความจำทุกครั้งและไม่สามารถแคชเนื้อหาในรีจิสเตอร์ได้
Tมาเก็บไว้ใน a const T*และอ่านจากมันได้ หากคุณสร้างออบเจ็กต์volatileนั้นการจัดเก็บที่อยู่ลงในconst T*จะล้มเหลวแม้ว่าคุณจะไม่เคยพยายามเขียน volatileและการเปลี่ยนแปลง / แก้ไข / หน่วยความจำที่เขียนจากโค้ดโปรแกรมจะมีมุมฉากอย่างสมบูรณ์
วิธีคิดเกี่ยวกับความแตกต่างที่หยาบคาย แต่มีประสิทธิภาพคือ:
volatilebytes_received, mutablereference_count
ตัวแปรที่ทำเครื่องหมายmutableอนุญาตให้แก้ไขได้ในวิธีการที่ประกาศconstไว้
ตัวแปรที่ทำเครื่องหมายvolatileบอกคอมไพเลอร์ว่าต้องอ่าน / เขียนตัวแปรทุกครั้งที่โค้ดของคุณบอกด้วยเช่นกัน (กล่าวคือไม่สามารถเพิ่มประสิทธิภาพการเข้าถึงตัวแปรออกไปได้)
ฉันต้องการเพิ่มว่าการระเหยยังมีประโยชน์มากเมื่อจัดการกับแอปพลิเคชันมัลติเธรดกล่าวคือคุณมีเธรดหลักของคุณ (ที่ main () มีชีวิตอยู่) และคุณวางไข่เธรดผู้ปฏิบัติงานซึ่งจะหมุนไปเรื่อย ๆ ในขณะที่ตัวแปร "app_running" เป็นจริง main () ควบคุมว่า "app_running" เป็นจริงหรือเท็จดังนั้นหากคุณไม่เพิ่มแอตทริบิวต์ระเหยในการประกาศ "app_running" หากคอมไพเลอร์เพิ่มประสิทธิภาพการเข้าถึง "app_running" ในโค้ดที่รันโดยเธรดรอง main ( ) อาจเปลี่ยน "app_running" เป็น false แต่เธรดรองจะทำงานต่อไปเนื่องจากค่าถูกแคชไว้ ฉันเห็นพฤติกรรมเดียวกันกับการใช้ gcc บน Linux และ VisualC ++ แอตทริบิวต์ "ระเหย" ที่ใส่ในการประกาศ "app_running" ช่วยแก้ปัญหาได้ ดังนั้น,
volatileนอกจากนี้ยังสามารถเปลี่ยนแปลงวัตถุได้โดยกระบวนการที่ไม่เกี่ยวข้องกับ CPU เลย ตัวอย่างเช่นการลงทะเบียนไบต์ที่ได้รับในอุปกรณ์ต่อพ่วงการสื่อสารสามารถเพิ่มขึ้นได้เองเมื่อได้รับไบต์ (และอาจทำให้เกิดการขัดจังหวะได้) อีกตัวอย่างหนึ่งคือการลงทะเบียนแฟล็กที่รอการขัดจังหวะในอุปกรณ์ต่อพ่วง