ชนิดข้อมูลและช่วงของข้อมูลใน C (Data Types and Their Ranges in C)

ภาพรวม


ประเภทข้อมูลในภาษา C (หรือในภาษาการเขียนโปรแกรมใดๆ) เป็นสิ่งสำคัญมากในการเรียนรู้และทำความเข้าใจก่อนที่คุณจะเริ่มเขียนโปรแกรม

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


ขอบเขต

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



ทำไมเราต้องการชนิดข้อมูลในC


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

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

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

ชนิดข้อมูลใน C . คืออะไร


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

อาจเป็นประเภท integer, float( decimal), character , boolean( true/false )  เป็นต้น

อย่างเป็นทางการ เราใช้ประเภทข้อมูลเพื่อระบุประเภทของข้อมูลที่ตัวแปรของเราถืออยู่

โดยทั่วไปมีประเภทข้อมูลสองประเภทใน C:

a. ชนิดข้อมูลหลักหรือชนิดข้อมูลพื้นฐาน และ b. ชนิดข้อมูลรอง

A. ประเภทข้อมูลหลักหรือประเภทข้อมูลพื้นฐาน

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

ชนิดข้อมูลหลัก/พื้นฐาน 4 ชนิดได้แก่:

  1. Integer
  2. Float
  3. Char
  4. Void

ตอนนี้สิ่งเหล่านี้ถูกจัดประเภทเพิ่มเติมเป็นชนิดข้อมูล  short, long,double, long double, signed และ unsigned ใน C

ก่อนที่จะพูดถึงเรื่องนี้ ให้เราเข้าใจก่อนว่าชนิดข้อมูล short, long, signed และ unsigned ในภาษา C หมายถึงอะไร

SHORT AND LONG

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


SIGNED AND UNSIGNED

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

ให้เราเข้าใจผ่านตัวอย่าง ชนิดข้อมูลจำนวนเต็มประกอบด้วยหน่วยความจำ 2 ไบต์

1 ไบต์ = 8 บิต 2 ไบต์ = 16 บิต

จำนวนหลัก = 2^(2 Byte)= 2^(16 bits)= 65536

ในกรณีของชนิดข้อมูล int ที่ไม่ได้ลงนาม จะมีเพียงจำนวนบวกเท่านั้น และเนื่องจากศูนย์รวมอยู่ในจำนวนบวกด้วย ดังนั้น int ที่ไม่ได้ลงนามจึงสามารถรับค่าได้ตั้งแต่ 0 ถึง 65535

ตอนนี้ให้เราพิจารณากรณีของชนิดข้อมูลที่ลงนามแล้ว ซึ่งมีทั้งตัวเลขบวกและลบ ดังนั้นความยาวหน่วยความจำปัจจุบันทั้งหมดจึงถูกแบ่งออกเป็นสองส่วนเท่าๆ กัน (65536/2= 32768) ครึ่งหนึ่งแทนจำนวนบวก ( 0 ถึง 32676 ) และอีกครึ่งหนึ่งแทนจำนวนลบ (-1 ถึง -32768)

สิ่งนี้ใช้ได้กับประเภทข้อมูลประเภทอื่น ๆ ทั้งหมดเช่น float char เป็นต้น

ในทำนองเดียวกัน คุณสามารถค้นหาช่วงของค่าของประเภทข้อมูลทั้งหมด เช่น float, char, double เป็นต้น


LONG AND LONG DOUBLE


ส่วนใหญ่จะใช้กับเลขทศนิยม โดยใช้คำนำหน้าเหล่านี้ เราสามารถเพิ่มช่วงของค่าที่แสดงเป็นทศนิยมได้ Float มีขนาด 4 ไบต์ double คือ 8 ไบต์และ long double คือ 10 ไบต์

โดยใช้ความสัมพันธ์ที่กล่าวถึงข้างต้น (ชนิดข้อมูล int) เราสามารถคำนวณความยาวของตัวเลขในทศนิยมและทศนิยม

ตัวอย่างเช่น float ใช้เวลา 4 ไบต์ นั่นคือ 32 บิต (4*8)

ดังนั้นความยาวของตัวเลขจะเป็น: 2^(32)= 4,29,49,67,296

กรณีดับเบิ้ลใช้ 8 ไบต์ 64 บิต(8*8)

