目前主要分为三个专栏，后续还会添加：

        专栏如下：                 C语言刷题解析       C语言系列文章       我的成长经历

感谢阅读！

初来乍到，如有错误请指出，感谢！

目录

1. 函数的概念
2. 库函数
3. 自定义函数
4. 形参和实参
5. return语句
6. 数组做函数参数
7. 嵌套调用和链式访问
8. 函数的声明和定义

1. 函数的概念

2. 库函数

2.1 标准库和头文件

C语言标准中规定了C语言的各种语法规则，C语言并不提供库函数；

语言的国际标准ANSI C规定了⼀些常用的函数的标准，被称为标准库。

那不同的编译器厂商根据ANSI提供的C语言标准就给出了⼀系列 函数的实现。

这些函数就被称为库函数。

#include <stdio.h>      /* printf */
#include <math.h>       /* sqrt */

int main ()
{
	double param, result;
	param = 1024.0;
	result = sqrt (param);
	printf ("sqrt(%f) = %f\n", param, result );
	return 0;
}

2.2.3 实践

#include <stdio.h>
#include <math.h>

int main()

{
 double d = 16.0;
 double r = sqrt(d);
 printf("%lf\n", r);
 return 0;
}

 2.2.4 库函数文档的一般格式

• 函数原型
• 函数功能介绍
• 参数和返回类型说明
• 代码举例
• 代码输出
• 相关知识链接

 3. 自定义函数

3.1 函数的语法形式

ret_type fun_name(形式参数)
{

}

• ret_type 是用来表示函数计算结果的类型，有时候返回类型可以是 void ，表示什么都不返回
• fun_name 是为了方便使用函数；就像人的名字⼀样，有了名字方便称呼，函数有了名字方便调用，所以函数名尽量要根据函数的功能起的有意义。
• 函数的参数就相当于，工厂中送进去的原材料，函数的参数也可以是 void ，明确表示函数没有参数。如果有参数，要交代清楚参数的类型和名字，以及参数个数。
• {  }  括起来的部分被称为函数体，函数体就是完成计算的过程。

3.2 函数的举例

#include <stdio.h>

int main()

{
 int a = 0;
 int b = 0;
 //输⼊
 scanf("%d %d", &a, &b);
 //调⽤加法函数，完成a和b的相加
 //求和的结果放在r中
 //to do
 
 //输出
 printf("%d\n", r);
 return 0;

}

#include <stdio.h>
int Add(int x, int y)
{
 int z = 0;
 z = x+y;
 return z;
}

#include <stdio.h> // 引入标准输入输出库

// 定义一个函数Add，用于计算两个整数的和
int Add(int x, int y)
{
    int z = 0; // 初始化变量z为0，用于存储结果
    z = x + y; // 将x和y相加的结果赋值给z
    return z; // 返回计算结果
}

int main()
{
    int a = 0; // 定义变量a，用于存储输入的第一个整数
    int b = 0; // 定义变量b，用于存储输入的第二个整数

    // 使用scanf函数从标准输入读取两个整数，分别赋值给变量a和b
    scanf("%d %d", &a, &b);

    // 调用Add函数，将变量a和b作为参数传递，计算它们的和
    // 将求和的结果存储在变量r中
    int r = Add(a, b);

    // 使用printf函数输出求和结果r
    printf("%d\n", r);

    return 0; // 程序正常结束，返回0
}

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

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

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

例如：

#include <stdio.h>
 
/* 函数声明 */
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; 
}

4. 形参和实参

4.1 实参

4.2 形参

实际上，如果只是定义了 Add 函数，⽽不去调⽤的话， Add 函数的参数 x 和 y 只是形式上存在的，不会向内存申请空间，不会真实存在的，所以叫形式参数。

形式参数只有在函数被调⽤的过程中为了存放实参传递过来的值，才向内存申请空间，这个过程就是形式的实例化。

4.3 实参和形参的关系

形参是实参的⼀份临时拷贝。

6.数组做函数参数

#include <stdio.h>
int main()
{
 int arr[] = {1,2,3,4,5,6,7,8,9,10};
 set_arr();//设置数组内容为-1
 print_arr();//打印数组内容
 return 0;
}

这⾥的set_arr函数要能够对数组内容进⾏设置，就得把数组作为参数传递给函数。

同时函数内部在设置数组每个元素的时候，也得遍历数组，需要知道数组的元素个数。

所以我们需要给set_arr传递2个参数

⼀个是数组，另外⼀个是数组的元素个数。

仔细分析print_arr也是⼀样的，只有拿到了数组和元素个数，才能遍历打印数组的每个元素。

#include <stdio.h>
int main()
{
 int arr[] = {1,2,3,4,5,6,7,8,9,10};
 int sz = sizeof(arr)/sizeof(arr[0]);
 set_arr(arr, sz);//设置数组内容为-1
 print_arr(arr, sz);//打印数组内容
 return 0;
}

数组作为参数传递给了set_arr 和 print_arr 函数了，那这两个函数应该如何设计呢？

这⾥我们需要知道数组传参的⼏个重点知识：

