ปูพื้นฐานการเขียนโปรแกรมภาษา C

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

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

ประเภทของตัวแปลภาษา
ในปัจจุบันตัวแปลภาษาแบ่งออกเป็น 2 ประเภท

คอมไพเลอร์ (Compiler)
ข้อดี

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

ข้อเสีย

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

อินเตอร์พรีเตอร์ (Interpreter)
ข้อดี

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

ข้อเสีย

• ช้า เนื่องจากทำงานทีละบรรทัด

ภาษา C จัดเป็นภาษาคอมพิวเตอร์ที่ใช้ตัวแปลภาษาแบบคอมไพเลอร์

โครงสร้างคำสั่งภาษา C

#include <stdio.h> 
/*
นำคำสั่งพื้นฐานที่อยู่ในไลบราลี่ stdio เข้ามาทำงาน 
เช่น กลุ่มคำสั่งที่ต้องการแสดงผลออกทางจอภาพ (printf) เป็นต้น
*/

int main()
{
    printf("Hello World"); //แสดงผลข้อความ Hello World ออกทางจอภาพ
    return 0;
}

คำสั่งของภาษา C ที่เขียนในไฟล์นามสกุล .c จะถูกเรียกมาจากส่วนที่เรียกว่าไลบราลี่ (Library)

ไลบราลี่ (Library) ประกอบด้วย 3 องค์ประกอบ ได้แก่

• เครื่องหมาย # (Preprocessor) คือการกำหนดให้ตัวแปลภาษา C ทราบว่าต้องแปลความหมายของไลบราลี่อะไร
• ไดเรกทีฟ (Directive) คำสั่งที่ต่อจาก # คือการ include หรืออ้างอิงไฟล์ไลบราลี่ ที่อยู่ระหว่างเครื่องหมาย < กับ >
• Header File หมายถึงชื่อไลบราลี่ที่ต้องการอ้างอิง เช่น stdio.h

หมายเหตุ (Comment)

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

การเขียนหมายเหตุ

