โทเค็นใน C (Tokens in C)

โทเค็นใน C (Tokens in C)

ภาพรวม

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

โทเค็นในภาษา C เป็นองค์ประกอบที่เล็กที่สุดหรือหน่วยการสร้างที่ใช้ในการสร้างโปรแกรม C โทเค็นC มี 6 ประเภท และจัดประเภทเป็น: Identifiers , Keywords , Constants , Operators , Special Characters and Strings

ขอบเขตของบทความ

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

โทเค็นใน C คืออะไร?

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

ตัวอย่าง:

#include <stdio.h>

int main(){
    printf("Hello World!");
    return 0;
}

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

กระบวนการคอมไพล์:
โปรแกรม C —> จัดกลุ่มอักขระเป็นโทเค็น C —> แปลโทเค็นเป็นโค้ดเป้าหมาย

ประเภทของโทเค็นในภาษาซี

โทเค็นในภาษา C สามารถจำแนกได้ดังนี้:

• Keywords
• Identifiers
• Constants
• Special Characters
• Strings
• Operators

Keywords

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

ตัวอย่าง:
ที่นี่ เรากำลังใช้คำหลัก int , char และ auto เราสามารถใช้ คำสำคัญ อัตโนมัติเพื่ออนุมานประเภทข้อมูลของตัวแปรใดก็ได้

ในตัวอย่างนี้ แทนที่จะใช้ int และ character array เราสามารถใช้ auto keyword ซึ่งจะระบุประเภทข้อมูลโดยอัตโนมัติเพื่อวัตถุประสงค์ในการจัดเก็บ

int num = 10; //int keyword
char firm[10] = "Scaler"; //char keyword

These two lines can be modified as: (without knowing the data-type)
auto num = 10; //auto keyword is used to deduce the data-type of a variable 
auto firm = "Scaler";

Identifiers

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

มีกฎที่กำหนดไว้ในภาษา C สำหรับการประกาศ identifiers:

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

ตัวระบุที่ถูกต้องบางส่วน:

scaler, _scaler, scaler123, scaler_123, count1_, Double

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

ตัวระบุที่ไม่ถูกต้อง:

100scaler        //started with a numerical digit
_hello,morning  //can't use comma operator
int            //keyword
float         //keyword
Delhi(100)   //circular brackets can't be used

ตัวอย่างข้างต้นไม่เป็นไปตามกฎสำคัญทั้งหมดสำหรับการกำหนดตัวระบุ ดังนั้นจึงเป็นตัวระบุที่ไม่ถูกต้อง

Constants

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

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

เราสามารถประกาศค่าคงที่ในภาษา C โดยใช้:

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

const variable_name = value; //We can assign a constant value to variable_name 

#define ตัวประมวลผลล่วงหน้า ที่นี่เราใช้ #define ตัวประมวลผลล่วงหน้า และค่าคงที่ ll จะเป็นชื่อแทนสำหรับคำหลักแบบยาว

#define ll long //Here, constant ll will be treated as an alias name for long

ประเภทของค่าคงที่ในภาษาซี

ค่าคงที่ในภาษาซี สามารถจำแนกได้เป็น 2 ประเภท คือ

Primary Constants

Numeric  -> Numeric constant คือค่าตัวเลขลบหรือค่าบวกที่เป็นค่าคงที่จำนวนเต็มหรือค่าคงที่เศษส่วนที่มีจุดทศนิยมหรือไม่ก็ได้ ไม่อนุญาตให้เว้นวรรคหรือสัญลักษณ์พิเศษอื่นใด

ค่าคงที่ตัวเลขแบ่งออกเป็นสองประเภท:

• Integer
• Float

ตัวอย่าง: 1.0, 5, 6, -2, -3.6

Character -> Character constants  จะเกิดขึ้นเมื่อเราแสดงอักขระตัวเดียวภายในเครื่องหมายอัญประกาศเดี่ยว (”)

แบ่งออกเป็นสามประเภทเพิ่มเติม:

