ฟังก์ชั่นในการเขียนโปรแกรม C พร้อมตัวอย่าง: แบบเรียกซ้ำและแบบอินไลน์

ฟังก์ชั่นในภาษาซีคืออะไร?

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

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

ห้องสมุดเทียบกับ ฟังก์ชั่นที่ผู้ใช้กำหนด

โปรแกรม 'C' ทุกโปรแกรมมีฟังก์ชันอย่างน้อยหนึ่งฟังก์ชันซึ่งเป็นฟังก์ชันหลัก แต่โปรแกรมสามารถมีฟังก์ชันจำนวนเท่าใดก็ได้ ฟังก์ชันหลัก () ในภาษา C เป็นจุดเริ่มต้นของโปรแกรม

ในการเขียนโปรแกรม 'C' ฟังก์ชันแบ่งออกเป็นสองประเภท:

1. ฟังก์ชั่นห้องสมุด
2. ฟังก์ชันที่ผู้ใช้กำหนด

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

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

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

ฟังก์ชั่นการเขียนโปรแกรม C แบ่งออกเป็น 3 กิจกรรม ได้แก่

1. การประกาศฟังก์ชัน
2. นิยามฟังก์ชัน
3. การเรียกใช้ฟังก์ชัน

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

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

การประกาศฟังก์ชัน (เรียกว่าต้นแบบ) มักจะทำเหนือฟังก์ชันหลัก () และใช้รูปแบบทั่วไป:

return_data_type function_name (data_type arguments);

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

เราพิจารณาโปรแกรมต่อไปนี้ซึ่งแสดงวิธีการประกาศฟังก์ชันลูกบาศก์เพื่อคำนวณค่าลูกบาศก์ของตัวแปรจำนวนเต็ม

#include <stdio.h>
/*Function declaration*/
int add(int a,b);
/*End of Function declaration*/
int main() {

โปรดทราบว่าฟังก์ชันไม่จำเป็นต้องส่งคืนค่าเสมอไป ในกรณีนี้ จะใช้คำสำคัญเป็นโมฆะ

ตัวอย่างเช่น การประกาศฟังก์ชัน output_message บ่งชี้ว่าฟังก์ชันไม่ส่งคืนค่า: void output_message();

นิยามฟังก์ชัน

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

int add(int a,int b)	//function body	
{
	int c;
	c=a+b;
	return c;
}

การเรียกใช้ฟังก์ชัน

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

  result = add(4,5);

นี่คือโค้ดฉบับสมบูรณ์:

#include <stdio.h>
int add(int a, int b);	//function declaration
int main()
{
	int a=10,b=20;
	int c=add(10,20); 	//function call
	printf("Addition:%d\n",c);
	getch();
}
int add(int a,int b)	//function body
{
	int c;
	c=a+b;
	return c;
}

Output:

Addition:30

อาร์กิวเมนต์ของฟังก์ชัน

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

โดยค่าเริ่มต้น อาร์กิวเมนต์จะถูกส่งผ่านโดยค่า (pass by value) ซึ่งเป็นการส่งสำเนาของข้อมูลไปยังฟังก์ชันที่ถูกเรียก ตัวแปรที่ส่งผ่านจริงจะไม่เปลี่ยนแปลง

เราพิจารณาโปรแกรมต่อไปนี้ซึ่งแสดงพารามิเตอร์ที่ส่งผ่านค่า:

int add (int x, int y); 
int main() {
  int a, b, result;
  a = 5;
  b = 10;
  result = add(a, b);
  printf("%d + %d\ = %d\n", a, b, result);
return 0;}
int add (int x, int y) { 
x += y;
  return(x);}

ผลลัพธ์ของโปรแกรมคือ:

5 + 10 = 15

โปรดทราบว่าค่าของ a และ b ถูกส่งผ่านเพื่อเพิ่มฟังก์ชันไม่เปลี่ยนแปลง เนื่องจากมีเพียงค่าเท่านั้นที่ถูกส่งผ่านไปยังพารามิเตอร์ x

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

ขอบเขตตัวแปร หมายถึง การมองเห็นตัวแปรภายในโค้ดของโปรแกรม

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

#include <stdio.h>
int global = 1348;
void test();
int main() {
  printf("from the main function : global =%d \n", global);
  test () ;
return 0;}

void test (){
printf("from user defined function : global =%d \n", global);}

ผลลัพธ์:

from the main function : global =1348
from user defined function : global =1348

เราจะมาพูดคุยรายละเอียดของโปรแกรมกัน:

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

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

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

ตัวแปรคงที่

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

โปรแกรมต่อไปนี้ใช้ตัวแปรคงที่:

#include <stdio.h>
void say_hi();
int main() {    
  int i;
  for (i = 0; i < 5; i++) { say_hi();}
   return 0;}
void say_hi() {
  static int calls_number = 1;
  printf("Hi number %d\n", calls_number);
  calls_number ++; }

โปรแกรมจะแสดง:

Hi number 1
Hi number 2
Hi number 3
Hi number 4
Hi number 5

ฟังก์ชั่นแบบเรียกซ้ำ

พิจารณาแฟกทอเรียลของจำนวนหนึ่งซึ่งคำนวณได้ดังนี้ 6! = 6 * 5 * 4 * 3 * 2 * 1

การคำนวณนี้กระทำโดยการคำนวณข้อเท็จจริง * (ข้อเท็จจริง -1) ซ้ำ ๆ จนกระทั่งข้อเท็จจริงเท่ากับ 1

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

ตัวอย่างเช่น:

#include <stdio.h>
int factorial(int number);
int main() {    
  int x = 6;
  printf("The factorial of %d is %d\n", x, factorial(x)); 
  return 0;}
int factorial(int number) {
 if (number == 1)    return (1); /* exiting condition */
  else
    return (number * factorial(number - 1));
}

โปรแกรมจะแสดง:

 The factorial of 6 is 720

ที่นี่เราจะหารือรายละเอียดของโปรแกรม:

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

พิจารณาแผนภูมิAต่อไปนี้เพื่อทำความเข้าใจกลไกการเรียกซ้ำให้ดียิ่งขึ้น ซึ่งประกอบด้วยการเรียกฟังก์ชันนั้นซ้ำไปเรื่อยๆ จนกว่าจะถึงกรณีพื้นฐานหรือหยุดลงping เมื่อเงื่อนไขถึงแล้ว เราจะรวบรวมค่าก่อนหน้า:

ฟังก์ชันอินไลน์

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

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

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

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

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

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

inline function_name ()
{
    //function definition
}

ให้เราเขียนโปรแกรมเพื่อใช้ฟังก์ชันอินไลน์

inline int add(int a, int b)		//inline function declaration
{
	return(a+b);
}
int main()
{
	int c=add(10,20);
	printf("Addition:%d\n",c);
	getch();
}

Output:

Addition: 30

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

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