• วิธีที่ 1 โดยใช้เครื่องหมาย Slash ( // ) ใช้ในการอธิบายคำสั่งสั้นๆ
  ในรูปแบบบรรทัดเดียว
• วิธีที่ 2 เขียนคำอธิบายไว้ในเครื่องหมาย /* … */ ใช้ในการอธิบายคำสั่งยาวๆหรือแบบหลายบรรทัด

ตัวอย่าง

#include <stdio.h> 
/*
นำคำสั่งพื้นฐานที่อยู่ในไลบราลี่ stdio เข้ามาทำงาน 
เช่น กลุ่มคำสั่งที่ต้องการแสดงผลออกทางจอภาพ (printf) เป็นต้น
*/

int main()
{
    printf("Hello World"); //แสดงผลข้อความ Hello World ออกทางจอภาพ
    return 0;
}

แสดงผลข้อมูล (Output)

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

printf("Format String",List Of Data);

• Format String คือ ชุดข้อความพิเศษสำหรับกำหนดรูปแบบการแสดงผลข้อมูล
• List Of Data คือ รายการข้อมูลต่างๆที่ต้องการแสดงผล ซึ่งสามารถแสดงข้อมูลได้มากกว่า 1 รายการโดยคั่นด้วยเครื่องหมายคอมม่า (,)

ตัวอย่าง Format String

• %d คือ ข้อมูลตัวเลขจำนวนเต็ม
• %f คือ ข้อมูลตัวเลขที่มีจุดทศนิยม
• %c คือ ข้อมูลตัวอักษร
• %s คือ ข้อมูลข้อความ มีลักษณะเป็นชุดของตัวอักษร ตัวเลข หรือ อักขระพิเศษ อยู่ในพื้นที่เครื่องหมาย Double Quote ( “”)

อักขระควบคุมการทำงาน

• \n ขึ้นบรรทัดใหม่
• \t เว้นช่องว่างในแนวนอน

ตัวอย่าง

int score = 15;
printf("คะแนนของฉัน คือ %d \n",score); 

ตัวแปรและชนิดข้อมูล

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

ชนิดข้อมูลพื้นฐาน (Data Type)

• boolean ค่าทางตรรกศาสตร์ (True = 1 / False = 0)
• int ตัวเลขที่ไม่มีจุดทศนิยม
• float ตัวเลขที่มีจุดทศนิยม
• char ตัวอักษร (ใช้เครื่องหมาย ‘ ’)
• string กลุ่มตัวอักษรหรือข้อความ (ใช้เครื่องหมาย “ ”)

การสร้างตัวแปร
ชนิดข้อมูล ชื่อตัวแปร = ค่าเริ่มต้น;

int score=100;
char grade='A';
float gpax=3.99;

กฎการตั้งชื่อ

• ขึ้นต้นด้วยตัวอักษร A-Z หรือ a-z หรือ _ เครื่องหมายขีดเส้นใต้เท่านั้น
• อักษรตัวแรกห้ามเป็นตัวเลข
• ตัวพิมพ์เล็ก-พิมพ์ใหญ่มีความหมายต่างกัน (Case Sensitive)
• ห้ามใช้อักขระพิเศษมาประกอบเป็นชื่อตัวแปร เช่น {} , % ^
  และช่องว่าง เป็นต้น
• ไม่สามารถประกาศชื่อเดียวกัน แต่มีชนิดข้อมูล 2 ชนิดได้
• ไม่ซ้ำกับคำสงวนในภาษา C

ค่าคงที่ (Constant)

มีลักษณะการใช้งานคล้ายกับตัวแปร แต่ค่าคงที่คือค่าที่ไม่สามารถเปลี่ยนแปลงได้ ตอนประกาศใช้งานค่าคงที่จะต้องมีการประกาศค่าเริ่มต้นเสมอ

ประเภทของค่าคงที่ (Constant)

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

printf("Hello %s","KongRuksiam");
printf(" 2 x 2 = %d" , 4);

Defined Constant คือ ค่าคงที่ซึ่งประกาศไว้ที่ส่วนหัวของโปรแกรมในลักษณะ Preprocessing Directives เช่น

#define MAX_VALUE 100;
int main(){
  printf("MAX = %d",MAX_VALUE);
}

Memory Constant เป็นการกำหนดค่าคงที่ให้ตัวแปร ส่งผลให้ตัวแปรที่ถูกกำหนดค่านั้น ไม่สามารถแปรเปลี่ยนค่าได้ ตลอดการทำงานของโปรแกรม ตัวอย่าง เช่น

const float PI = 3.14 ;
const int SIZE = 10;

การรับข้อมูล (Input)

คือ คำสั่งสำหรับรับค่าผ่านทางคีย์บอร์ดและเก็บค่าดังกล่าวลงในตัวแปรมีโครงสร้างคำสั่ง ดังนี้

scanf("Format String",List Of Address)

• Format String คือ ชุดข้อความพิเศษสำหรับกำหนดรูปแบบการรับข้อมูลจากผู้ใช้
• List Of Address คือ ตำแหน่งของตัวแปรในหน่วยความจำ โดยทั่วไปจะอยู่ในรูปของตัวแปรที่มีเครื่องหมาย & นำหน้า เช่น ตำแหน่งของตัวแปร name คือ &name

ตัวอย่าง Format String

• %d เก็บข้อมูลตัวเลขจำนวนเต็ม
• %f เก็บข้อมูลตัวเลขที่มีจุดทศนิยม
• %c เก็บข้อมูลตัวอักษร
• %s เก็บข้อมูลกลุ่มตัวอักษร (ข้อความ)

ตัวดำเนินการ (Operator)

หมายถึง กลุ่มของเครื่องหมายหรือสัญลักษณ์ที่ใช้ในการเขียนโปรแกรม

ตัวดำเนินการทางคณิตศาสตร์

• + หมายถึง การบวก
• - หมายถึง การลบ
• * หมายถึง การคูณ
• / หมายถึง การหาร
• % หมายถึง การหารเอาเศษ

int x = 100;
int y = 50;

x+y; //100 + 50 = 150
x-y; //100 - 50 = 50
x*y; //100 x 50 = 5000
x/y; //100 / 50 = 2
x%y; //100 % 50 = 0

ตัวดำเนินการเพิ่มค่าและลดค่า

++ (Prefix)

int a=5;
printf("ค่าเริ่มต้น=%d",a);//5
printf("prefix=%d",++a);//6
printf("ค่าล่าสุด=%d",a);//6

++ (Postfix)

int a=5;
printf("ค่าเริ่มต้น=%d",a); //5
printf("postfix=%d",a++); //5
printf("ค่าล่าสุด=%d",a);//6

— (Prefix)

int a=5;
printf("ค่าเริ่มต้น=%d",a); //5
printf("prefix=%d",--a);//4
printf("ค่าล่าสุด=%d",a);//4

— (Postfix)

int a=5;
printf("ค่าเริ่มต้น=%d",a); //5
printf("postfix=%d",a--); //5
printf("ค่าล่าสุด=%d",a);//4

ตัวดำเนินการกำหนดค่า (Compound Assignment) หมายถึงการใช้ตัวดำเนินการทางคณิตศาสตร์ร่วมกับเครื่องหมายเท่ากับ (=)

int x = 100;
int y = 50;
x+=y; //หมายถึง x=x+y -> 150
x-=y; //หมายถึง x=x-y -> 50
x*=y; //หมายถึง x=x*y -> 5000
x/=y; //หมายถึง x=x/y -> 2
x%=y; //หมายถึง x=x%y -> 0

ตัวดำเนินการเปรียบเทียบ ผลการเปรียบเทียบจะได้คำตอบ คือ True (1) หรือ False (0)

/*
== หมายถึง เท่ากับ
!= หมายถึง ไม่เท่ากับ
> หมายถึง มากกว่า
< หมายถึง น้อยกว่า
>= หมายถึง มากกว่าเท่ากับ
<= หมายถึง น้อยกว่าเท่ากับ
*/

ตัวดำเนินการทางตรรกศาสตร์ ประกอบด้วย

/*

&& (AND) และ
|| (OR) หรือ
! (NOT) ไม่

*/

ตารางความจริง

แผนภาพ AND Logical Operator

แผนภาพ OR Logical Operator

แผนภาพ NOT Logical Operator

โครงสร้างควบคุมแบบมีเงื่อนไข (Condition)

กลุ่มคำสั่งที่ใช้ตัดสินใจในการเลือกทำงานตามเงื่อนไขต่างๆ ภายในโปรแกรม

If Statement
เป็นคำสั่งที่ใช้กำหนดเงื่อนไขในการตัดสินใจทำงานของโปรแกรม ถ้าเงื่อนไขเป็นจริงจะทำตามคำสั่งต่างๆ ที่กำหนดภายใต้เงื่อนไขนั้นๆ

if(เงื่อนไข){
  //คำสั่งเมื่อเงื่อนไขเป็นจริง; 
}

If…Else Statement

if(เงื่อนไข){ 
 //คำสั่งเมื่อเงื่อนไขเป็นจริง ; 
}else{
 //คำสั่งเมื่อเงื่อนไขเป็นเท็จ ; 
}

แบบลดรูป (Ternary Operator)

ตัวแปร = เงื่อนไข ? คำสั่งเมื่อเงื่อนไขเป็นจริง :  คำสั่งเมื่อเงื่อนไขเป็นเท็จ;

รูปแบบคำสั่งแบบหลายเงื่อนไข

if(เงื่อนไขที่ 1){ 
    //คำสั่งเมื่อเงื่อนไขที่ 1 เป็นจริง ; 
}else if(เงื่อนไขที่ 2){
    //คำสั่งเมื่อเงื่อนไขที่ 2 เป็นจริง ; 
}else if(เงื่อนไขที่ 3){
    //คำสั่งเมื่อเงื่อนไขที่ 3 เป็นจริง ; 
}else{
    //คำสั่งเมื่อทุกเงื่อนไขเป็นเท็จ ;
}

Switch..Case
Switch เป็นคำสั่งที่ใช้กำหนดเงื่อนไขคล้ายๆกับ if แต่จะเลือกเพียงหนึ่งทางเลือกออกมาทำงานโดยนำค่าในตัวแปรมากำหนดเป็นทางเลือกผ่านคำสั่ง case (ตัวแปรควบคุม)

switch (ค่าที่เก็บในตัวแปรควบคุม) {
  case ค่าที่ 1 : คำสั่งที่ 1;
      break;
   case ค่าที่ 2 : คำสั่งที่ 2;
      break;
     ……
   case ค่าที่ N : คำสั่งที่ N;
      break;
  default : คำสั่งเมื่อไม่มีค่าที่ตรงกับที่ระบุใน case
 }

โครงสร้างควบคุมแบบทำซ้ำ (Loop)

กลุ่มคำสั่งที่ใช้ในการวนรอบ (Loop) โปรแกรมจะทำงานไปเรื่อยๆจนกว่าเงื่อนไขที่กำหนดไว้จะเป็นเท็จ จึงจะหยุดทำงาน

While Loop
จะทำงานตามคำสั่งภายใน while ไปเรื่อยๆเมื่อเงื่อนไขที่กำหนดเป็นจริง

while(เงื่อนไข){ 
  //คำสั่งที่จะทำซ้ำเมื่อเงื่อนไขเป็นจริง ; 
}

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

for(ค่าเริ่มต้นของตัวแปร; เงื่อนไข; เปลี่ยนแปลงค่าตัวแปร) { 
   //คำสั่งเมื่อเงื่อนไขเป็นจริง; 
}

Do…While Loop
โปรแกรมจะทำงานตามคำสั่งอย่างน้อย 1 รอบ เมื่อทำงานเสร็จจะมาตรวจสอบเงื่อนไขที่คำสั่ง while ถ้าเงื่อนไขเป็นจริงจะวนกลับขึ้นไปทำงานที่คำสั่งใหม่อีกรอบ แต่ถ้าเป็นเท็จจะหลุดออกจากลูป

do { 
  //คำสั่งต่างๆ เมื่อเงื่อนไขเป็นจริง; 
 } while(เงื่อนไข);

คำสั่งที่เกี่ยวข้องกับ Loop

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

ข้อแตกต่างและการใช้งาน Loop

• For ใช้ในกรณีรู้จำนวนรอบที่ชัดเจน
• While ใช้ในกรณีที่ไม่รู้จำนวนรอบ
• Do..while ใช้ในกรณีที่อยากให้ลองทำก่อน 1 รอบแล้วทำซ้ำไปเรื่อยๆตราบเท่าที่เงื่อนไขเป็นจริง

หัวข้อเสริม

การรับและแสดงผลข้อมูลแบบตัวอักษรนอกจากจะใช้ฟังก์ชั่น scanf() และ printf() แล้ว ยังมีฟังก์ชั่นเฉพาะที่ใช้สำหรับรับข้อมูลแบบตัวอักษร คือ

• getchar() คือ ฟังก์ชั่นสำหรับรับข้อมูล 1 ตัวอักษรจากคีย์บอร์ด
• putchar() คือ ฟังก์ชั่นสำหรับแสดงผลข้อมูล 1 ตัวอักษรออกทางจอภาพ

การรับและแสดงผลชุดข้อความ (String) นอกจากจะใช้ฟังก์ชั่น scanf() และ printf() แล้ว ยังมีฟังก์ชั่นเฉพาะที่ใช้จัดการข้อความ คือ

• gets() คือ ฟังก์ชั่นสำหรับรับข้อมูลชุดข้อความจากคีย์บอร์ด
• puts() คือ ฟังก์ชั่นสำหรับแสดงผลชุดข้อความออกทางจอภาพ

อาร์เรย์ (Array) คืออะไร

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

คุณสมบัติของอาร์เรย์

1. ใช้เก็บกลุ่มของข้อมูล
2. ข้อมูลที่อยู่ในอาร์เรย์จะเรียกว่าสมาชิก หรือ อิลิเมนต์ (element)
3. แต่ละอิลิเมนต์ (element) จะเก็บค่าข้อมูล (value) และ อินเด็กซ์ (Index)
4. Index หมายถึงคีย์ของอาร์เรย์ใช้อ้างอิงตำแหน่งของ element เริ่มต้นที่ 0
5. สมาชิกในอาร์เรย์ต้องมีชนิดข้อมูลเหมือนกัน
6. สมาชิกในอาร์เรย์จะถูกคั่นด้วยเครื่องหมายคอมม่า

การสร้างอาร์เรย์

แบบกำหนดขนาด

//ชนิดข้อมูล ชื่อตัวแปร[ขนาด]; //ขนาดต้องเป็นตัวเลขจำนวนเต็ม
int score [3];

แบบกำหนดขนาดและค่าเริ่มต้น

// ชนิดข้อมูล ชื่อตัวแปร [ขนาด] = {สมาชิก,….};
int score [3] = {100,90,70};

แบบไม่กำหนดขนาด

// ชนิดข้อมูล ชื่อตัวแปร[] = {สมาชิก,....};
int score [] = {100,90,70,80};

การเปลี่ยนแปลงข้อมูลสมาชิก Array

int number[] = {10, 20, 30, 40};
number[2] = 100;
char vowels[] = {‘A’,’F’,’I’,’O’,’U’}
vowels[1]=’E’;

การเข้าถึงสมาชิกด้วย For Loop

int number[] = {10, 20, 30};
  for (int i = 0; i < 3; i++) {
      // กระบวนการทำงาน
  }

อาร์เรย์ 2 มิติ

• อาร์เรย์ที่มีข้อมูลสมาชิกภายในเป็นอาร์เรย์ (Array ซ้อน Array)
• มีโครงสร้างเป็นรูปแบบแถว (แนวนอน) และคอลัมน์ (แนวตั้ง)

การสร้างอาร์เรย์ 2 มิติ

//แบบกำหนดขนาด
//ชนิดข้อมูล ชื่อตัวแปร[ขนาดแถว][ขนาดคอลัมน์];  
int score [2][4];

//แบบกำหนดขนาดและค่าเริ่มต้น
//ชนิดข้อมูล ชื่อตัวแปร[ขนาดแถว][ขนาดคอลัมน์] = {สมาชิก,....};
int numbers [2][4]={
   {50,70,80,90},
   {100,99,60,55}
};

การเปลี่ยนแปลงค่าในอาร์เรย์ 2 มิติ

// ชื่อตัวแปร[แถว][คอลัมน์] = กำหนดค่า
  score [0][1] = 99
  score [1][3] = 80

สรุปอาร์เรย์

1. ใช้เก็บกลุ่มของข้อมูล ที่มีชนิดข้อมูลเดียวกัน
2. ใช้ตัวแปรชื่อเดียวกัน
3. ใช้หมายเลขกำกับเพื่ออ้างอิงตำแหน่งของข้อมูลในอาร์เรย์
4. มีขนาดที่แน่นอนไม่สามารถปรับเปลี่ยนขนาดได้

ฟังก์ชั่น (Function)

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

ประเภทของฟังก์ชั่น

• ฟังก์ชั่นมาตรฐาน (Standard Library Functions) คือ ฟังก์ชั่นที่มีอยู่ในภาษา C ผู้ใช้สามารถเรียกใช้งานได้เลย เช่น printf() , scanf() ที่ทำงานอยู่ในไลบราลี่ หรือ Header File เช่น stdio.h เป็นต้น
• ฟังก์ชั่นที่ผู้ใช้สร้างขึ้นมาเอง (User-Define Function) คือ
  ฟังก์ชั่นที่ถูกสร้างขึ้นมาให้ทำงานตามวัตถุประสงค์ที่ผู้ใช้ต้องการ

ฟังก์ชั่น main() คือ ฟังก์ชั่นพิเศษกลุ่มคำสั่งที่อยู่ในฟังก์ชั่นนี้จะถูกสั่งให้ทำงานโดยอัตโนมัติเป็นลำดับแรกเสมอ

กฎการตั้งชื่อฟังก์ชั่น

• ชื่อฟังก์ชันต้องไม่ซ้ำกัน
• ชื่อฟังก์ชันสามารถตั้งเป็นตัวอักษรหรือตัวเลขได้
• ชื่อของฟังก์ชันต้องไม่ขึ้นต้นด้วยตัวเลข

วิธีสร้างฟังก์ชั่น

นิยามชื่อฟังก์ชั่นก่อนกำหนดโครงสร้าง

func_name(); //นิยามชื่อฟังก์ชั่น (function prototype)
int main(){
}
func_name(){} //กำหนดโครงสร้างการทำงานหลังฟังก์ชั่น main

นิยามชื่อฟังก์ชั่นพร้อมกำหนดโครงสร้าง

// นิยามชื่อพร้อมกำหนดโครงสร้างคำสั่ง (เขียนอยู่ด้านบน main เท่านั้น)
func_name(){ }
int main(){
}

ฟังก์ชั่นที่ไม่มีการรับและส่งค่า (void)

//โครงสร้างคำสั่ง
void ชื่อฟังก์ชั่น(){
// คำสั่งต่างๆ
}
//การเรียกใช้งานฟังก์ชั่น
ชื่อฟังก์ชั่น ();

ฟังก์ชั่นแบบมีพารามิเตอร์ (Parameter)

//โครงสร้างคำสั่ง
void ชื่อฟังก์ชั่น(parameter1,parameter2,.....){
// กลุ่มคำสั่งต่างๆ
}
//การเรียกใช้งานฟังก์ชั่น
ชื่อฟังก์ชั่น (argument1,argument2,.....);

อาร์กิวเมนต์ คือ ตัวแปรหรือค่าที่ต้องการส่งมาให้กับฟังก์ชัน (ตัวแปรส่ง)

พารามิเตอร์ คือ ตัวแปรที่ฟังก์ชันสร้างไว้สำหรับรับค่าที่จะส่งเข้ามาให้กับฟังก์ชัน (ตัวแปรรับ)

ฟังก์ชั่นแบบมีค่าส่งกลับ (Return)

//โครงสร้างคำสั่ง
  type ชื่อฟังก์ชั่น(){
       return ค่าที่จะส่งออกไป (อ้างอิงตามชนิดข้อมูล)
}
//การเรียกใช้งานฟังก์ชั่น
ตัวแปรที่รับค่าจากฟังก์ชั่น = ชื่อฟังก์ชั่น();

ฟังก์ชั่นแบบรับและส่งค่า (Parameter & Return)

//โครงสร้างคำสั่ง
  type ชื่อฟังก์ชั่น(parameter1,parameter2,.....){
       return ค่าที่จะส่งออกไป (อ้างอิงตามชนิดข้อมูล)
}
//การเรียกใช้งานฟังก์ชั่น
ตัวแปรที่รับค่าจากฟังก์ชั่น = ชื่อฟังก์ชั่น(argument1,argument2..);

ขอบเขตตัวแปร

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

พอยน์เตอร์ (Pointer)

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

การสร้างตัวแปร Pointer

//โครงสร้างคำสั่ง
//ชนิดข้อมูล *ตัวแปรพอยน์เตอร์;

int number = 10;
char letter = 'A';
//ตัวแปร p1 คือ ตัวแปร pointer ที่ชี้ไปที่แอดเดรสของตัวแปรที่เป็นรูปแบบ int
int *p1 = &number;
//ตัวแปร p2 คือ ตัวแปร pointer ที่ชี้ไปที่แอดเดรสของตัวแปรที่เป็นรูปแบบ char
char *p2 = &letter;

* คือ ตำแหน่งแอดเดรสในหน่วยความจำที่พอยน์เตอร์ชี้อยู่
& คือ ค่าแอดเดรสของตัวแปร

สตรัคเจอร์ (Structure)

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

**เปรียบเสมือนกับสร้างชนิดข้อมูลขึ้นมาใช้งานเอง**

การสร้างสตรัคเจอร์

//โครงสร้างคำสั่ง
struct ชื่อสตรัคเจอร์ {
 ชนิดข้อมูลตัวที่ 1  ตัวแปรที่ 1 ;
 ชนิดข้อมูลตัวที่ 2 ตัวแปรที่ 2 ;
 …..
}

//สร้าง structure
struct user{
 char name[20];
 char gender;
 int age;
};

//นำ structure ไปใช้งาน
struct user emp1;
strcpy(emp1.name,”kong”);
emp1.gender=’M’;
emp1.age = 30;

เนื้อหาที่เกี่ยวข้อง

ช่องทางการสนับสนุน
🎓คอร์สเรียน Udemy | 🛒ซื้อของผ่าน Shopee

🌎 ติดตามข่าวสารเพิ่มเติมได้ที่
Facebook | YouTube | TikTok