คลาสพื้นที่เก็บข้อมูลใน C: อัตโนมัติ, ภายนอก, คงที่, รีจิสเตอร์ (ตัวอย่าง)

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

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

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

ดังนั้นคลาสการจัดเก็บข้อมูลจึงถูกใช้เพื่อแสดงข้อมูลเกี่ยวกับตัวแปร

หมายเหตุ: ตัวแปรไม่ได้เกี่ยวข้องกับเพียงแค่ ประเภทข้อมูลค่าของมัน แต่ยังเป็นคลาสการจัดเก็บข้อมูลด้วย

ประเภทของคลาสการจัดเก็บข้อมูลในภาษา C คืออะไร?

คลาสพื้นที่จัดเก็บข้อมูลมาตรฐานมีทั้งหมดสี่ประเภท ตารางด้านล่างแสดงถึงคลาสการจัดเก็บข้อมูลในภาษาซี

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

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

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

คำหลัก auto ใช้เพื่อกำหนดคลาสการจัดเก็บข้อมูลอัตโนมัติ ตามค่าเริ่มต้น ตัวแปรอัตโนมัติมีค่าขยะ

Example, auto int age;

โปรแกรมด้านล่างกำหนดฟังก์ชันที่มีตัวแปรท้องถิ่นสองตัว

int add(void) {
   int a=13;
   auto int b=48;
return a+b;}

เราใช้โปรแกรมอื่นที่แสดงระดับขอบเขต "ระดับการมองเห็น" สำหรับตัวแปรอัตโนมัติในแต่ละรหัสบล็อกซึ่งแยกจากกัน:

#include <stdio.h>
int main( )
{
  auto int j = 1;
  {
    auto int j= 2;
    {
      auto int j = 3;
      printf ( " %d ", j);
    }
    printf ( "\t %d ",j);
  }
  printf( "%d\n", j);}

Output:

 3 2 1

คลาสการจัดเก็บข้อมูลภายนอกใน C

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

คีย์เวิร์ด extern ใช้สำหรับประกาศตัวแปรหรือฟังก์ชันส่วนกลางในไฟล์อื่น เพื่อให้สามารถอ้างอิงถึงตัวแปรหรือฟังก์ชันที่ได้กำหนดไว้แล้วในไฟล์ต้นฉบับ

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

Example, extern void display();

ไฟล์แรก: main.c

#include <stdio.h>
extern i;
main() {
   printf("value of the external integer is = %d\n", i);
   return 0;}

ไฟล์ที่สอง: original.c

#include <stdio.h>
i=48;

ผลลัพธ์:

 value of the external integer is = 48

เพื่อคอมไพล์และรันโค้ดข้างต้น ให้ทำตามขั้นตอนด้านล่าง

ขั้นตอนที่ 1) สร้างโปรเจ็กต์ใหม่

• เลือกแอปพลิเคชันคอนโซล
• ClickGo

ขั้นตอนที่ 2) เลือก C แล้วคลิกถัดไป

ขั้นตอนที่ 3) คลิกถัดไป

ขั้นตอนที่ 4) กรอกรายละเอียดแล้วคลิก ถัดไป

ขั้นตอนที่ 5) คลิก เสร็จสิ้น

ขั้นตอนที่ 6) นำโค้ดหลักตามที่แสดงในโปรแกรมก่อนหน้าใส่ลงในไฟล์ main.c แล้วบันทึก

ขั้นตอนที่ 7) สร้างไฟล์ C ใหม่ [ไฟล์ -> ใหม่ -> ไฟล์เปล่า] บันทึก (เป็น original.c) และเพิ่มลงในโปรเจ็กต์ปัจจุบันโดยคลิก “ตกลง” ในกล่องโต้ตอบ

ขั้นตอนที่ 8) นำโค้ดภาษา C ของไฟล์ original.c ที่แสดงในตัวอย่างก่อนหน้านี้มาบันทึก โดยไม่ต้องมีฟังก์ชัน main()

ขั้นตอนที่ 9) สร้างและเรียกใช้โปรเจ็กต์ของคุณ ผลลัพธ์จะแสดงในรูปถัดไป

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

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

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

Example: static int count = 10;

โปรดทราบว่าตัวแปรคงที่มีค่าเริ่มต้นเป็นศูนย์และจะเริ่มต้นได้เพียงครั้งเดียวตลอดอายุการใช้งาน

#include <stdio.h> /* function declaration */
void next(void);
static int counter = 7; /* global variable */
main() {
 while(counter<10) {
      next();
      counter++;   }
return 0;}
void next( void ) {    /* function definition */
   static int iteration = 13; /* local static variable */
   iteration ++;
   printf("iteration=%d and counter= %d\n", iteration, counter);}

ผลลัพธ์:

iteration=14 and counter= 7
iteration=15 and counter= 8
iteration=16 and counter= 9

ตัวแปรส่วนกลางสามารถเข้าถึงได้ทั่วทั้งไฟล์ ในขณะที่ตัวแปรแบบคงที่สามารถเข้าถึงได้เฉพาะบางส่วนของโค้ดเท่านั้น

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

ลงทะเบียนคลาสการจัดเก็บใน C

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

Example: register int age;

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

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

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

#include <stdio.h> /* function declaration */
main() {
{register int  weight;
int *ptr=&weight ;/*it produces an error when the compilation occurs ,we cannot get a memory location when dealing with CPU register*/}
}

Output:

error: address of register variable 'weight' requested

ตารางต่อไปนี้จะสรุปคุณลักษณะหลักของแต่ละคลาสการจัดเก็บข้อมูลซึ่งมักใช้ในการเขียนโปรแกรม C

คำถามที่พบบ่อย