C语言-函数

函数是一组一起执行一个任务的语句。每个 C 程序都至少有一个函数，即主函数 main() 。

主函数可以调用其他函数，其他函数也可以相互调用，用户也可以那个自定义函数。

函数声明告诉编译器函数的名称、返回类型和参数。函数定义提供了函数的实际主体。

一、自定义函数

1、函数定义与声明

1.1 定义

一个函数应该包括函数头和函数体。定义函数的基本语法如下：

return_dataType function_name( parameter list )
{
   body of the function
}
1
2
3
4

函数说明：

• return_dataType：返回值类型，它是函数返回的值的数据类型。可以是C语言中的任意数据类型。也可以不返回值，这种情况下，return_dataType 是关键字 void。
• function_name：函数名称，，它函数标识符的命名规则。函数名和参数列表一起构成了函数签名。
• 参数列表：参数就像是占位符。当函数被调用时，您向参数传递一个值，这个值被称为实际参数。参数列表包括函数参数的类型、顺序、数量。参数是可选的，也就是说，函数可能不包含参数。
• body：函数主体，它是函数需要执行的代码语句，是函数的主体部分。

注意：C语言中，函数的定义是相互平行、独立的。即，函数体内不能包含其他函数的定义。

示例如下：

/* 函数返回两个数中较大的那个数 */
int max(int num1, int num2) {
    /* 局部变量声明 */
    int result;

    if (num1 > num2) {
        result = num1;
    } else {
        result = num2;
    }
    return result; 
}
1
2
3
4
5
6
7
8
9
10
11
12

2、函数声明

函数定义是为了让编译器知道函数的功能，而函数声明是为了让编译器预先知道函数名称、参数、返回类型等信息。而函数的实际主体可以单独定义。

函数声明的代码和函数定义时的函数头已基本一致，但是末尾要添加分号。一般格式如下：

return_dataType function_name( parameter list );

一般我们定义函数之前，要先对函数进行声明。因为编译器对 C代码是顺序编译的，而且总是从 main函数开始的。所以：

• 如果自定义函数位于 main函数后面，则必须在 main函数前面先声明该函数（即调用之前先声明）。
• 如果自定义函数位于 main函数前面，则不再进行函数声明，因此此时函数定义已包含了函数声明的作用。

示例如下：

int max(int num1, int num2);
1

2、调用函数

创建 C 函数时，会定义函数做什么，然后通过调用函数来完成已定义的任务。

当程序调用函数时，程序控制权会转移给被调用的函数。被调用的函数执行已定义的任务，当函数的返回语句被执行时，或到达函数的结束括号时，会把程序控制权交还给主程序。

通过函数名调用函数，并传递所需参数，如果函数返回一个值，则可以存储返回值。

实例1：调用之前先声明后定义函数

#include 

/* 函数声明 */
int max(int num1, int num2);

int main() {
    /* 局部变量定义 */
    int a = 100;
    int b = 200;
    int ret;

    /* 调用函数 */
    ret = max(a, b);

    printf("Max value is : %d\n", ret);

    return 0;
}

