ความรู้เบื้องต้นเกี่ยวกับฟังก์ชัน C

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

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

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

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

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

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

ฟังก์ชั่น: การประกาศ การกำหนด และการโทร

การใช้ฟังก์ชันต่างๆ ขึ้นอยู่กับองค์ประกอบสำคัญ 3 ประการ ซึ่งทำหน้าที่เป็นรากฐานสำคัญในการใช้งาน

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

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

 return_type function_name(parameters); 

ที่ไหน:

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

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

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

ตัวอย่างเช่น นี่คือการประกาศฟังก์ชันง่ายๆ:

 int add(int a, int b); 

คำจำกัดความของฟังก์ชัน

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

 return_type function_name(parameters) {
    // Function body - code that defines what the function does
    // Return a value if applicable
    return value;
} 

มาแบ่งส่วนของไวยากรณ์กัน:

คลังข้อมูลของคำสั่งที่อยู่ในวงเล็บปีกกา { } ถือเป็นส่วนเนื้อหาของฟังก์ชัน ซึ่งประกอบด้วยชุดคำสั่งที่อธิบายลักษณะพฤติกรรมของฟังก์ชันเมื่อมีการเรียกใช้

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

แน่นอนว่า นี่คือรูปแบบการประกาศฟังก์ชันที่สวยงามในภาษาอังกฤษ:pythondef ทักทาย(ชื่อ):print(“Hello,"+ name + “!”)

 int add(int a, int b) {
    int sum = a \+ b;
    return sum;
}

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

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

 return_type result = function_name(arguments); 

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

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

นี่คือตัวอย่างของการเรียกใช้ฟังก์ชัน:

 #include <stdio.h>

// Function prototype
int add(int a, int b);

int main() {
    int x = 5, y = 3;

    // Call the function and store the result in 'sum'
    int sum = add(x, y);
    printf("The sum of %d and %d is %d\n", x, y, sum);
    return 0;
}

// Function definition
int add(int a, int b) {
    return a \+ b;
} 

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

พารามิเตอร์ฟังก์ชันและค่าส่งคืน

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

มีสองวิธีในการส่งพารามิเตอร์

###ผ่านความคุ้มค่า

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

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

 #include <stdio.h>

int square(int num) {
    num = num * num;
    return num;
}

int main() {
    int x = 5;
    int y = square(x);

    // Output: x and y after function call: 5 25
    printf("x and y after function call: %d %d\n", x, y);

    return 0;
} 

ฟังก์ชันสี่เหลี่ยมยอมรับอินพุตตัวเลขที่แสดงโดยตัวแปร"num"

ฟังก์ชัน square ใช้ตัวเลขเป็นอินพุต คำนวณรากที่สอง แก้ไขตามนั้น และส่งกลับผลลัพธ์ที่อัปเดต

วัตถุประสงค์หลักของรหัสนี้คือการประกาศตัวแปร “x” ซึ่งเริ่มแรกกำหนดค่าเป็นจำนวนเต็ม

โค้ดดำเนินการโดยการเรียกใช้ฟังก์ชัน square และระบุค่า x เป็นอาร์กิวเมนต์ การดำเนินการนี้จะตามมาด้วยการกำหนดเอาต์พุตผลลัพธ์ให้กับตัวแปรรองที่ชื่อ y

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

ผ่านการอ้างอิง

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

ความแตกต่างที่โดดเด่นประการหนึ่งระหว่างภาษาโปรแกรม C และภาษาต่างๆ เช่น Python อยู่ที่การใช้พอยน์เตอร์ รวมถึงฟังก์ชันของพวกมันเป็นอาร์กิวเมนต์

 #include <stdio.h>

void square(int *num) {
    *num = *num * *num;
}

int main() {
    int x = 5;
    square(&x);

    // Output: x after function call: 25
    printf("x after function call: %d\n", x);
    return 0;
} 

ฟังก์ชัน Square ยอมรับตัวชี้จำนวนเต็มเป็นอาร์กิวเมนต์อินพุต ซึ่งแสดงโดยตัวแปร"num"ฟังก์ชันนี้ไม่ให้ผลตอบแทนใดๆ

ฟังก์ชัน square รับตัวเลขเป็นอินพุต คำนวณกำลังสองด้วยการคูณด้วยตัวมันเอง จากนั้นอัปเดตค่าที่จัดเก็บไว้ในหน่วยความจำที่ชี้ไปโดยอาร์กิวเมนต์ที่ส่งไปยังฟังก์ชันโดยใช้ตัวดำเนินการ Dereference (\*)

วัตถุประสงค์หลักของข้อมูลโค้ดนี้คือเพื่อสร้างตัวแปรจำนวนเต็มใหม่ชื่อ"x"และกำหนดค่าเริ่มต้นเป็น 5

รหัสจะดำเนินการโดยการยกเลิกการอ้างอิงตัวชี้ไปที่ x และส่งที่อยู่ของมัน ซึ่งได้รับจากการใช้ที่อยู่ของตัวดำเนินการ & เพื่อเป็นอาร์กิวเมนต์ของฟังก์ชัน square()

หลังจากการเรียกใช้ฟังก์ชัน"กำลังสอง"ลำดับการดำเนินการหลักจะดำเนินการพิมพ์ค่าปัจจุบันของตัวแปร’x’ซึ่งได้รับการอัปเดตภายในฟังก์ชัน และตอนนี้เก็บค่าตัวเลขไว้ที่ยี่สิบห้า การแก้ไขพารามิเตอร์’*num’ดั้งเดิมโดยฟังก์ชัน"square"ทำให้เกิดผลลัพธ์นี้สำหรับตัวแปร’x'

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

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

ฟังก์ชั่นเป็นโมฆะ

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

นี่คือตัวอย่างของฟังก์ชันโมฆะ:

 #include <stdio.h>

// Void function with no parameters
void greet() {
    printf("Hello, All Things N!");
}

int main() {
    // Call the void function, output: "Hello, All Things N!"
    greet();

    return 0;
} 

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

สำรวจฟังก์ชั่นในการเขียนโปรแกรม C

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

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