ดังนั้นความยาวของตัวเลขจะเป็น: 2^(64)= 1,84,46,74,40,73,70,95,51,616

1. ชนิดข้อมูล CHAR ใน C


มันถูกใช้เพื่อเก็บอักขระตัวเดียวและต้องใช้ 1 ไบต์ อักขระอาจเป็นตัวอักษร ตัวเลข หรืออักขระพิเศษใดๆ ที่เขียนด้วยเครื่องหมายจุลภาคแบบกลับด้านเดียว เช่น ‘1’, ‘a’, ‘#’ เป็นต้น

เนื่องจากต้องใช้ 1 ไบต์ซึ่งเท่ากับ 8 บิต จำนวนอักขระในภาษา C คือ 256(2^8) พื้นที่หน่วยความจำแตกต่างกับการใช้คำนำหน้า

#include <stdio.h>
void main() {
   char c; 
   c = 'a' ;
   printf("%c",c); 
}


เอาท์พุต


2. ชนิดข้อมูล INT ใน C

มันถูกใช้เพื่อเก็บค่าจำนวนเต็มและต้องการหน่วยความจำตามค่าของจำนวนเต็มที่เราต้องการเก็บ

ขนาดของ int ขึ้นอยู่กับคอมไพเลอร์ ตัวอย่างเช่น คอมไพเลอร์ 32 บิตมี int เป็น 2 ไบต์ แต่คอมไพเลอร์ 64 บิต (ซึ่งเราใช้อยู่ตอนนี้) มี int เป็น 4 ไบต์

และเนื่องจากขนาดแตกต่างกัน ช่วงของค่าจำนวนเต็มจึงสามารถจัดเก็บได้แตกต่างกันไปตามคอมไพเลอร์ไปจนถึงคอมไพเลอร์

สำหรับ 2 ไบต์ คือ 0 ถึง 65,535

สำหรับ 4 ไบต์ มันคือ 0 ถึง 4,29,49,67,296

#include <stdio.h>
void main() {
   int i; 
   i = 10;
   printf("%d",i); 
}


เอาท์พุต



3. FLOAT

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

สำหรับคอมไพเลอร์ 32 บิตและ 64 บิต จะเหมือนกับ 4 ไบต์ นั่นคือความยาวของค่า 2^(4*8) ซึ่งเท่ากับ 4,29,49,67,296 เช่น 0 ถึง 4,29,49,67,296 ตัวเลขสามารถแสดงโดยใช้ทศนิยม

#include <stdio.h>  
void main() {
   float f; 
   f = 1.20 ;
   printf("%f",f); 
 }


เอาท์พุต

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

#include <stdio.h>
int main() {
  printf("short int is %2d bytes \n", sizeof(short int));
  printf("int is %2d bytes \n", sizeof(int));
  printf("int * is %2d bytes \n", sizeof(int *));
  printf("long int is %2d bytes \n", sizeof(long int));
  printf("long int * is %2d bytes \n", sizeof(long int *));
  printf("signed int is %2d bytes \n", sizeof(signed int));
  printf("unsigned int is %2d bytes \n", sizeof(unsigned int));
  printf("\n");
  printf("float is %2d bytes \n", sizeof(float));
  printf("float * is %2d bytes \n", sizeof(float *));
  printf("double is %2d bytes \n", sizeof(double));
  printf("double * is %2d bytes \n", sizeof(double *));
  printf("long double is %2d bytes \n", sizeof(long double));
  printf("\n");
  printf("signed char is %2d bytes \n", sizeof(signed char));
  printf("char is %2d bytes \n", sizeof(char));
  printf("char * is %2d bytes \n", sizeof(char *));
  printf("unsigned char is %2d bytes \n", sizeof(unsigned char));
  return 0; 
}



4. VOID

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

ต่อไปนี้เป็นข้อมูลขนาดประเภทข้อมูลตามคอมไพเลอร์ 32 บิตและคอมไพเลอร์ 64 บิต

B. ประเภทข้อมูลรอง (Secondary Data Types)


ชนิดข้อมูลรองเกิดขึ้นจากการรวมชนิดข้อมูลหลักสองชนิดขึ้นไปใน C

ส่วนใหญ่เป็นสองประเภท:

  1. ผู้ใช้กำหนดประเภทข้อมูล (USER DEFINED DATA TYPES)
  2. ประเภทข้อมูลที่ได้รับ (DERIVED DATA TYPE)


