1、函数的声明

  1. // 返回值  函数名称(参数)
  2. //return 返回值
  3. unsigned long Fibonacci(unsigned n) {
  4.   if (n > 2)
  5.     return Fibonacci(n - 1) + Fibonacci(n - 2);
  6.   else
  7.     return 1;
  8. }

2、main 函数

C 语言规定，main()是程序的入口函数，即所有的程序一定要包含一个main()函数。

  1. int main(void) {
  2.   printf("Hello World\n");
  3.   return 0;//表示函数结束运行  如果main()里面省略return 0这一行，编译器会自动加上
  4. }

3、参数的传值引用

  1. /**
  2.  * @brief 交换参数值
  3.  * 
  4.  * @param a 
  5.  * @param b 
  6.  */
  7. void swap(int a, int b)
  8. {
  9.     //这里的参数没有传递的是值，不是指针引用
  10.     //影响不了原始变量
  11.     int t = b;
  12.     b = a;
  13.     a = t;
  14. }
  16. /**
  17.  * @brief 交换参数值
  18.  * 
  19.  * @param a 
  20.  * @param b 
  21.  */
  22. void swap2(int *a, int *b)
  23. {
  24.     //通过传入变量x和y的地址，函数内部就可以直接操作该地址，
  25.     //从而实现交换两个变量的值。
  26.     int t = *b;
  27.     *b = *a;
  28.     *a = t;
  29. }
  31. int main(int argc, char const *argv[])
  32. {
  33.     int a = 1;
  34.     int b = 2;
  35.     swap(a, b);
  36.     printf("swap  a=%d, b=%d", a, b);
  38.     swap2(&a, &b);
  40.     printf("swap2 a=%d, b=%d", a, b);
  41.     return 0;
  42. }

4、函数指针

  • 赋值方式 ```c void print(int a) { printf(“%d\n”, a); }

//返回值 (指针名称)(参数类型) = void (*print_ptr)(int) = &print;

  1. C 语言还规定，函数名本身就是指向函数代码的指针，通过函数名就能获取函数地址。也就是说，print 和 &print是一回事。
  3. - 函数作为参数传递
  4. ```java
  5. int myfunc(int a){
  6.     return a+1;
  7. }
  9. int compute(int (*myfunc)(int), int a, int b){
  10.     return myfunc(a) + b;
  11. }
  13. int main(int argc, char const *argv[])
  14. {
  15.     int a = 1;
  16.     int b = 2;
  17.     printf("函数指针=== %d", compute(&myfunc,a,b));
  18.     return 0;
  19. }
  21. //输出 4

5、函数原型

函数必须先声明，后使用。由于程序总是先运行main()函数，导致所有其他函数都必须在main()函数之前声明。

C 语言提供的解决方法是，只要在程序开头处给出函数原型，函数就可以先使用、后声明。

  1. #include <stdio.h>
  2. //声明函数原型
  3. int twice(int);
  5. int main(int argc, char const *argv[])
  6. {
  7.     printf("函数原型==%d",twice(1));
  8.     return 0;
  9. }
  11. //使用函数原型后，可以声明在 main方法后
  12. int twice(int num) {
  13.   return 2 * num;
  14. }

6、exit()

exit()函数用来终止整个程序的运行。一旦执行到该函数，程序就会立即结束。该函数的原型定义在头文件stdlib.h里面。

7、extern 说明符

对于多文件的项目，源码文件会用到其他文件声明的函数。这时，当前文件里面，需要给出外部函数的原型，并用extern说明该函数的定义来自其他文件。

  1. extern int foo(int arg1, char arg2);
  2. // 相当于 int foo(int arg1, char arg2);
  4. int main(void) {
  5.   int a = foo(2, 3);
  6.   // ...
  7.   return 0;
  8. }

8、static 说明符

static用于函数内部声明变量时，表示该变量只需要初始化一次，不需要在每次调用时都进行初始化。

9、const 说明符

函数参数里面的const说明符，表示函数内部不得修改该参数变量。

10、可变参数

  1. // ... 表示可变参数
  2. int printf(const char* format, ...);