• 函数的形式参数要和函数的实参个数匹配
• 函数的实参是数组，形参也是可以写成数组形式的
• 形参如果是⼀维数组，数组大小可以省略不写
• 形参如果是⼆维数组，行可以省略，但是列不能省略
• 数组传参，形参是不会创建新的数组的
• 形参操作的数组和实参的数组是同⼀个数组

根据上述的信息，我们就可以实现这两个函数：

void set_arr(int arr[], int sz)
{
 int i = 0;
 for(i=0; i<sz; i++)
 {
 arr[i] = -1;
 }
}

void print_arr(int arr[], int sz)
{
   int i = 0;
   for(i=0; i<sz; i++)
   {
   printf("%d ", arr[i]);
   }
   printf("\n");
}

---

7. 嵌套调用和链式访问

7.1 嵌套调用

嵌套调⽤就是函数之间的互相调⽤，每个函数就还⼀个乐高零件。

正是因为多个乐⾼的零件互相⽆缝的配合才能搭建出精美的乐⾼玩具，也正是因为函数之间有效的互相调⽤，最后写出来了相对⼤型的程序。

假设我们计算某年某月有多少天？

如果要函数实现，可以设计2个函数:

• is_leap_year()：根据年份确定是否是闰年
• get_days_of_month()：调用is_leap_year确定是否是闰年后，再根据月计算这个月的天数

// 函数用于判断给定的年份是否为闰年
int is_leap_year(int y)
{
    // 如果年份能被4整除且不能被100整除，或者能被400整除，则为闰年
    if(((y%4==0)&&(y%100!=0))||(y%400==0))
        return 1; // 返回1表示是闰年
    else
        return 0; // 返回0表示不是闰年
}

