【PPT密码】PPT文件的两种不可编辑情况-CFANZ编程社区

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

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

感谢阅读！

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

函数的概念
库函数
自定义函数
形参和实参
return语句
数组做函数参数
嵌套调用和链式访问
函数的声明和定义

1. 函数的概念

数学中我们其实就⻅过函数的概念，⽐如：⼀次函数 y=kx+b ，k和b都是常数，给⼀个任意的x，就得到⼀个y值。

其实在C语言也引⼊函数（function）的概念。

有些翻译为：子程序，子程序这种翻译更加准确一些。

C语⾔中的函数就是⼀个完成某项特定的任务的一小段代码。

这段代码是有特殊的写法和调用方法的。

C语⾔的程序其实是由⽆数个小的函数组合⽽成的，也可以说：⼀个大的计算任务可以分解成若干个较小的函数（对应较小的任务）完成。

同时⼀个函数如果能完成某项特定任务的话，这个函数也是可以复⽤的，提升了开发软件的效率。

在C语言中我们一般会见到两类函数：

库函数
自定义函数

2. 库函数

2.1 标准库和头文件

我们前⾯内容中学到的 printf 、 scanf 都是库函数，库函数的也是函数，不过这些函数已经是现成的，我们只要学会就能直接使⽤了。

有了库函数，⼀些常⻅的功能就不需要程序员自己实现了⼀定程度提升了效率；

同时库函数的质量和执⾏效率上都更有保证。

各种编译器的标准库中提供了⼀系列的库函数，这些库函数根据功能的划分，都在不同的头⽂件中进行了声明。

库函数相关头⽂件：

C 标准库头文件 - cppreference.com

有数学相关的，有字符串相关的，有⽇期相关的等，每⼀个头⽂件中都包含了，相关的函数和类型等信息，库函数的学习不⽤着急⼀次性全部学会，慢慢学习，各个击破就行。

2.2 库函数的使用方法

库函数的学习和查看⼯具很多，⽐如：

C/C++官⽅的链接： https://zh.cppreference.com/w/c/header

cplusplus.com： https://legacy.cplusplus.com/reference/clibrary/

2.2.1 功能

Compute square root 计算平方根

Returns the square root of x.（返回平⽅根）

2.2.2 头文件包含

库函数是在标准库中对应的头⽂件中声明的，所以库函数的使用，务必包含对应的头⽂件，不包含是可能会出现⼀些问题的。

举例： sqrt

#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(形式参数)
{

}

我们可以把函数想象成小型的⼀个加⼯⼚，⼯⼚得输⼊原材料，经过⼯⼚加⼯才能⽣产出产品，那函数也是⼀样的。

函数⼀般会输⼊⼀些值（可以是0个，也可以是多个），经过函数内的计算，得出结果。

3.2 函数的举例

举个例⼦：

写⼀个加法函数，完成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;

}

我们根据要完成的功能，给函数取名：Add，函数Add需要接收2个整型类型的参数，函数计算的结果也是整型。

所以我们根据上述的分析写出函数：

#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 实参

在上⾯代码中，第3~8⾏是 Add 函数的定义，有了函数后，再第19⾏调⽤Add函数的。

我们把第19行调用Add函数时

传递给函数的参数a和b，称为实际参数，简称实参。

实际参数就是真实传递给函数的参数。

4.2 形参

在上⾯代码中，第2⾏定义函数的时候，在函数名 Add 后的括号中写的 x 和 y

称为形式参数，简称形参。

为什么叫形式参数呢？

4.3 实参和形参的关系

虽然我们提到了实参是传递给形参的，他们之间是有联系的，但是形参和实参各⾃是独⽴的内存空间。

这个现象是可以通过调试来观察的。

请看下⾯的代码和调试演示：

我们在调试的可以观察到，x 和 y 确实得到了 a 和 b的值，但是x 和 y 的地址和 a 和 b的地址是不⼀样的，所以我们可以理解为。

5. return 语句

在函数的设计中，函数中经常会出现return语句，这⾥讲⼀下return语句使⽤的注意事项。

6.数组做函数参数

在使⽤函数解决问题的时候，难免会将数组作为参数传递给函数，在函数内部对数组进⾏操作。

⽐如：

写⼀个函数对将⼀个整型数组的内容，全部置为-1，再写⼀个函数打印数组的内容。

简单思考⼀下，基本的形式应该是这样的：

#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个函数:

// 函数用于判断给定的年份是否为闰年
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），下面是对这些函数调用的详细解释：

is_leap_year 函数：

get_days_of_month 函数：

main 函数：

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

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)

8. 函数的声明和定义

8.1 单个文件

⼀般我们在使⽤函数的时候，直接将函数写出来就使⽤了。

⽐如：我们要写⼀个函数判断⼀年是否是闰年。

#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;
}

函数的调⽤⼀定要满意，先声明后使⽤；

函数的定义也是⼀种特殊的声明，所以如果函数定义放在调⽤之前也是可以的。