Storage Class ใน C ++ คืออะไรและประเภทของมันคืออะไร?

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

• คลาสพื้นที่เก็บข้อมูลใน C ++ คืออะไร?
• ประเภทของคลาสการจัดเก็บ
  • อัตโนมัติ
  • ลงทะเบียน
  • คงที่
  • ภายนอก
  • ไม่แน่นอน

เอาล่ะ.

Storage Class ใน C ++ คืออะไร?

ทุกตัวแปรใน C ++ มีประเภทข้อมูลและคลาสการจัดเก็บ ชนิดข้อมูลระบุชนิดของข้อมูลที่สามารถเก็บไว้ในตัวแปรเช่น int, float, char เป็นต้นคลาส Storage ควบคุมคุณสมบัติที่แตกต่างกันสองคุณสมบัติของตัวแปร: อายุการใช้งานและขอบเขต

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

ประเภทของชั้นเก็บข้อมูล

มีคลาสพื้นที่เก็บข้อมูลห้าคลาสในโปรแกรม C ++:

• อัตโนมัติ
• ลงทะเบียน
• คงที่
• ภายนอก
• ไม่แน่นอน

เรามาดูรายละเอียดของคลาสพื้นที่เก็บข้อมูลแต่ละคลาสกัน

คลาสการจัดเก็บอัตโนมัติ

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

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

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

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

ตามค่าเริ่มต้นค่าขยะจะถูกกำหนดให้กับพวกเขาในขณะที่ประกาศ

ไวยากรณ์:

ประเภทข้อมูล var_name1 [= value]

หรือ

ประเภทข้อมูลอัตโนมัติ var_name1 [= ค่า]

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

ลงทะเบียน Storage Class

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

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

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

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

ไวยากรณ์:

ลงทะเบียนประเภทข้อมูล var_name1 [= value]

ตัวอย่าง:

รหัสรายการที่เชื่อมโยงในค

{ลงทะเบียน int pi}

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

มาดูตัวอย่างคลาสการลงทะเบียนและที่เก็บข้อมูลอัตโนมัติ

ตัวอย่าง:

#include โดยใช้เนมสเปซ std // การประกาศตัวแปรที่จะสร้าง extern // ค่า intial สามารถเริ่มต้นเป็น x int x void autoStorageClass () {printf ('nDemonstrating auto classnn') // การประกาศตัวแปรอัตโนมัติ (เพียง // การเขียน 'int a = 32' ก็ใช้ได้เช่นกัน) int num = 32 // การพิมพ์ตัวแปรอัตโนมัติ 'a' printf ('ค่าของตัวแปร' num '' 'ที่ประกาศเป็น auto:% dn', num) printf ( '--------------------------------')} โมฆะ registerStorageClass () {printf ('nDemonstrating register classnn') / / การประกาศรีจิสเตอร์ตัวแปร register char c = 'G' // การพิมพ์ตัวแปร register 'b' printf ('ค่าของตัวแปร' c '' 'ที่ประกาศเป็น register:% dn', c) printf ('---- ---------------------------- ')} int main () {// เพื่อสาธิตคลาส Storage อัตโนมัติ autoStorageClass () // เพื่อสาธิต ลงทะเบียน Storage Class registerStorageClass () return 0}

เอาท์พุต:

คลาสการจัดเก็บแบบคงที่

คลาสหน่วยเก็บแบบคงที่ใช้ในการประกาศ ตัวแปรคงที่ . ตัวแปรแบบคงที่จะรักษาค่าไว้ (นั่นคือค่าสุดท้าย) แม้ว่าจะอยู่นอกขอบเขตก็ตาม ตัวแปรคงเริ่มต้นเพียงครั้งเดียว &มีอยู่จนถึงการยุติโปรแกรม

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

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

ไวยากรณ์:

ประเภทข้อมูลคง var_name1 [= value]

ตัวอย่าง:

#include void function (void) static int c = 5 // Global static variable main () {while (c--) {function ()} return 0} ฟังก์ชัน void (void) {static int cnt = 2 cnt ++ std :: cout<< 'cnt is ' << cnt std::cout << ' and c is ' << c << std::endl } 

ความแตกต่างระหว่างคลาสและอินเทอร์เฟซใน java

เอาท์พุต:

คลาสพื้นที่จัดเก็บ Extern

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

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

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

ไวยากรณ์

ชนิดข้อมูลภายนอก var_name1

ตัวอย่าง

# รวม int cnt extern เป็นโมฆะ write_extern () main () {cnt = 5 write_extern ()}

ไฟล์ที่สอง: support.cpp

#include extern int cnt void write_extern (void) {std :: cout<< 'Count is ' << cnt << std::endl } 

ที่นี่มีการใช้คีย์เวิร์ดภายนอกเพื่อประกาศ cnt ในไฟล์อื่น ตอนนี้รวบรวมสองไฟล์ดังต่อไปนี้ & ลบ

$ g ++ main.cpp support.cpp -o เขียน

สิ่งนี้จะสร้างโปรแกรมที่เรียกใช้งานการเขียนลองดำเนินการเขียนและตรวจสอบผลลัพธ์ดังนี้ & ลบ

$. / เขียน

5

ก้าวไปข้างหน้าด้วยคลาสพื้นที่เก็บข้อมูลใน C ++ มาดูคลาสสุดท้ายนั่นคือคลาสพื้นที่เก็บข้อมูลที่เปลี่ยนแปลงได้

คลาสการจัดเก็บที่ไม่แน่นอน

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

ในที่สุดเรามาดูตารางเปรียบเทียบเพื่อทำความเข้าใจความแตกต่างระหว่างคลาสพื้นที่เก็บข้อมูลต่างๆ

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

ดังนั้นเราจึงมาถึงตอนท้ายของบทความนี้ใน 'คลาสการจัดเก็บใน C ++'

หากคุณต้องการเรียนรู้เพิ่มเติมโปรดดูไฟล์ โดย Edureka บริษัท การเรียนรู้ออนไลน์ที่เชื่อถือได้ หลักสูตรการฝึกอบรมและการรับรอง Java J2EE และ SOA ของ Edureka ได้รับการออกแบบมาเพื่อฝึกอบรมคุณสำหรับแนวคิด Java ทั้งหลักและขั้นสูงพร้อมกับกรอบงาน Java ต่างๆเช่น Hibernate & Spring

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