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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

return_data_type function_name (data_type arguments);

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

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

#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

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

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

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

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

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 ตัวแปรที่ถูกประกาศภายในฟังก์ชันจะอยู่ในบล็อกของโค้ดนั้น และไม่สามารถอ้างอิงถึงภายนอกฟังก์ชันได้ อย่างไรก็ตาม ตัวแปรที่ถูกประกาศนอกฟังก์ชันทั้งหมดจะเป็นตัวแปรร่วมและสามารถเข้าถึงได้จากทั้งโปรแกรม ค่าคงที่ประกาศด้วย a #กำหนด ที่ด้านบนของโปรแกรมสามารถเข้าถึงได้จากโปรแกรมทั้งหมด เราพิจารณาโปรแกรมต่อไปนี้ซึ่งพิมพ์ค่าของตัวแปรทั่วโลกจากทั้งฟังก์ชันหลักและฟังก์ชันที่ผู้ใช้กำหนด:

#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

เรามาพูดคุยรายละเอียดโปรแกรม:

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

ในภาษา 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

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

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

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

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

ฟังก์ชั่นในการเขียนโปรแกรม 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();
}