1. ผู้ใช้กำหนดประเภทข้อมูลใน C (USER DEFINED DATA TYPES)

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

1. STRUCTURE

STRUCTURE เป็นชนิดข้อมูลที่ผู้ใช้กำหนดใน C ซึ่งเราสามารถจัดเก็บค่าของข้อมูลหลายประเภท

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

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

#include <stdio.h> 
#include <string.h>
  
struct Student {
   char name[50];
   int roll_no;
   float marks;
};

int main() {
   struct Student student1;
   strcpy(student1.name, "Ankush");
   student1.roll_no = 20; 
   student1.marks = 99.99; 
   
   return 0;
}

2. UNION

UNION ค่อนข้างคล้ายกับโครงสร้างเนื่องจากใช้เพื่อเก็บค่าของข้อมูลหลายประเภท

#include <stdio.h>
#include <string.h>
union Emp {
   float F;
   char X;
}e;

int main() {
   union Emp e;        
   e.F = 2.0;
   e.X = ‘a’;

   return 0;
}

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

สมมติว่าเรามีสองตัวแปร หนึ่งในประเภท float (4 ไบต์) และหนึ่งในประเภท char (1 ไบต์) ตอนนี้ struct จะต้องมีหน่วยความจำ 5 ไบต์ (4 ไบต์ของ float ใน 1 ไบต์ของถ่าน) แต่ยูเนี่ยนจะต้องมี 4 ไบต์ (4 ไบต์ของ float ซึ่งเป็นจำนวนสูงสุดในบรรดาตัวแปรทั้งหมด)

3. TYPEDEF

เป็นคีย์เวิร์ดที่มีอยู่ใน C ซึ่งใช้เพื่อตั้งชื่อใหม่ให้กับข้อมูลทุกประเภท

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

typedef unsigned long int ul; ul i1, i2;

4. ENUM

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

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

ในรูปด้านล่างที่กำหนด 0 จะถูกกำหนดให้เป็น Jan, 1 เป็น Feb, 3 เป็น Apr  เป็นต้น

#include<stdio.h>
enum Months{Jan,Feb,Mar,April,May, June, July};

int main() {
    enum Months month;
    month = April;
    printf("%d",month);
    return 0;
} 


เอาท์พุท:


2. ชนิดข้อมูลที่ได้รับ (DERIVED DATA TYPES)


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

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

  1. ARRAY
  2. STRING
  3. POINTER
  4. FUNCTIONS

1. ARRAY

Array อาร์เรย์เป็นประเภทข้อมูลที่ได้รับซึ่งใช้ในการจัดเก็บข้อมูลประเภทเดียวกันในตำแหน่งหน่วยความจำที่อยู่ติดกัน เราสามารถจัดเก็บข้อมูลประเภทใดก็ได้ตั้งแต่ int , float , double , char ไปจนถึง pointer , string , โครงสร้าง นั่นคือเราสามารถสร้างอาร์เรย์ของชนิดข้อมูลพื้นฐานที่ผู้ใช้กำหนดหรือที่ได้รับมา

Array ให้การเข้าถึงแบบสุ่ม นั่นคือ เราสามารถรับค่าขององค์ประกอบใดๆ ในอาร์เรย์โดยใช้ค่าดัชนีของมัน

ในภาพที่แสดงด้านบน คุณสามารถดูวิธีการจัดเก็บองค์ประกอบในอาร์เรย์ (ในลักษณะต่อเนื่องกัน) และวิธีสร้างดัชนี (เริ่มต้นด้วย 0 ไม่ใช่ 1) นั่นคือองค์ประกอบที่ 9 เข้าถึงได้โดยใช้ดัชนี 8

ตัวอย่างเช่น หากคุณต้องการเก็บเครื่องหมายทั้งหมดของคุณ คุณสามารถใช้อาร์เรย์จำนวนเต็ม จากนั้นคุณสามารถเข้าถึงเครื่องหมายของคุณโดยใช้ดัชนี ให้เราเข้าใจมันผ่านรหัส (หากคุณจะสังเกตรหัสอย่างระมัดระวัง องค์ประกอบที่ดัชนี ith สามารถเข้าถึงได้โดยใช้ arr[i])