// 函数用于获取给定年份和月份的天数
int get_days_of_month(int y, int m)
{
    // 定义一个数组，存储每个月的天数，数组的第0个元素未使用
    int days[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    // 获取数组中对应月份的天数
    int day = days[m];
    
    // 如果是闰年且月份为2月，则2月的天数加1
    if (is_leap_year(y) && m == 2)
        day += 1;
    
    // 返回该月份的天数
    return day;
}

// 主函数，用于接收用户输入的年份和月份，并输出该月的天数
int main()
{
    // 定义变量 y 用于存储用户输入的年份
    int y = 0;
    // 定义变量 m 用于存储用户输入的月份
    int m = 0;
    
    // 使用 scanf 函数从标准输入读取年份和月份
    scanf("%d %d", &y, &m);
    
    // 调用 get_days_of_month 函数，传入年份 y 和月份 m，获取该月的天数
    int d = get_days_of_month(y, m);
    
    // 使用 printf 函数输出该月的天数
    printf("%d\n", d);
    
    // 主函数返回0，表示程序正常结束
    return 0;
}

这⼀段代码，完成了⼀个独⽴的功能。代码中反应了不少的函数调用：

• main 函数调⽤ scanf 、 printf 、 get_days_of_month
• get_days_of_month 函数调⽤ is_leap_year

未来的稍微大⼀些代码都是函数之间的嵌套调用，但是函数是不能嵌套定义的。

这段代码中包含两个函数和一个主函数（main），下面是对这些函数调用的详细解释：

is_leap_year 函数：

• 这个函数接收一个整数参数 y，代表需要判断的年份。
• 函数内部首先检查年份是否满足闰年的条件：
• 如果年份能被4整除且不能被100整除，或者能被400整除，则认为是闰年。
• 如果条件满足，函数返回 1 表示是闰年；如果不满足，返回 0 表示不是闰年。

get_days_of_month 函数：

• 这个函数接收两个整数参数：y（年份）和 m（月份）。
• 函数内部定义了一个数组 days[]，用于存储每个月的标准天数（非闰年情况下）。
• 根据输入的月份 m，从数组 days[] 中获取对应月份的天数，并存储在变量 day 中。
• 如果输入的年份 y 是闰年，并且月份 m 为2月（即二月），则在 day 的基础上加1，因为闰年的二月有29天。
• 最后，函数返回变量 day 的值，即该月的天数。

main 函数：

• 这是程序的入口点，也是主函数。
• 首先定义了两个整型变量 y 和 m，用于存储用户输入的年份和月份。
• 使用 scanf 函数从标准输入读取用户输入的年份和月份，并将它们存储在变量 y 和 m 中。
• 接下来，调用 get_days_of_month 函数，并将读取的年份 y 和月份 m 作为参数传递。函数的返回值（即该月的天数）被存储在变量 d 中。
• 使用 printf 函数输出变量 d 的值，即用户查询的月份的天数。
• 最后，main 函数返回 0，表示程序正常结束。

在实际运行时，用户会被提示输入一个年份和一个月份，程序会根据输入的值调用

get_days_of_month 函数

来计算并输出该月的天数。

如果是闰年且用户查询的是2月，输出的天数将是29天；

否则，输出的是该月的标准天数。

---

7.2 链式访问

所谓链式访问就是将⼀个函数的返回值作为另外⼀个函数的参数，像链条⼀样将函数串起来就是函数的链式访问。

⽐如：

#include <stdio.h>
int main()
{
     int len = strlen("abcdef");//1.strlen求⼀个字符串的⻓度
     printf("%d\n", len);//2.打印⻓度 
     return 0;
}

前⾯的代码完成动作写了2条语句，把如果把strlen的返回值直接作为printf函数的参数呢？

这样就是⼀个链式访问的例子了。

#include <stdio.h>
int main()
{
     printf("%d\n", strlen("abcdef"));//链式访问
     return 0;
}

再看⼀个有趣的代码，下⾯代码执⾏的结果是什么呢？

#include <stdio.h>
int main() 
{
	printf("%d", printf("%d", printf("%d", 43)));
	return 0;
}

这个代码的关键是明⽩ printf 函数的返回是啥？

printf - C++ Reference (cplusplus.com)

int printf ( const char * format, ... );

printf函数返回的是打印在屏幕上的字符的个数。

上⾯的例子中，我们就第一个printf打印的是第二个printf的返回值，第二个printf打印的是第三个

printf的返回值。

第三个printf打印43，在屏幕上打印2个字符，再返回2

第二个printf打印2，在屏幕上打印1个字符，再放回1

第一个printf打印1

所以屏幕上最终打印：4321

#include <stdio.h>
//判断⼀年是不是闰年
int is_leap_year(int y)
{
	if (((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0))
		return 1;
	else
		return 0;
}
int main()
{
	int y = 0;
	scanf("%d", &y);
	int r = is_leap_year(y);
	if (r == 1)
		printf("闰年\n");
	else
		printf("⾮闰年\n");
	return 0;
}

这个代码在VS2022上编译，会出现下⾯的警告信息：  

这是因为C语⾔编译器对源代码进⾏编译的时候，从第⼀⾏往下扫描的，当遇到第7⾏的is_leap_year 函数调⽤的时候。

并没有发现前⾯有is_leap_year的定义，就报出了上述的警告。

把怎么解决这个问题呢？

就是函数调⽤之前先声明⼀下is_leap_year这个函数，声明函数只要交代清 楚：函数名，函数的返回类型和函数的参数。

如：int is_leap_year(int y)；

这就是函数声明，函数声明中参数只保留类型，省略掉名字也是可以的。

代码变成这样就能正常编译了。

#include <stdio.h>
//判断⼀年是不是闰年
int is_leap_year(int y);

int main()
{
	int y = 0;
	scanf("%d", &y);
	int r = is_leap_year(y);
	if (r == 1)
		printf("闰年\n");
	else
		printf("非闰年\n");
	return 0;
}

int is_leap_year(int y)
{
	if (((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0))
		return 1;
	else
		return 0;
}

// 函数的声明

int Add ( int x, int y);

test.c  

# include <stdio.h>

# include "add.h"

int main ()

{

        int a = 10 ;

        int b = 20 ;

        //函数调⽤

        int c = Add(a, b);

        printf ( "%d\n" , c);

  return 0 ;

}

运⾏结果：

有了函数声明和函数定义的理解，我们写代码就更加方便了 

8.3 static 和 extern

static 和 extern 都是C语⾔中的关键字。

static 是 静态的 的意思，可以⽤来：

• 修饰局部变量
• 修饰全局变量
• 修饰函数

extern 是⽤来声明外部符号的。

在讲解 static 和 extern 之前再讲⼀下：作⽤域和⽣命周期。  

1. 局部变量的作用域是变量所在的局部范围。

2. 全局变量的作用域是整个工程（项目）。

8.3.1 static 修饰局部变量：  

int g_val = 2018 ;

test.c  

# include <stdio.h>

extern int g_val;

int main ()

{

        printf ( "%d\n" , g_val);

        return 0 ;

}

static int g_val = 2018 ;

 test.c

# include <stdio.h>

extern int g_val;

int main ()

{

        printf ( "%d\n" , g_val);

        return 0 ;

}

结论：

一个全局变量被static修饰，使得这个全局变量只能在本源⽂件内使用，不能在其他源⽂件内使用。

本质原因是全局变量默认是具有外部链接属性的，在外部的文件中想使用，只要适当的声明就可以使用；

但是全局变量被 static 修饰之后，外部链接属性就变成了内部链接属性，只能在⾃⼰所在的源文件内部使⽤了，其他源⽂件，即使声明了，也是⽆法正常使⽤的。

使⽤建议：如果⼀个全局变量，只想在所在的源⽂件内部使用，不想被其他⽂件发现，就可以使用static修饰。

8.3.3 static 修饰函数

int Add ( int x, int y)

{

        return x+y;

}

test.c  

# include <stdio.h>

extern int Add ( int x, int y);

int main ()

{

        printf ( "%d\n" , Add( 2 , 3 ));

        return 0 ;

}

static int Add ( int x, int y)

{

        return x+y;

}

 test.c

# include <stdio.h>

extern int Add ( int x, int y);

int main ()

{

        printf ( "%d\n" , Add( 2 , 3 ));

        return 0 ;

}

代码1是能够正常运行的，但是代码2就出现了链接错误。 

使用建议：一个函数只想在所在的源文件内部使用，不想被其他源文件使用，就可以使用 static 修 饰。