#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
库函数
strcpy的用法：、
将一个字符串拷贝至另一个字符串中。
如：拷贝“hello bit”
#include<string.h>//strcpy函数的头文件
int main()
{
char arr1[20] = { 0 };//容量为20的空字符串
char arr2[] = "hello bit";
strcpy(arr1,arr2);//写法一：
//即(char *destination, const char * source);。
//其中，char *destination与char * source都是指针。
char* ret = strcpy(arr1, arr2);//写法二：
//strcpy的返回类型：char*。
//当strcpy把源字符串内容拷贝到目标字符串中时，它会把目标字符串的地 址返回来。
//故，这里便可以用char*指针来接收它的返回类型。
//不能这样写：char* strcpy(char* arr1, const char* arr2);或char* strcpy(char* arr1, char* arr2);
printf("%s\n", arr1);
printf("%s\n", ret);
return 0;
}
memset——设置内存
memory——记忆——计算机中：内存
memset定义：将指针所指的内存块中的前num个字节设置成特定的值。
memset用法：这个函数通常为新申请的内存做初始化工作。
函数介绍
void* memset(void* s, int ch, size_t n);/*或者是void* memset(void* ptr, int value, size_t sum);*/
函数解释：将s中当前位置后面的n个字节 （typedef unsigned int size_t ）用 ch 替换并返回 s 。
memset：作用是在一段内存块中填充某个给定的值，它是对较大的结构体或数组进行清零操作的一种最快方法[1]。
memset()函数原型是extern void* memset(void* buffer, int c, int count)
buffer：为指针或是数组, c：是赋给buffer的值, count：是buffer的长度.
或者是void* memset(void* ptr, int value, size_t sum);
ptr：Pointer to the block of memory to fill——为填充内存块的指针或是数组。
value：Value to be set——是赋给ptr的值。
num：Number of bytes to be set to the value——是ptr的长度。
int main()
{
char arr[20] = "hello bit";
//此时内存块已经确定：hello bit\0 (后面还有10“空位”)
printf("%s\n", arr);
//现在想把这个数组前5个字符都改成x
memset(arr, 'x', 5);//用.逗号隔开
printf("%s\n", arr);
/*memset(arr, "pijiu", 5);
printf("%s\n", arr);*///这样修改并不能达到想要的结果——pijiu bit，只能得到——" bit" (四个字符)。
return 0;
}
自定义函数
练习一：写一个函数可以找出两个整数中的最大值
第(1)步：推演函数使用场景
int main()
{
int a = 0;
int b = 0;
scanf("%d %d", &a, &b);
int max = get_max(a, b);
printf("%d\n", max);
return 0;
}
↓
↓
第(2)步：get_max函数的设计
方法一：
int get_max(int x, int y)
{
return(x > y) ? (x) : (y); //return (x > y ? x : y);
}
int main()
{
int a = 10;
int b = 20;
int max = get_max(a, b);
printf("max = %d\n", max);
return 0;
}
方法二：
int get_max(int x, int y)
{
if (x > y)
return x;
else
return y;
}
int main()
{
int a = 10;
int b = 20;
int max1 = get_max(a, b);//变量
int max2 = get_max(30,20);//常量
int max3 = get_max(15+15,30+10);//表达式
int max4 = get_max(get_max(3,50), 10 + 10);//函数
printf("max1 = %d\n", max1);
printf("max2 = %d\n", max2);
printf("max3 = %d\n", max3);
printf("max4 = %d\n", max4);
return 0;
}
void的使用场景
①void test：函数在调用完后什么都不需要返回。
②test(void)：这个函数没有参数，不能用来传参。
①
void test()
{
printf("hehe\n");
}
int main()
{
test();
return 0;
}
②
test(void)
{
printf("hehe\n");
}
int main()
{
test();
return 0;
}
练习二：写一个函数可以交换两个整形变量的内容。
(非函数版)
#include<stdlib.h>//system头文件
#include<windows.h>//windows头文件
int main()
{
int a = 0;
int b = 0;
//输入
scanf("%d %d", &a, &b);
system("cls");
printf("交换前：%d %d\n", a, b);
int tmp = 0;//第三个变量
//交换
tmp = a;
a = b;
b = tmp;
Sleep(1000);
system("cls");
printf("交换后：%d %d\n", a, b);
return 0;
}
函数版
#include <stdio.h>
实现成函数，但是不能完成任务：通过调试可以发现，在进行交换的过程中，swap仅仅只把a,b(实际参数)的值赋给了x,y(形数式参)，[这时形参只相当于实参的一份临时拷贝]，并对x,y进行了交换，但是实际参数并不会因为形式参数(形参有自己的独立空间)的改变而改变，因此在返回主函数时并不能实现a,b的交换。所以需要把a,b的地址与x,y进行一一对应，建立联系(注意：这里不是说交换地址，地址是无法交换的)，这样在返回主函数时才能实现交换a,b。
void Swap1(int x, int y)//x,y：形式参数（形参）
{
int tmp = 0;
tmp = x;
x = y;
y = tmp;
}
//正确的版本①：把a,b的地址与x,y进行一一对应
void Swap2(int* px, int* py)//px,py：形参。int* 指针类型，px,py指针变量。
{
int tmp = 0;
tmp = *px;
*px = *py;
*py = tmp;
}
int main()
{
int a = 1;
int b = 2;//a,b；实际参数（实参）
Swap1(a, b);
printf("Swap1::a = %d b = %d\n", a, b);
Swap2(&a, &b);//&a,&b都是实参。
printf("Swap2::a = %d b = %d\n", a, b);
return 0;
}
//正确版本②：
void Swap(int* pa, int* pb)
{
int tmp = 0;
tmp = *pa;
*pa = *pb;
*pb = tmp;
}
int main()
{
int a = 0;
int b = 0;
scanf("%d %d", &a, &b);
Swap(&a, &b);//对a,b取地址，准备将a,b地址与px,py建立联系。
printf("Swap:a = %d b = %d\n", a, b);
return 0;
}
指针内容回顾：
int main()
{
int a = 20;
int* pa = &a;//pa = &a：将a的地址托付给pa。int* pa：pa的类型是int*。
*pa = 10;//由上可知pa里存的地址，所以*pa就是a(pa前加上*：解引用 详见讲义初识C语言——指针部分)。
return 0;
}
总结：我们可以发现练习一与练习二不同。前者并没有将a,b地址传给x,y，是因为它只用求最大值(a,b最大值始终都是一样的)，故不需要将a,b值改变；而后者却相反，它会因为a,b值的大小，可能对二者值进行交换，所以需要将a,b地址传过去，建立联系，进而远程遥控对而这进行重新排序。即当自定义函数里的变量需要与主函数里的变量建立联系时，主函数就需要传地址，自定义函数就需要通过指针接收地址。
函数的参数
实际参数（实参）
形式参数（形参）
函数的调用
传值调用
传址调用
练习
1. 写一个函数可以判断一个数是不是素数。
求100~200之间的素数(不用函数版)
错误写法：
int main()
{
int i = 0;
for (int a = 100; a >= 100 && a <= 200; a++)
{
for (i = 2; i >= 2 && i <= a; i++)
{
int b = a % i;
switch (b)
{
case 0:
break;//只break了switch——break只能跳出一次循环。
//即，在i > a之前，不管b是否等于0，i一直++，a值不变。
default:
continue;
}//这种写法会导致a所在范围内所有的数字都被打印。
}
if (i == a+1)//只break了switch——break只能跳出一次循环。当最后一次循环时，进循环前i=a；出循环时，i++=a。
printf("%d ", a);
}
return 0;
}
正确写法：
int main()
{
int i = 0;
for (int a=100;a >=100 && a <= 200;a++)
{
//方法一：
for (i = 2;i >= 2 && i <= a;i++)
{
if (a % i == 0)
break;
else
continue;
}
//printf("%d ", a);//直接这样写，即便是if语句break以后，还会从这里经过，而不是跳过printf，进行a++。
//因此，要给printf加限制条件——满足素数的条件。
if(i == a)//break只会跳出switch和循环语句，并不会跳出if，因此，最后一次循环结束时，不会进行i++。
printf("%d \n", a);
//方法二：
for (i = 2; i >= 2 && i <= a/2; i++)//已知a=b*c，在[0~(a/2)),和((a/2)~a]这两个区间内，
//至少还有一组数字相乘=a——1*a。如果只有1*a，则这个数必是素数。
{
if (a % i == 0)
break;
else
continue;//continue只会作用于switch和循环语句，并不会跳出循环，最后一次循环——i = a / 2结束时，仍会进行i++。故后面if中需要+1。
}
if (i == (a / 2) + 1)
{
printf("%d ", a);
printf("i=%d ", i);
printf("c=%d \n", (a / 2) + 1);
}
}
return 0;
}//不用函数的方法远不止这些，其中更简单的方法不乏其例——要知道“人外有人，山外有山。”，要多多学习。
求100~200之间的素数(用函数版)
约定：是素数的话，返回1；不是素数，返回0。
#include<math.h>
int is_prime(int n)//不管返回1，还是返回0，都是整数，所以函数名前要用int来定义。
{
int j = 0;
for (j = 2; j <= sqrt(n); j++)
{
if (n % j == 0)
{
return 0;//返回到主函数（*）if语句，而不是本for循环。
//不是素数
}
}
return 1;//返回到主函数（*）if语句。
//是素数
}
int main()
{
int i = 0;
for (i = 100; i <= 200; i++)
{
if (is_prime(i) == 1)//（*）返还的值就是is_prime(i)
//if (is_prime(i)):VS中，也能这样写。因为如果自定义函数返回值为0，即为假，则不进入 if；
//如果自定义函数返回值为1，即为真，则进入if打印结果。
{
printf("%d ", i);
}
}
return 0;
}
2. 写一个函数判断一年是不是闰年。
约定：是闰年——返回1；不是闰年——返回0。、
方法一：
int is_leap_year(int n)
{
if (n % 4 == 0 && n % 100 != 0)
{
return 1;
}
if (n % 400 == 0)//这里不能加else。
{
return 1;
}
return 0;//必须加，否则会在每个能被400整除的数字y后，再多出一个不合格的结果——y+1。
}
int main()
{
int y = 0;
for (y = 1000; y <= 2000; y++)//这里可以将y++改成y+=4。
{
if (is_leap_year(y))//if (is_leap_year(y)==1)也行
{
printf("%d ", y);
}
}
return 0;
}
方法二：
int is_leap_year(int n)
{
if (((n % 4 == 0) && (n % 100 != 0)) || (n % 400 == 0))
return 1;
else//这里可加可不加
return 0;
}
int main()
{
int y = 0;
for (y = 1000; y <= 2000; y++)
{
if (is_leap_year(y))
{
printf("%d ", y);
}
}
return 0;
}
或
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;
for (y = 1000; y <= 2000; y++)
{
if (is_leap_year(y))
{
printf("%d ", y);
}
}
return 0;
}
方法三：
int is_leap_year(int n)
{
return (((n % 4 == 0) && (n % 100 != 0)) || (n % 400 == 0));
}
int main()
{
int y = 0;
for (y = 1000; y <= 2000; y++)
{
if (is_leap_year(y))
{
printf("%d ", y);
}
}
return 0;
}
3. 写一个函数，实现一个整形有序数组的二分查找。
约定：找到了返回下标，找不到返回-1。
int binary_search(int arr[], int k, int sz)//返回值为下标或-1——整形int。
//注意：arr一定要加[]。
//sz：数组长度。
{
int left = 0;
int right = sz - 1;
while (left <= right)
{
int mid = (left + right) / 2;
if (arr[mid] < k)
left = mid + 1;
else if (arr[mid] > k)
right = mid - 1;
else
return mid;
}
return -1;//left > right：找不到
}
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
int k = 0;
scanf("%d", &k);
int pos = binary_search(arr, k, 10);//binary_search(arr,k,10):在arr数组(的10个元素)中，二分查 找k。
//因为是通过下标来查找的，所以返回的也是下标，因此用pos:position 表示返回值。
if (-1 == pos)
printf("找不到\n");
else
printf("找到了，下标是%d\n", pos);
return 0;
}
4. 写一个函数，每调用一次这个函数，就会将 num 的值增加1
方法一（使用指针法）：
Add(int* px)//main通过Add把num地址传过来了，这里就要用指针来接收。
{
*px = *px + 1;//这里不能写*px++;，因为这里++是作用于px，而不是*px。
//(*px)++;这样写是没有问题的。
}
int main()
{
int num = 0;
Add(&num);//上节课讲过：要改实参的数值必须将其地址与形参一一对应起来。
printf("%d\n", num);
Add(&num);
printf("%d\n", num);
Add(&num);
printf("%d\n", num);
return 0;
}
方法二（不使用指针法）：使用返回值的方式实现
int Add(int n)
{
return n + 1;
}
int main()
{
int num = 0;
num = Add(num);//因为会返回值，因此这里可以不用&num。
printf("%d\n", num);
num = Add(num);
printf("%d\n", num);
num = Add(num);
printf("%d\n", num);
return 0;
}
函数的嵌套调用和链式访问
函数和函数之间可以根据实际的需求进行组合的，也就是互相调用的。
嵌套调用
#include <stdio.h>
void new_line()
{
printf("hehe\n");
}
void three_line()
{
int i = 0;
for (i = 0; i < 3; i++)
{
new_line();
}
}
int main()
{
three_line();
return 0;
}
函数可以嵌套调用，但是不能嵌套定义。
如：
嵌套定义是错误的，不能写作：
int main()
{
int Add(int x, int y, int z)
{
return x+y+z;
}
int sum = Add(2, 4, 6);
printf("sum = %d", sum);
return 0;
}
嵌套调用是允许的，因此应该写作：
int Add(int x, int y, int z)
{
return x + y + z;
}
int main()
{
int sum = Add(2, 4, 6);
printf("sum = %d", sum);
return 0;
}
链式访问
把一个函数的返回值作为另外一个函数的参数。
#include<string.h>
int main()
{
int len = strlen("asdfg\0");
printf("%d\n", len);
return 0;
}
↓
↓
#include<string.h>
int main()
{
printf("%d\n", strlen("asdfg\0"));//将strlen函数的返回值作为printf的参数串起来了——链式访 问。
return 0;
}
#include <stdio.h>
int main()
{
printf("%d", printf("%d", printf("%d", 43)));
//printf返回值：打印几个字符，返回值就是几。
//printf("%d", 43)：打印结果为43。
return 0;
}//打印结果：4321
#include <stdio.h>
#include <string.h>
int main()
{
char arr[20] = "hello";
int ret = strlen(strcat(arr, "bit"));
//strcat是C语言中的一个字符串函数，用于将两个字符串连接起来，即将第二个字符串追加到第一个字符串的末尾。
printf("%d\n", ret);
return 0;
}
补充：
一、概述
strcat是C语言中的一个字符串函数，用于将两个字符串连接起来，即将第二个字符串追加到第一个字符串的末尾。该函数定义在
string.h头文件中。
二、函数原型
char* strcat(char* dest, const char* src);
三、参数说明
dest：目标字符串，即要将src追加到其末尾的字符串。src：源字符串，即要被追加到dest末尾的字符串。
四、返回值说明
该函数返回一个指向目标字符串dest的指针。
五、使用示例
1. 将两个字符数组连接起来char str1[20] = "Hello"; char str2[10] = "world"; strcat(str1, str2); printf("%s", str1);
输出结果为：Hello world
2.将两个字符串连接起来char* str1 = "Hello"; char* str2 = "world"; char* result = strcat(str1, str2);
printf("%s", result);
输出结果为：Hello world
3. 注意事项
a.目标字符串必须足够大，以便能够容纳源字符串。否则会导致程序崩溃或者出现未知错误。
b.源字符串必须以NULL结尾。
c.目标和源不能重叠。如果目标和源重叠，则结果是未定义的。
六、总结
strcat函数是C语言中非常实用的一个函数，可以方便地将两个字符数组或字符串连接起来。在使用时需要注意目标字符串的大小
和源字符串的结尾，以及目标和源是否重叠等问题。
函数的声明和定义
语法展示：
int Add(int x, int y)//函数的定义——一种特殊的声明
{
return x + y;
}
int main()
{
int a = 0;
int b = 0;
scanf("%d %d", &a, &b);
int sum = Add(a, b);
printf("%d\n", sum);
return 0;
}
↓
↓
int Add(int x, int y);//函数的声明
int main()
{
int a = 0;
int b = 0;
scanf("%d %d", &a, &b);
int sum = Add(a, b);
printf("%d\n", sum);
return 0;
}
int Add(int x, int y)
{
return x + y;
}
在工程中正确写法：
函数声明所在头文件Function Declaration.h部分
函数的声明和定义——工程中正确写法（头文件）
声明
int Add(int x, int y);
主函数所在源文件main.c部分
#include "Function Declaration.h"
int main()
{
int a = 0;
int b = 0;
scanf("%d %d", &a, &b);
int sum = Add(a, b);
printf("%d\n", sum);
return 0;
}
函数定义所在源文件Function Definition.c部分
函数的声明和定义——工程中正确写法（源文件）
定义——函数的实现
int Add(int x, int y)
{
return x + y;
}
打印结果
其中，存放函数定义的源文件和函数声明的头文件统称为加法模块；
存放主函数的源文件称为测试模块。
函数的声明一般放在头文件中，函数的定义一般放在源文件中。
拆成多个文件的好处
①可以模块化开发——分工；
②代码的隐藏
同样，变量也可以声明和定义
int g_val = 2024;
int main()
{
printf("g_val = %d\n", g_val);
return 0;
}
↓
↓
int g_val;//变量的声明
int main()
{
printf("g_val = %d\n", g_val);
return 0;
}
int g_val = 2024;//变量的定义
注意：当main函数后面没有出现定义时，那么前面出现的即为定义。
int g_val;//定义
int main()
{
/*int g_val;*/
printf("g_val = %d\n", g_val);
return 0;
}//打印结果：g_val = 0（全局变量不初始化，默认为0/局部变量不初始化，值随机）
函数递归
递归的两个必要条件
①存在限制条件，当满足这个限制条件的时候，递归便不再继续。
②每次递归调用之后越来越接近这个限制条件。
示例：
最简单的递归（但会发生错误的递归）
int main()
{
printf("PKU ");
main();//递归
return 0;
}//打印结果：3995个"PKU "——程序崩了，所以不是无限循环——栈区空间不够用了——栈溢出：stack overflow
练习1：（画图讲解）
接受一个整型值（无符号），按照顺序打印它的每一位。
例如：
输入：1234，输出 4 3 2 1.
原理：
参考代码：
void Print(unsigned int n)
{
while (n)//当n=0时，0为假，不进入，"递"结束。这里“递”结束时，归也随之结束。
{
printf("%d ", n % 10);
n = n / 10;
}
}
int main()
{
unsigned int num = 0;
scanf("%u", &num);
Print(num);
return 0;
}
输入：1234，输出 1 2 3 4.
原理：
参考代码：
①
void print(unsigned int n)
{
if (n > 9)
{
print(n / 10);//函数内部调用自己
}
printf("%d ", n % 10);//递——递推；
//归——回归
}
int main()
{
unsigned int num = 0;
scanf("%u", &num);
print(num);
return 0;
}
整理得：
void print(unsigned int n)
{
if (n > 9)
{
print(n / 10);
}
printf("%d ", n % 10);
}
int main()
{
unsigned int num = 0;
scanf("%u", &num);
print(num);
return 0;
}
②
void print(int n)
{
if (n > 9)
{
print(n / 10);
}
printf("%d ", n % 10);
}
int main()
{
int num = 1234;
print(num);
return 0;
}
练习2：（画图讲解）
编写函数不允许创建临时变量，求字符串的长度。
非函数版
#include<string.h>
int main()
{
char arr[] = "asd";
int len = strlen(arr);
printf("%d\n", len);
return 0;
}
↓
↓
函数——创建临时变量版
#include<string.h>
int my_strlen(char* str)//字符的地址应该放在字符指针里去
{
int count = 0;//临时变量
while (*str != '\0')//*str=arr[]里的字符
{
count++;
str++;//字符指针+1，向后跳一个字符
}
return count;
}
//同理：整型指针+1，向后跳一个整型，即4个字节
int main()
{
char arr[] = "asd";
//[a s d \0]
//数组名其实是数组首元素地址。
int len = my_strlen(arr);//这里的arr传的就是数组首元素a的地址
printf("%d\n", len);
return 0;
}
↓
↓
函数递归——不创建临时变量版
#include<string.h>
int my_strlen(char* str)//字符的地址应该放在字符指针里去
{
if (*str != '\0')
return 1 + my_strlen(str + 1);
else
return 0;
}
int main()
{
char arr[] = "asd";
int len = my_strlen(arr);
printf("%d\n", len);
return 0;
}
参考代码：
#include <stdio.h>
int Strlen(const char* str)
{
if (*str == '\0')
return 0;
else
return 1 + Strlen(str + 1);
}
int main()
{
char* p = "abcdef";
int len = Strlen(p);
printf("%d\n", len);
return 0;
}
递归与迭代
循环就是一种迭代
练习1：
求n的阶乘(不考虑溢出)。
不使用递归版：
int Fac(int n)
{
int i = 0;
int ret = 1;
for (i = 1; i <= n; i++)
{
ret *= 1;
}
return ret;
}
int main()
{
int n = 0;
scanf("%d", &n);
int ret = Fac(n);
printf("%d\n", ret);
return 0;
}
使用递归版：
函数栈帧：每一次函数调用都会为本次函数调用分配内存空间(是在内存的栈区)，其中我们将为本次函数调用分配的内存空间就称为这次函数调用的栈帧空间。
函数栈帧的创建和销毁：
写一个函数求n的阶乘
int Fac(int x)
{
if (x <= 1)//0!=1
return 1;
else
return x * Fac(x - 1);
}
int main()
{
int n = 0;
scanf("%d", &n);
int ret = Fac(n);//factorial阶乘
printf("%d\n", ret);
return 0;
}
练习2：
求第n个斐波那契数(不考虑溢出)。
斐波那契数：斐波那契数列（Fibonacci sequence），又称黄金分割数列 [1]。
因数学家莱昂纳多·斐波那契（Leonardo Fibonacci）以兔子繁殖为例子而引入，故又称“兔子数列”。
其数值为：1、1、2、3、5、8、13、21、34……
1
1=0+1
2=1+1
3=1+2
5=2+3
8=3+5
13=5+8
21=8+13
34=13+21
……
在数学上，这一数列以如下递推的方法定z义：F(0)=0，F(1)=1, F(n)=F(n - 1)+F(n - 2)（n ≥ 2，n ∈ N*）。
写一个函数求第n个斐波那契数：
递归版：
int count = 0;
int Fib(int n)
{
if (n == 3)//统计第三个斐波那契数被计算的次数
count++;
if (n <= 2)
return 1;
else
return Fib(n - 1) + Fib(n - 2);
}
int main()
{
int n = 0;
scanf("%d", &n);
int ret = Fib(n);
printf("%d\n", ret);
printf("\ncount=%d\n", count);//以n=40为例，最后结果：ret=102334155
//count=39088169
return 0;
}
第30项：832040
第40项：102334155
第50项：12586269025（当n的值稍微大一些的时候，计算就会十分缓慢）
循环版：
int Fib(int n)
{
int a = 1;
int b = 1;
int c = 1;
while (n > 2)
{
c = a + b;
a = b;
b = c;
n--;
}
return c;
}
int main()
{
int n = 0;
scanf("%d", &n);
int ret = Fib(n);
printf("%d\n", ret);
return 0;
}
总结：由上面两种方法可知，有时候递归并不是一种高效的方法，递归有着内容简短的优点与计算过程过于缓慢的缺点，而非递归有着快捷输出结果的优点和书写代码过于冗长的缺陷。因此在日常写代码过程中，要灵活使用递归法与非递归法。
其中，我们在使用 fib 这个函数的时候能发现：
如果我们要计算第50个斐波那契数字的时候特别耗费时间，
以及使用 factorial 函数求10000的阶乘（不考虑结果的正确性），程序会崩溃等问题。
要想解决上述的问题，我们可以：
485
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
