ตัวแปรในภาษาการเขียนโปรแกรม C++ ทำหน้าที่เป็นองค์ประกอบพื้นฐานในการจัดการและจัดการข้อมูลที่มีบทบาทสำคัญในการจัดการตัวแปรภายในโปรแกรม C++ ภาษาการเขียนโปรแกรม C++ นำเสนอวิธีที่มีประสิทธิภาพในการจัดการการมองเห็นตัวแปรในขอบเขตและหน่วยการคอมไพล์ที่แตกต่างกันโดยใช้ตัวแปรส่วนกลางแบบคงที่ ตัวแปรส่วนกลางแบบคงที่ที่ได้รับการประกาศในขอบเขตส่วนกลางนั้นถูกจำกัดไว้เฉพาะไฟล์ที่ถูกกำหนดไว้เนื่องจากตัวระบุ 'คงที่' คีย์เวิร์ด 'คงที่' ช่วยให้มั่นใจได้ว่าตัวแปรจะรักษาค่าของมันไว้ในการเรียกใช้ฟังก์ชันภายในไฟล์นั้น แต่ยังคงไม่สามารถเข้าถึงได้และมองไม่เห็นในไฟล์อื่น ตัวแปรโกลบอลแบบคงที่ใน C++ มีความสำคัญอย่างยิ่งในการจัดการสถานะของโปรแกรม บทความนี้จะสำรวจความซับซ้อนของตัวแปรส่วนกลางแบบคงที่ โดยเน้นที่คุณลักษณะ กรณีการใช้งาน และความท้าทายที่อาจเกิดขึ้น
ตัวแปรคงที่ใน C ++
ในภาษา C++ ตัวแปรแบบคงที่สามารถสร้างอินสแตนซ์ภายในขอบเขตต่างๆ รวมถึงโกลบอล โลคัล เนมสเปซ หรือภายในคลาส การมีอยู่ของมันครอบคลุมรันไทม์ของโปรแกรมทั้งหมดตั้งแต่ต้นจนจบ ทำให้มั่นใจได้ว่าการจัดสรรจะคงอยู่ตลอด กล่าวง่ายๆ ก็คือ หน่วยความจำจะถูกจัดสรรให้กับตัวแปรเหล่านี้เมื่อเริ่มต้นโปรแกรม และถูกจัดสรรคืนเมื่อการทำงานของโปรแกรมสิ้นสุดลง เมื่อใช้สแตติกกับตัวแปร มันจะจำกัดการมองเห็นของตัวแปรในแง่ของการเชื่อมโยง และสามารถเข้าถึงได้เฉพาะโปรแกรมที่ได้รับการประกาศเท่านั้น
การประยุกต์ใช้ตัวแปรคงที่ใน C ++
ตัวแปรส่วนกลางแบบคงที่จัดเตรียมกลไกที่ได้รับการควบคุมเพื่อรักษาสถานะหรือการกำหนดค่าที่เกี่ยวข้องกับไฟล์ที่กำหนดเท่านั้น แนวคิดของขอบเขตไฟล์ที่กำหนดโดยตัวแปรส่วนกลางแบบคงที่ช่วยอำนวยความสะดวกในการเขียนโปรแกรมแบบโมดูลาร์ที่สะอาดขึ้นโดยการป้องกันผลข้างเคียงที่ไม่ต้องการจากการเชื่อมโยงภายนอก ดังนั้นจึงนำไปสู่โค้ดที่บำรุงรักษาและป้องกันข้อผิดพลาดได้มากขึ้น ตัวแปรแบบคงที่สามารถใช้ได้ในสถานการณ์ต่างๆ และมีการแสดงรายการดังต่อไปนี้:
สถานการณ์ที่ 1: ตอบโต้ข้ามหลายฟังก์ชัน
เมื่อมีการประกาศตัวแปรด้วยคีย์เวิร์ดแบบคงที่ภายในฟังก์ชัน ตัวแปรจะคงสถานะไว้ในการเรียกฟังก์ชันเดียวกันหลายครั้ง ความสามารถในการรักษาสถานะของตัวแปรนี้จะเป็นประโยชน์ภายใต้สถานการณ์เฉพาะ ให้เราดูตัวอย่างเพื่อทำความเข้าใจตัวนับในหลายฟังก์ชันโดยใช้ตัวแปรส่วนกลางแบบคงที่ของ C++ รหัสตัวอย่างได้รับดังต่อไปนี้:
#รวม
เคาน์เตอร์คลาส {
ส่วนตัว:
int globalCounter แบบคงที่;
สาธารณะ:
การเพิ่มโมฆะเคาน์เตอร์ ( ) {
++เคาน์เตอร์ทั่วโลก;
}
int getCounterValue ( ) ค่าคงที่ {
กลับ โกลบอลเคาน์เตอร์;
}
} ;
int เคาน์เตอร์::globalCounter = 0 ;
int หลัก ( ) {
เคาน์เตอร์เคาน์เตอร์;
สำหรับ ( อินท์ ไอ = 0 ; ฉัน < 5 ; ++ผม ) {
counter.increationCounter ( ) ;
}
int counterValue = counter.getCounterValue ( ) ;
มาตรฐาน::cout << 'มูลค่าของตัวนับคือ:' << ค่าตัวนับ << มาตรฐาน::endl;
กลับ 0 ;
}
รหัสนี้กำหนดคลาส 'Counter' แบบธรรมดาที่มีสองฟังก์ชัน: 'increationCounter' ซึ่งจะเพิ่มตัวนับรวม 1 และ 'getCounterValue' ซึ่งส่งคืนค่าปัจจุบันของตัวนับส่วนกลาง โค้ดยังมีฟังก์ชันหลักที่อธิบายวิธีใช้คลาส 'Counter' โดยจะสร้างออบเจ็กต์ “ตัวนับ” เพิ่มตัวนับห้าครั้ง รับค่าของมัน และพิมพ์ลงบนคอนโซล การใช้งานนี้ใช้ตัวนับส่วนกลางเดียวที่ใช้ร่วมกันโดยวัตถุ 'ตัวนับ' ทั้งหมด ง่ายและเข้าใจง่าย แต่อาจไม่เหมาะกับสถานการณ์ที่คุณต้องการตัวนับอิสระหลายตัว ดูผลลัพธ์ของโปรแกรมต่อไปนี้:
ในตัวอย่างนี้ คุณจะสังเกตได้ว่าตัวแปรคงที่ 'globalCounter' จะคงสถานะไว้ระหว่างการเรียกใช้ฟังก์ชันต่างๆ เช่น 'increaseCounter' และ 'getCounterValue' ซึ่งทำหน้าที่เป็นตัวนับถาวรสำหรับหลายฟังก์ชันในไฟล์เดียวกัน
สถานการณ์ที่ 2: ฟังก์ชันยูทิลิตี้ที่ใช้ร่วมกันระหว่างอินสแตนซ์
เมื่อฟังก์ชั่นสมาชิกในคลาสถูกกำหนดให้เป็นแบบคงที่ ฟังก์ชั่นนั้นจะพร้อมใช้งานสำหรับอินสแตนซ์คลาสทั้งหมด อย่างไรก็ตาม ไม่สามารถเข้าถึงสมาชิกของอินสแตนซ์ได้เนื่องจากไม่มีตัวชี้ ให้เราเจาะลึกตัวอย่างที่เกี่ยวข้องต่อไปนี้เพื่อให้เข้าใจสถานการณ์นี้ได้ดีขึ้น:
#รวมยูทิลิตี้คลาสคลาส {
สาธารณะ:
ฟังก์ชันอรรถประโยชน์โมฆะคงที่ ( ) {
มาตรฐาน::cout << 'ฟังก์ชันยูทิลิตี้ถูกเรียกว่า' << มาตรฐาน::endl;
}
} ;
คลาส MyClass {
สาธารณะ:
โมฆะ callUtilityFunction ( ) {
UtilityClass::utilityFunction ( ) ;
}
} ;
int หลัก ( ) {
MyClass obj;
obj.callUtilityFunction ( ) ;
กลับ 0 ;
}
รหัสนี้กำหนดสองคลาส: “UtilityClass” และ “MyClass” “ UtilityClass” มีฟังก์ชันคงที่สาธารณะที่เรียกว่า “utilityFunction” ที่พิมพ์ 'เรียกว่าฟังก์ชันยูทิลิตี้' ไปยังคอนโซล “MyClass” มีฟังก์ชันสาธารณะที่เรียกว่า “callUtilityFunction” ซึ่งเรียกฟังก์ชัน “utilityFunction” ของ “UtilityClass”
ฟังก์ชั่นหลักสร้างวัตถุของ 'MyClass' ที่เรียกว่า 'obj' จากนั้นจะเรียกฟังก์ชัน 'callUtilityFunction' ของวัตถุ 'obj' ซึ่งทำให้ฟังก์ชัน 'utilityFunction' ของ 'UtilityClass' ถูกเรียก ซึ่งจะพิมพ์ 'เรียกใช้ฟังก์ชัน Utility' ไปยังคอนโซล ดูผลลัพธ์ของรหัสต่อไปนี้:
วิธีการนี้ช่วยลดความจำเป็นในการแยกอ็อบเจ็กต์และทำให้โครงสร้างโค้ดง่ายขึ้น คลาสมีสองวิธีในการเข้าถึง 'utilityFunction' วิธีหนึ่งคือโดยตรงซึ่งใช้ไวยากรณ์ UtilityClass::utilityFunction() ซึ่งสามารถเข้าถึงได้โดยไม่ต้องสร้างวัตถุ อีกวิธีหนึ่งคือผ่านออบเจ็กต์ที่ใช้ฟังก์ชันสมาชิก obj.callUtilityFunction() ซึ่งอนุญาตให้มีบริบทมากขึ้นและฟังก์ชันการทำงานเพิ่มเติมที่เป็นไปได้ภายในคลาส แนวทางนี้สร้างความสมดุลระหว่างความเรียบง่ายและความยืดหยุ่น ขึ้นอยู่กับรูปแบบการใช้งานที่คุณต้องการสำหรับฟังก์ชันยูทิลิตี้
สถานการณ์ที่ 3: ขอบเขตคลาสในตัวแปรส่วนกลางแบบคงที่
โดยไม่คำนึงถึงจำนวนอินสแตนซ์ของคลาส สมาชิกที่ถูกประกาศว่าเป็นสแตติกภายในคลาสจะมีอยู่ในสำเนาเดียวเท่านั้น สิ่งนี้ใช้ได้กับทั้งสมาชิกข้อมูล (ตัวแปร) และฟังก์ชันสมาชิก ที่สำคัญ คำจำกัดความของสมาชิกข้อมูลคงที่จะต้องเกิดขึ้นนอกการประกาศคลาส ซึ่งโดยทั่วไปจะอยู่ที่ขอบเขตของไฟล์
ต่อไปนี้เป็นตัวอย่างของสแตติกที่ใช้กับทั้งสมาชิกข้อมูลและฟังก์ชันสมาชิกใน C++:
#รวมเคาน์เตอร์คลาส {
สาธารณะ:
int globalCount แบบคงที่;
เคาน์เตอร์ ( ) {
++นับทั่วโลก;
}
โมฆะคงที่ printGlobalCount ( ) {
มาตรฐาน::cout << 'จำนวนทั่วโลกคือ:' << globalCount << มาตรฐาน::endl;
}
} ;
int เคาน์เตอร์::globalCount = 0 ;
int หลัก ( ) {
เคาน์เตอร์ เคาน์เตอร์1;
เคาน์เตอร์ เคาน์เตอร์2;
ตัวนับ::printGlobalCount ( ) ;
กลับ 0 ;
}
รหัสกำหนดคลาสที่เรียกว่า 'ตัวนับ' โดยมีตัวแปรสมาชิกคงที่ส่วนตัวชื่อ 'globalCount' และฟังก์ชันสมาชิกสาธารณะสองรายการ หนึ่งคือ Counter() ซึ่งเป็นฟังก์ชันคอนสตรัคเตอร์ที่เพิ่มตัวแปร 'globalCount' อีกอันคือ “printGlobalCount” ที่ส่งคืนค่าปัจจุบันของตัวแปร “globalCount” รหัสนี้ยังรวมถึงฟังก์ชันหลักด้วย ฟังก์ชันนี้สร้างอ็อบเจ็กต์สองรายการของคลาส 'Counter' ที่ระบุด้วยชื่อ 'counter1' และ 'counter2' หลังจากการประกาศตัวแปร มันจะเรียกฟังก์ชัน “Counter::printGlobalCount” ซึ่งน่าจะพิมพ์ค่าปัจจุบันของตัวแปร “globalCount” ดูตัวอย่างผลลัพธ์ต่อไปนี้:
ในตัวอย่างนี้ ตัวแปร 'globalCount' ได้รับการประกาศเป็นสมาชิกข้อมูลคงที่ภายในคลาส 'Counter' ซึ่งหมายความว่ามีเพียงสำเนาเดียวของตัวแปรนี้ โดยไม่คำนึงถึงจำนวนวัตถุ 'ตัวนับ' ที่ถูกสร้างขึ้น ตัวสร้างตัวนับ () จะเพิ่ม 'globalCount' สำหรับแต่ละอินสแตนซ์ แสดงให้เห็นถึงลักษณะที่ใช้ร่วมกันระหว่างวัตถุ “printGlobalCount” เป็นฟังก์ชันสมาชิกแบบคงที่ โปรดจำไว้ว่า ทำได้โดยใช้ชื่อของคลาสโดยตรง (Counter::printGlobalCount) ผลลัพธ์แสดงให้เห็นว่า 'globalCount' เพิ่มขึ้นตามที่คาดไว้ ซึ่งสะท้อนถึงสถานะที่ใช้ร่วมกันในทุกอินสแตนซ์ของคลาส 'Counter'
บทสรุป
โดยสรุป ตัวแปรโกลบอลแบบคงที่ใน C++ กลายเป็นเครื่องมืออเนกประสงค์ในการจัดการสถานะระหว่างฟังก์ชันและไฟล์ต่างๆ การเชื่อมโยงภายใน ลักษณะที่คงอยู่ และการแบ่งปันข้อมูลที่ควบคุม ทำให้สิ่งเหล่านี้มีคุณค่าในสถานการณ์การเขียนโปรแกรมบางอย่าง ด้วยการทำความเข้าใจคุณลักษณะ สำรวจกรณีการใช้งานที่หลากหลาย และรับทราบถึงข้อผิดพลาดที่อาจเกิดขึ้น นักพัฒนาจึงสามารถใช้ตัวแปรส่วนกลางแบบคงที่ได้อย่างมีประสิทธิภาพ ปรับปรุงความเป็นโมดูลของโค้ด และอำนวยความสะดวกในการสื่อสารระหว่างส่วนต่างๆ ของโครงการของตน ด้วยการพิจารณาอย่างถี่ถ้วนและการยึดมั่นในแนวทางปฏิบัติที่ดีที่สุด ตัวแปรส่วนกลางแบบคงที่จึงสามารถถูกควบคุมเพื่อสนับสนุนการออกแบบและฟังก์ชันการทำงานของโปรแกรม C++ ในเชิงบวก