• Single Character
• String
• BackSlash

ตัวอย่าง:

'A', 'B', 'C'  //Single Character Constants
"Scaler", "Mayank"  //String Constants
"\n"  //Backslash n denotes new line in C language 

Logical -> Logical Constants ใน C ประกอบด้วยตัวดำเนินการเชิงตรรกะและสามารถรับค่าใดค่าหนึ่งจากสองค่า: จริงหรือเท็จ

โดยทั่วไปมีสองประเภท:

• logical connectives
• quantifiers.

equality predicate (‘=) ยังถือเป็นค่าคงที่เชิงตรรกะอีกด้วย สัญลักษณ์บางตัวที่ถือว่าเป็นค่าคงที่เชิงตรรกะคือ:

Secondary Constants

1. Arrays -> Arrays ในภาษา C คือชุดขององค์ประกอบประเภทข้อมูลที่คล้ายกันพร้อมหมายเลขดัชนีเฉพาะสำหรับการเข้าถึง องค์ประกอบของอาร์เรย์จะถูกเก็บไว้ที่ตำแหน่งหน่วยความจำที่อยู่ติดกัน

ตัวอย่าง: int A[10] ;
ชื่อของอาร์เรย์ A เป็นตัวชี้คงที่ไปยังองค์ประกอบแรกของอาร์เรย์ ดังนั้นจึงถือได้ว่าเป็น const int *

ประกาศอาร์เรย์ (Array Declaration)

int arr[5]; //arr is array name of type integer and 5 is the size of array  

การเริ่มต้นอาร์เรย์ (Array Initialization)

int nums[5] = {0,1,2,3,4}; //array nums is initialized with elements 0,1,2,3,4  

2. Pointer -> Pointer เป็นตัวแปรในภาษา C และค่าของมันคือระบุที่อยู่ของตำแหน่งหน่วยความจำ พอยน์เตอร์ทำให้สามารถคืนค่าจากฟังก์ชันได้มากกว่าหนึ่งค่า

ตัวอย่างการประกาศ Pointer ใน C

int *nums; //nums is a pointer of type integer

3. Structure -> Structure เป็นประเภทข้อมูลที่กำหนดโดยผู้ใช้ในภาษา C ซึ่งใช้ในการจัดเก็บข้อมูลประเภทต่างๆ เราใช้คีย์เวิร์ด struct เพื่อประกาศโครงสร้างใน C ตัวแปรภายในโครงสร้างเรียกว่าสมาชิกของโครงสร้าง

ตัวอย่างการกำหนดโครงสร้างใน C

struct Article {
   char subject[50]; //member of structure of type char
   char abstract[50];
   int lines;
};

4. Union -> Union เป็นประเภทข้อมูลที่กำหนดโดยผู้ใช้ในภาษา C ซึ่งใช้ในการจัดเก็บข้อมูลประเภทต่างๆ เราใช้คีย์เวิร์ดยูเนี่ยนเพื่อประกาศสหภาพใน C ตัวแปรภายในสหภาพเรียกว่าสมาชิกของสหภาพ

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

ตัวอย่างการกำหนด union ใน C

union Article {
   char subject[50]; //member of union of type char
   char abstract[50];
};

5. Enum ->การแจงนับ (หรือ enum) เป็นประเภทข้อมูลที่กำหนดโดยผู้ใช้ใน C ซึ่งส่วนใหญ่ใช้เพื่อกำหนดชื่อให้กับค่าคงที่อินทิกรัล

ตัวอย่างการประกาศและการเริ่มต้น enum ใน C

enum days {Sun, Mon, Tues};

ในที่นี้ days เป็นตัวแปรของคีย์เวิร์ด enum และพารามิเตอร์ในวงเล็บปีกกาเรียกว่า enumerators ที่มีค่าสถานะต่างกัน (0,1,2)

อักขระพิเศษใน C

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

ประเภทของอักขระพิเศษใน C