/* 函数定义：返回两个数中较大的那个数 */
int max(int num1, int num2) {
    /* 局部变量声明 */
    int result;

    if (num1 > num2) {
        result = num1;
    } else {
        result = num2;
    }
    return result;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

实例2：调用之前以定义函数

#include 

/* 函数定义 */
void exchange(int a, int b) {
    int temp;
    temp = a;
    a = b;
    b = temp;
    printf("exchange: a=%d, b=%d\n", a, b);
}

int main() {
    /* 局部变量定义 */
    int a = 100;
    int b = 200;

    /* 调用函数 */
    printf("1 --- a=%d, b=%d\n", a, b);
    exchange(a, b);
    printf("2 --- a=%d, b=%d\n", a, b);

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

二、函数传递参数的方式

函数参数的作用是传递数据给函数使用。

函数的参数可以分为两种：

• 形式参数：声明和定义函数时，参数列表中的参数就是形式参数，简称形参。
• 实际参数：调用函数时，传递给函数的参数就是实际参数，简称实参。

当调用函数时，有两种向函数传递参数的方式：

• 传值调用：把参数的实际值复制给函数的形式参数。在这种情况下，修改函数内的形式参数不会影响实际参数。
• 引用调用：通过指针传递方式，形参为指向实参地址的指针，当对形参的指向操作时，就相当于对实参本身进行的操作。

默认情况下，C 使用传值调用来传递参数。一般来说，这意味着函数内的代码不能改变用于调用函数的实际参数。

实例1：值传递。函数调用中的实例就是值传递，这里就不实例了。

实例2：引用传递

#include 

/* 函数声明 */
void my_swap(int *x, int *y);

int main() {
    /* 局部变量定义 */
    int a = 100;
    int b = 200;

    printf("交换前，a 的值： %d\n", a);
    printf("交换前，b 的值： %d\n", b);

    /* 调用函数来交换值
      &a 表示指向 a 的指针，即变量 a 的地址
      &b 表示指向 b 的指针，即变量 b 的地址
    */
    my_swap(&a, &b);
    printf("交换后，a 的值： %d\n", a);
    printf("交换后，b 的值： %d\n", b);

    return 0;
}

/* 函数定义 */
void my_swap(int *x, int *y) {
    int temp;
    temp = *x;    /* 保存地址 x 的值 */
    *x = *y;      /* 把 y 赋值给 x */
    *y = temp;    /* 把 temp 赋值给 y */
    return;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

三、局部变量和全局变量

作用域（Scope）就是变量的有效范围，就是变量可以在哪个范围以内使用。

变量的作用域由变量的定义位置决定，在不同位置定义的变量，它的作用域是不一样的。

1、局部变量

定义在函数内部的变量称为局部变量（Local Variable），它的作用域仅限于函数内部， 出了函数就不能使用了。

函数的形参也是局部变量，也只能在函数内部使用。

示例如下：

#include 

int sum(int m, int n) {
    int i, sum = 0;
    //m、n、i、sum 都是局部变量，只能在 sum() 内部使用
    for (i = m; i <= n; i++) {
        sum += i;
    }
    return sum;
}

int main() {
    int begin = 5, end = 86;
    int result = sum(begin, end);
    //begin、end、result 也都是局部变量，只能在 main() 内部使用
    printf("The sum from %d to %d is %d\n", begin, end, result);

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

2、全局变量

在所有函数外部定义的变量称为全局变量（Global Variable），它的作用域默认是整个程序，也就是所有的代码文件（源文件），包括源文件（.c文件）和头文件（.h文件）。

如果给全局变量加上 static 关键字，它的作用域就变成了当前文件，在其它文件中就无效了。

示例如下：

#include 

//定义三个全局变量，分别表示三个面的面积
int s1 = 0, s2 = 0, s3 = 0;

int vs(int length, int width, int height) {
    int v;  //体积
    v = length * width * height;
    s1 = length * width;
    s2 = width * height;
    s3 = length * height;
    return v;
}

int main() {
    int v = 0;
    v = vs(15, 20, 30);
    printf("v=%d, s1=%d, s2=%d, s3=%d\n", v, s1, s2, s3);
    v = vs(5, 17, 8);
    printf("v=%d, s1=%d, s2=%d, s3=%d\n", v, s1, s2, s3);

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

四、内部函数和外部函数

1、内部函数

如果定义一个函数只能被所在的源文件使用，那么这样的函数就称为内部函数，又称为静态函数。

定义内部函数时，使用关键字 static 进行修饰。先声明时一样修饰。

static return_dataType function_name( parameter list )
{
   body of the function
}
1
2
3
4

使用内部函数的好处是，不同开发者编写函数时，不必再担心函数是否会与其他源文件中的函数同名，因为内部函数只在所在源文件中有效，不同源文件中即使有相同的函数名，也没有关系。

2、外部函数

外部函数是可以是被其他源文件调用的函数，

定义外部函数时，使用关键字 extern 进行修饰。先声明时一样修饰。

extern return_dataType function_name( parameter list )
{
   body of the function
}
1
2
3
4

常见标准库函数：https://cplusplus.com/reference/clibrary/

– 求知若饥，虚心若愚。