ชนิดข้อมูลและช่วงของข้อมูลใน 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 ชนิดได้แก่:
- Integer
- Float
- Char
- 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
ส่วนใหญ่เป็นสองประเภท:
- ผู้ใช้กำหนดประเภทข้อมูล (USER DEFINED DATA TYPES)
- ประเภทข้อมูลที่ได้รับ (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 มีประเภทข้อมูลที่ได้รับ ซึ่งเราสามารถใช้ตามความสะดวกของเรา
- ARRAY
- STRING
- POINTER
- 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/