#include <stdio.h>
int main() {

  int x = 0, num[4];

  for (x = 0; x < 4; x++) {
    num[x] = (x + 1) * x;
  }

  for (x = 0; x < 4; x++) {
    printf("%d \n", num[x]);
  }

  return 0;
}


เอาท์พุต


เราสามารถสร้างอาร์เรย์ของโครงสร้างได้

#include <stdio.h> 
#include <string.h>   
struct student {   
  int rollno;   
  char name[10];   
};  

int main() {
    int i;   
    struct student st[2];   
    printf("Enter Records of 2 students");

    for(i = 0; i < 2; i++) {  
        printf("\nEnter Rollno:");   
        scanf("%d",&st[i].rollno);   
        printf("\nEnter Name:");   
        scanf("%s",&st[i].name);  
    }
    
    printf("\nStudent Information List:");  
    for(i = 0; i < 2; i++) {   
        printf("\nRollno:%d, Name:%s",st[i].rollno,st[i].name);
    }
    
 return 0;
}

Input

Enter Records of 2 students
Enter Rollno:1
Enter Name:Ankush
Enter Rollno:2
Enter Name:Shreyas

Output

Student Information List:
Rollno:1, Name:Ankush
Rollno:2, Name:Shreyas


2. STRING

สตริงคืออาร์เรย์ของอักขระ ความแตกต่างระหว่างอาร์เรย์อักขระปกติและสตริงคือ สตริงมีค่า ‘\0’ ที่ส่วนท้าย ซึ่งบ่งชี้ว่านี่คือจุดสิ้นสุดของสตริง ในขณะที่อาร์เรย์อักขระธรรมดาไม่จำเป็นต้องมีสิ่งนี้

‘\0’ เป็นอักขระพิเศษ ซึ่งเรียกว่าอักขระ NULL และใช้เพื่อระบุการสิ้นสุดของสตริง

มีหลายวิธีในการเริ่มต้นสตริงใน C

ในภาพที่แสดงด้านบน คุณสามารถดูวิธีจัดเก็บอักขระภายในเป็นสตริงได้อย่างไร ใช่ มันเป็นไปตามคุณสมบัติการจัดทำดัชนีของอาร์เรย์ ดังนั้น สตริงจึงเรียกว่าอาร์เรย์ของอักขระ สังเกต ‘\0’ (NULL) ที่ส่วนท้ายของสตริง มันหมายถึงจุดสิ้นสุดของสตริง

#include <stdio.h>
int main() {
   char str1[6] = {'H', 'e', 'l', 'l', 'o', '\0'};\
   char str2[] = "Hello";
   printf("Say: %s\n", str1 );
   printf("Say: %s\n", str2 );
   return 0;
}


เอาท์พุต


เราสามารถสำรวจอักขระแต่ละตัวของสตริงโดยใช้ความยาวหรือโดยใช้ ‘\0’ ให้เราดูว่า:

#include <stdio.h>  

void main() {  
  char hey[6] = "hello";  
  int i = 0;      
    
  while (i < 6)  {  
    printf("The ith character is",hey[i]); 
    i++;
  }  
  printf("\n");
  char bye[7] = "GoodBye"; 
  int j = 0; 
  while (bye[j]!=NULL) {
  /* This will not work if there is no ‘\0’ at the end of string */                        
  printf("The jth character is \n", bye[j]);
  j++; 
} 
    
}

3. POINTER

POINTER เป็นชนิดข้อมูลพิเศษ ค่าเหล่านี้มีความพิเศษเนื่องจากไม่เหมือนกับข้อมูลประเภทอื่นๆ ที่ไม่มีการเก็บค่าปกติไว้ในตัวแปร เนื่องจากเราทุกคนทราบดีว่าหน่วยความจำแต่ละบล็อกในหน่วยความจำของคอมพิวเตอร์มีที่อยู่เฉพาะ (เหมือนกับที่อยู่บ้านในสังคม) ตัวแปรตัวชี้เหล่านี้เก็บที่อยู่ของตำแหน่งหน่วยความจำดังกล่าว ตอนนี้พอยน์เตอร์ก็เป็นตัวแปรประเภทหนึ่งเช่นกัน ดังนั้นจึงต้องการตำแหน่งหน่วยความจำและพื้นที่หน่วยความจำเพื่อเก็บค่า และจากการสนทนาข้างต้น เราทราบดีว่าพื้นที่หน่วยความจำที่จัดสรรให้กับประเภทข้อมูลใดๆ ขึ้นอยู่กับประเภทของค่าที่จะจัดเก็บและพอยน์เตอร์เก็บที่อยู่หน่วยความจำ ขนาดที่อยู่หน่วยความจำขึ้นอยู่กับการกำหนดค่าคอมพิวเตอร์ ไม่ว่าจะเป็น 32 บิตหรือ 64 บิต หากเป็น 32 บิต ขนาดจะเป็น 2 ไบต์ และหากเป็น 64 บิต ขนาดจะเป็น 4 ไบต์ จากการสนทนาข้างต้น เราสามารถพูดได้ว่าขนาดของตัวชี้จะเป็น 2 ไบต์และ 4 ไบต์ นอกจากนี้ ชนิดข้อมูลของพอยน์เตอร์จะเหมือนกับชนิดข้อมูลของตัวแปรที่มีที่อยู่ซึ่งจัดเก็บอยู่เสมอ

