A function prototype is essentially a *stripped* declaration of a function that goes before the actual declaration of the function. For example, look at this piece of code:
```c
#include <stdio.h>

int main() {
  printf("%d\n", sum(1));
  return 0;
}

int sum(int x, int y) {
  return x + y;
}
```
If you look closely, you'll notice that, in the `main` function, `sum` is only called with one argument. Many compilers would happy compile this code, perhaps with a warning. For example, gcc will give you the warning `implicit declaration of function 'sum' [-Wimplicit-function-declaration]`, but proceed to yield a working executable.
When such call happens, the argument of interest(`y`, in this case), is undefined, and is likely a value on the stack(on 32-bit systems) or in one of the registers(on 64-bit system).
To avoid this behavior, you can add a **function prototype** at the top(the location actually doesn't matter, as long as its above potential callers, such as `main`!) of the file, like so:
```c
#include <stdio.h>

int sum(int, int); // This is the function prototype!

int main() {
  printf("%d\n", sum(1));
  return 0;
}

int sum(int x, int y) {
  return x + y;
}
```
As you can see, the function prototype is indeed just a stripped declaration: `int sum(int x, int y)` was turned into `int sum(int, int)`. Now, if we try compiling this code using gcc, we'll get the error `too few arguments to function 'sum'`, and no executable will be generated.

Function prototypes are a really important feature of C and should always be used to save hours of potential debugging.
ต้นแบบฟังก์ชันโดยพื้นฐานแล้วคือการประกาศแบบ *แยก* ของฟังก์ชันที่ดำเนินไปก่อนที่จะมีการประกาศฟังก์ชันจริง ตัวอย่างเช่น ดูที่โค้ดชิ้นนี้: ```c #include <stdio.h> int main() { printf("%d\n", sum(1)); กลับ 0; } ผลรวม int (int x, int y) { กลับ x + y; } ``` หากคุณมองใกล้ ๆ คุณจะสังเกตเห็นว่าในฟังก์ชัน `main` นั้น `sum` จะถูกเรียกด้วยอาร์กิวเมนต์เดียวเท่านั้น คอมไพเลอร์หลายคนยินดีที่จะคอมไพล์โค้ดนี้ อาจมีคำเตือนด้วย ตัวอย่างเช่น gcc จะให้คำเตือน `การประกาศโดยนัยของฟังก์ชัน 'ผลรวม' [-Wimplicit-function-declaration]` แต่ดำเนินการต่อไปเพื่อให้ได้ไฟล์ปฏิบัติการที่ใช้งานได้ เมื่อการเรียกดังกล่าวเกิดขึ้น อาร์กิวเมนต์ที่สนใจ (`y` ในกรณีนี้) จะไม่ถูกกำหนด และน่าจะเป็นค่าบนสแต็ก (บนระบบ 32 บิต) หรือในรีจิสเตอร์ตัวใดตัวหนึ่ง (บนระบบ 64 บิต) . เพื่อหลีกเลี่ยงพฤติกรรมนี้ คุณสามารถเพิ่ม **function Prototype** ที่ด้านบนสุดได้ (จริงๆ แล้วตำแหน่งนั้นไม่สำคัญ ตราบใดที่ตำแหน่งที่สูงกว่าผู้ที่อาจเป็นผู้เรียก เช่น `main`!) ของไฟล์ เช่น: ` ``c #include <stdio.h> ผลรวม int(int, int); // นี่คือฟังก์ชันต้นแบบ! int main() { printf("%d\n", ผลรวม (1)); กลับ 0; } ผลรวม int (int x, int y) { กลับ x + y; } ``` อย่างที่คุณเห็น ต้นแบบของฟังก์ชันเป็นเพียงการประกาศแบบแยกส่วน: `int sum(int x, int y)` ถูกเปลี่ยนเป็น `int sum(int, int)` ตอนนี้ หากเราพยายามรวบรวมโค้ดนี้โดยใช้ gcc เราจะได้รับข้อผิดพลาด `มีอาร์กิวเมนต์น้อยเกินไปที่จะฟังก์ชัน 'sum'` และจะไม่มีการสร้างไฟล์ปฏิบัติการใด ๆ ต้นแบบฟังก์ชันเป็นคุณลักษณะที่สำคัญมากของ C และควรใช้เสมอเพื่อประหยัดเวลาหลายชั่วโมงในการแก้ไขข้อบกพร่องที่อาจเกิดขึ้น
spam fails_task lang_mismatch pii not_appropriate hate_speech sexual_content quality toxicity humor helpfulness creativity violence