ฟังก์ชัน#

การแนะนำ#

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

หน้านี้ครอบคลุมพื้นฐานการใช้งานฟังก์ชันในภาษา C++ ซึ่งรวมถึง:

โครงสร้างและไวยากรณ์ของฟังก์ชัน#

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

return_type function_name(parameters) {
  // Code to execute when the function is called
  return result;  // Optional, used to return a value
}

ส่วนประกอบการทำงาน

คำอธิบาย

return_type

The data type that the function returns, some common options are:

  • void — Returns nothing
  • int — Returns an integer value
  • double — Returns a floating-point number
  • bool — Returns true or false
  • char — Returns a single character
  • const char* — Returns a text string
  • user-defined types — Returns a struct or class object

function_name

ชื่อของฟังก์ชัน

parameters

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

result

ไม่บังคับ ค่าที่ส่งคืนโดยฟังก์ชัน หาก return_type ของฟังก์ชันไม่ใช่ return_typeค่านี้จะต้องระบุ และประเภทของค่าต้องตรงกับ void ที่ระบุไว้ทุกประการ

หมายเหตุ: ฟังก์ชันจะต้อง ประกาศ ก่อน ที่จะเรียกใช้เสมอ หรือคุณต้องระบุ ต้นแบบฟังก์ชัน

ต้นแบบฟังก์ชัน#

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

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

Without a prototype, you would have to define every function above main(), which can make projects harder to follow as they grow.

// The function's prototype
void greeting();

int main() {
  greeting();
}

// Write the function's body after
void greeting() {
  Brain.Screen.print("Hello!");
}

การกำหนดและการเรียกใช้ฟังก์ชัน#

Functions with No Parameters#

หากฟังก์ชันไม่ต้องการอินพุต คุณสามารถกำหนดฟังก์ชันนั้นได้โดยไม่ต้องมีพารามิเตอร์ ใช้ void เป็นประเภทการส่งคืนหากฟังก์ชันนั้นไม่ส่งคืนค่าใดๆ

// Define a function to display a message
void greeting() {
    Brain.Screen.print("Hello!");
}

int main() {
    // Initializing Robot Configuration. DO NOT REMOVE!
    vexcodeInit();
    // Call the function to display the message
    greeting();
}

Functions with Parameters#

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

หมายเหตุ: สามารถส่งข้อความได้โดยใช้สตริงแบบ C (const char*) หรือสตริงแบบ C++ (std::string)

// Define a function with a parameter
void namedGreeting(const char* name) {
    Brain.Screen.print("Hello, %s!", name);
}

int main() {
    // Initializing Robot Configuration. DO NOT REMOVE!
    vexcodeInit();
    namedGreeting("Stranger");
}

ค่าที่ส่งคืน#

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

// Define a function that multiplies numbers by 2
int timesTwo(int number) {
    return number * 2;
}

int main() {
    // Initializing Robot Configuration. DO NOT REMOVE!
    vexcodeInit();
    // Display the return value
    Brain.Screen.print("%d", timesTwo(2));
}

ส่งต่อโดยอ้างอิง#

By default, C++ passes function parameters by value, meaning the function receives a copy of the original variable. Changes made inside the function do not affect the original value.

// Add 1 to the number
void addOne(int number) {
  number++;
}

int main() {
  int value = 5;
  addOne(value);
  // "value" will still be 5
}

To allow a function to modify the original variable, parameters can be passed by reference using the & symbol.

// Add 1 to the number
void addOne(int& number) {
  number++;
}

int main() {
  int value = 5;
  addOne(value);
  // "value" will now be 6
}

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

ฟังก์ชันเรียกกลับ#

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

ฟังก์ชัน Callback มักใช้สำหรับเหตุการณ์ต่างๆ เช่น การกดปุ่ม หรือการอัปเดตข้อมูลจากเซ็นเซอร์

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

void onPressed() {
  Brain.Screen.print("Screen pressed!");
}

// Call onPressed whenever the screen is pressed
int main() {
  vexcodeInit();
  Brain.Screen.pressed(onPressed);
}

Callback Signatures#

ฟังก์ชันเรียกกลับทุกฟังก์ชันต้องมีรูปแบบเฉพาะ ซึ่งกำหนดสิ่งต่อไปนี้:

  • ประเภทการส่งคืน

  • จำนวนพารามิเตอร์

  • ประเภทพารามิเตอร์

รูปแบบการลงนามที่ต้องการจะถูกกำหนดโดย API ฟังก์ชันเรียกกลับต้องตรงกับรูปแบบการลงนามนี้อย่างแม่นยำ

// This callback function cannot include any parameters
void callback(void);


// This callback function includes four parameters
void callback(axisType axis, double x, double y, double z);

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

ฟังก์ชันที่มีอาร์กิวเมนต์เริ่มต้น#

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

กฎสำหรับการกำหนดค่าเริ่มต้น:

  • ค่าเริ่มต้น ต้องเป็น พารามิเตอร์สุดท้ายในคำจำกัดความของฟังก์ชัน

  • เมื่อพารามิเตอร์ใดมีค่าเริ่มต้นแล้ว พารามิเตอร์ทั้งหมดหลังจากนั้นจะต้องมีค่าเริ่มต้นด้วยเช่นกัน

  • หากฟังก์ชันระบุอาร์กิวเมนต์เริ่มต้นใน prototype ค่าเริ่มต้นเหล่านั้นจะต้องไม่ถูกระบุอีกครั้งในคำจำกัดความของฟังก์ชัน

// Required parameter first, default parameter last
void greeting(const char* name, int repeatCount = 1) {

    for (int i = 0; i < repeatCount; i++) {
        Brain.Screen.print("Hello, %s!", name);
        Brain.Screen.newLine();
    }
}

int main() {
    vexcodeInit();

    // Say what name to greet (V5) and
    // use default value for repeatCount (1)
    greeting("V5");

    Brain.Screen.newLine();

    // Overrides the default value to 3
    greeting("V5", 3);
}
On this page