คำถามสั้นๆ สำหรับพวกคุณ ทำไมพอยน์เตอร์ทั้งหมดจึงมีขนาดเท่ากัน? คำตอบถูกซ่อนอยู่ในการสนทนาข้างต้น ถ้าไม่เข้าใจก็อ่านซ้ำ !!

ตอนนี้เราสามารถดำเนินการหลักสองอย่างด้วยความช่วยเหลือของพอยน์เตอร์ ประการแรก เราสามารถเก็บที่อยู่ของตัวแปรที่เรียกว่าการกำหนดค่าเริ่มต้น และประการที่สอง เราสามารถเก็บค่าที่อยู่นั้นได้ ซึ่งเรียกว่า dereferencing ‘&’ ใช้สำหรับการเริ่มต้นและ ‘*’ ใช้สำหรับยกเลิกการอ้างอิง

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

int i = 10;   // variable i is of int type storing value 10
int* p = NULL;  // p is a variable of pointer data type<br>
p = &i  // now p will contain address of variable i,&i denotes address of i
 
(*p)++ // *p gives the value at i, p will be incremented by 1 printf(‘%d’, i) // value of i will be 11 now.


คุณสามารถเข้าใจแนวคิดนี้ได้จากการแสดงรูปภาพด้านล่าง

4. FUNCTIONS


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

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

เพื่อจัดการกับสถานการณ์ประเภทนี้ เราใช้ฟังก์ชันซึ่งทำงานที่ต้องการสำหรับผู้ใช้ ( ฟังก์ชันผลรวมในกรณีนี้)

มีฟังก์ชันหลักอยู่ในทุกโปรแกรม C ส่วนฟังก์ชันอื่นๆ ทั้งหมดมีการประกาศไว้ที่นั่นเท่านั้น

นอกเหนือจากฟังก์ชันหลักแล้ว ผู้ใช้ต้องการเพิ่มฟังก์ชันกี่ฟังก์ชัน

การประกาศฟังก์ชันใน C


ด้านล่างเป็นรหัสของผลรวมของตัวเลขสองตัวที่ป้อนจากผู้ใช้:

#include <stdio.h>
int sum(int a, int b){
   return a+b;
}
int main() {
   int num1, num2, num3;
   num1 = 2, num2 = 6;   
   num3 = sum(num1, num2);  // Calling the function.
   printf("Sum of numbers: %d", num3);
   return 0;
}


เอาท์พุต



โดยสรุป ชนิดข้อมูลใช้เพื่อกำหนดประเภทของข้อมูลที่ตัวแปรประกอบด้วย อาจเป็นประเภทดั้งเดิม (ธรรมดา) เช่น จำนวนเต็ม อักขระ ทุ่น หรือรอง (ซับซ้อนเล็กน้อย) เช่น struct, union, array, pointer เป็นต้น

เราสามารถใช้ชนิดข้อมูลที่กำหนดไว้ล่วงหน้าใดๆ ตามที่โปรแกรมของเราต้องการ หรือเพียงแค่สร้างประเภทข้อมูลของเราเอง (array, struct, union) หากเราไม่พบชนิดข้อมูลที่กำหนดไว้ล่วงหน้าที่เหมาะสม

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

และเมื่อคุณเริ่มใช้งาน คุณจะรู้สึกสบายใจขึ้น


credit : https://www.scaler.com/topics/c/

Leave a Reply

Your email address will not be published. Required fields are marked *