วงเล็บเหลี่ยม Square Brackets [ ]
วงเล็บเหลี่ยม Square Brackets เปิดและปิดแสดงถึงตัวห้อยแบบเดี่ยวและแบบหลายมิติ และใช้เป็นข้อมูลอ้างอิงองค์ประกอบอาร์เรย์สำหรับการเข้าถึงองค์ประกอบอาร์เรย์

ตัวอย่าง:

int arr[10]; //For declaring array, with size defined in square brackets

Simple Brackets ( )
วงเล็บ เปิดและปิดใช้สำหรับการเรียกใช้ฟังก์ชันและการประกาศฟังก์ชัน
ตัวอย่าง:

get_area(100); //Function calling with 100 as parameter passed in circular brackets

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

int main{
    printf("Illustrating the use of curly braces!");
}

เครื่องหมายจุลภาค Comma ( , )
เครื่องหมายจุลภาคใช้เพื่อแยกตัวแปรหรือมากกว่าหนึ่งคำสั่ง เช่นเดียวกับการแยกพารามิเตอร์ของฟังก์ชันในการเรียกใช้ฟังก์ชัน
ตัวอย่าง:

int a=10,b=20,c=30; //Use of comma operator

Pre-Processor / Hash ( # )
เป็นมาโครโปรเซสเซอร์ที่คอมไพเลอร์ใช้โดยอัตโนมัติและแสดงว่าเรากำลังใช้ไฟล์ส่วนหัว
ตัวอย่าง:

#include<stdio.h> //For defining header-file
#define ll long  

int main(){
    printf("Hello World!");
}

ดอกจัน Asterisk ( * )
สัญลักษณ์ดอกจันสามารถใช้สำหรับการคูณตัวแปรและสำหรับการสร้างตัวแปรพอยน์เตอร์ ตัวอย่าง:

int main(){
    int a = 20,b = 10;
    int sum = a*b; //Use of asterisk in multiplication
    int *ptr = &a; 
    //Pointer variable ptr pointing to address of integer variable a
}

ตัวหนอน Tilde ( ~ )
มันถูกใช้เป็นตัวทำลายล้างเพื่อเพิ่มพื้นที่ว่างจากหน่วยความจำ
ตัวอย่าง:

int main(){
  int n = 2;
  printf("Bitwise complement of %d: %d", n, ~n);
  //Bitwise complement of 2 can be found with the help of tilde operator and result here is -3
}

ระยะเวลา Period ( . )
ใช้เพื่อเข้าถึงสมาชิกของโครงสร้างหรือสหภาพ
ตัวอย่าง:

#include <stdio.h>
#include <string.h>

struct Person { //structure defined
  int city_no; //members of structure
  float salary;
}person1;

int main(){
  person1.city_no = 100; 
  //accessing members of structure using period (.) operator
  person1.salary = 200000;
  printf("City_Number: %d",person1.city_no);
  printf("\nSalary: %.2f",person1.salary);
  return 0;
}

โคลอน Colon ( : )
ใช้เป็นส่วนหนึ่งของตัวดำเนินการตามเงื่อนไข( ? : )ในภาษาซี
ตัวอย่าง:

int a = 10,b = 20,c;
c = (a < b) ? a : b; 
//If a<b is true, then c will be assigned with the value of a else b 
printf("%d", c);

อัฒภาค Semicolon ( ; )
เป็นที่รู้จักในฐานะตัวปิดคำสั่ง ดังนั้น แต่ละคำสั่งเชิงตรรกะของภาษา C จะต้องลงท้ายด้วยเซมิโคลอน
ตัวอย่าง:

int a=10; //Semi-colon is widely used in C programs to terminate a line

Assignment Operator ( = )
ใช้เพื่อกำหนดค่าให้กับตัวแปรและบางครั้งใช้สำหรับการตรวจสอบการดำเนินการทางตรรกะ
ตัวอย่าง:

int a = 10, b = 20; //Assignment operator is used to assign some values to the variables

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