目录
一.函数是什么
1.函数简介
在计算机科学中，子程序（英语：Subroutine, procedure, function, routine, method,subprogram, callable unit），是一个大型程序中的某部分代码， 由一个或多个语句块组成。它负责完成某项特定任务，而且相较于其他代码，具备相对的独立性。
一般会有输入参数并有返回值，提供对过程的封装和细节的隐藏。这些代码通常被集成为软件库。
2.函数分类
1.库函数
2.自定义函数
二.库函数
1.为什么要有库函数
1. 我们知道在我们学习C语言编程的时候，总是在一个代码编写完成之后迫不及待的想知道结果，想把这个结果打印到我们的屏幕上看看。这个时候我们会频繁的使用一个功能：将信息按照一定的格式打印到屏幕上（printf）。
2. 在编程的过程中我们会频繁的做一些字符串的拷贝工作（strcpy）。
3. 在编程是我们也计算，总是会计算n的k次方这样的运算（pow）。
像上面我们描述的基础功能，它们不是业务性的代码。我们在开发的过程中每个程序员都可能用的到，为了支持可移植性和提高程序的效率，所以C语言的基础库中提供了一系列类似的库函数，方便程序员进行软件开发。
2.怎么学习库函数
我们要学会从网站上学习库函数，或者从msdn上来学习
3.大致分类
IO函数 input output getchar putchar
字符串操作函数 strlen strcmp
字符操作函数 大小写转换， 字符分类
内存操作函数 memcpy memmave memset
时间/日期函数 time
数学函数 pow sqrt
其他库函数
3.具体的学习
我们打开网站，然后找到我们的库函数，对应的头文件。
我们慢慢学习，也可以刚开始的时候翻译，后来慢慢学习，然后读英语。一步一步来。
4.简单介绍几个
(1)strcpy
char * strcpy ( char * destination, const char * source );
返回类型 函数名 两个参数
在文献看了我们知道，是字符串拷贝，函数原型就是：原指针指向的字符串拷贝到新的指针的地址
#include <stdio.h>
#include <string.h>
int main()
{
//字符串拷贝的时候
//hello bit
char arr1[20] = { 0 };
char arr2[] = "hello bit";
//把arr2中的字符串拷贝到arr1中
strcpy(arr1, arr2);
printf("%s\n", arr1);
return 0;
}就是把arr2里面的内容传到arr1里面
这里用指针打印也是一样的
#include <stdio.h>
#include <string.h>
int main()
{
char arr1[20] = { 0 };
char arr2[] = "hello bit";
char * ret = strcpy(arr1, arr2);
printf("%s\n", ret);
return 0;
}效果都是一样的，放到ret的地址里面，然后打印ret，char定义的时候加上*，加上ret的指针
(2)memset
void * memset ( void * ptr, int value, size_t num );
返回类型 函数名 三个参数
int main()
{
char arr[20] = "hello bit";
printf("%s\n", arr);
memset(arr, 'x', 5);
printf("%s\n", arr);
return 0;
}这个还是就是替换字符串里面的字符，换成x，后面数是几，就换几个
第一个参数是要换的名字，第二个参数是要换成什么，第三个加上换几个字符
三.自定义函数
如果库函数能干所有的事情，那还要程序员干什么？
所有更加重要的是自定义函数。
自定义函数和库函数一样，有函数名，返回值类型和函数参数。
但是不一样的是这些都是我们自己来设计。这给程序员一个很大的发挥空间。
1.函数的组成
ret_type fun_name(para1, * )
{
statement; //语句项
}
ret_type 返回类型
fun_name 函数名
para1 函数参数2.我们举例子来看
写一个函数可以找出两个整数中的最大值
可以用if按部就班的去写，谁大返回谁
这里的不会改变x和y的值，所以在函数中也不会变，a和b的值也没有改变，不需要指针来找他们的地址，因为他们谁就是谁的
int get_max(int x, int y)
{
if (x > y)
return x;
else
return y;
}
//也可以直接这样去写
int get_max(int x, int y)
{
return (x > y ? x : y);
}
int main()
{
int a = 0;
int b = 0;
//输入
scanf("%d %d", &a, &b);
int m = get_max(a, b);//推演函数的使用场景
int m = get_max(get_max(3, 7), 5);//推演函数的使用场景，这里就是函数里面放确定的值，可以得到的参数，然后传到函数里面去
//输出
printf("%d\n", m);
return 0;
}这里有几个地方，我们后面讲参数，会再讲到的
然后我们下面讲参数，记得上面这个代码例子，下面会用到！！！
四.参数
1.实际参数
真实传给函数的参数，叫实参。
实参可以是：常量、变量、表达式、函数等。
无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。
//int m = get_max(get_max(3, 7), 5);这个例子就是里面放的可以确定的值
2.形式参数
形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内存单元），所以叫形式参数。形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有效。
我们写函数，如果我们没有调用这个函数，我们是不占用内存的，如果我们去调用他了，才会占内存。
这些我们需要例子才能理解清楚
3.深度理解
（1）小 void
void test(void)
//第一个void意思是函数调用完，不需要返回值，不需要你来返回
//第二个void意思是不能传参数，这里面不传参数
{
printf("hehe\n");
}
int main()
{
test();
return 0;
}（2）写一个函数可以交换两个整形变量的内容。
一般的
int main()
{
int a = 0;
int b = 0;
//输入
scanf("%d %d", &a, &b);
//交换
printf("交换前：a=%d b=%d\n", a, b);
int tmp = 0;//第三个变量
tmp = a;
a = b;
b = tmp;
//输出
printf("交换后：a=%d b=%d\n", a, b);
return 0;
}我们用函数来写
void Swap(int x, int y)
{
int tmp = x;
x = y;
y = tmp;
}
int main()
{
int a = 0;
int b = 0;
//输入
scanf("%d %d", &a, &b);//3 5
//交换
printf("交换前：a=%d b=%d\n", a, b);
Swap(a, b);
//输出
printf("交换后：a=%d b=%d\n", a, b);
return 0;
}
我们发现没有交换，这是什么情况呢
（4）深度理解实参与形参之间的关系
接着上面的，当我们调试起来，我们来看他们各自的地址
这是我们a和b的地址
但是函数里面x和y的地址，跟ab是不一样的
当我们换完了后，我们不影响ab的值，因为xy跟ab不是一个地址，我们换的只是xy
xy有他俩独立的空间，ab只穿数过去，地址不一样，传不回来了
实际参数传给形式参数，形式参数有自己的空间，自己改变自己的，不返回给实际参数，实际参数该咋咋
官方回答：当函数调用的时候，实际参数传给形式参数，这时候形参是实参的临时拷贝，对形参的修改不影响实参。
所以我们加上指针，来找他们的地址，这样可以给xy跟ab建立上联系
我们先复习一下指针
int main()
{
int a = 10;
//a = 20;，换一种方式来改a的值
int* pa = &a; //pa是地址，就是指针，&a就是取a的地址
*pa = 20; //当我们int *，后，这就是解引用，就是找到a的值，叫指针变量
//所以这个*pa就是找到a的地址里面的a的值
printf("a=%d\n", a);
return 0;
}现在我们来看我们修改过的代码
void Swap2(int* pa, int* pb)
{
int tmp = *pa;//tmp = a;
*pa = *pb; //a=b
*pb = tmp; //b=tmp
}
//pa和pb就是他们的地址，我们加上*就是解引用，去找到地址上放的值
//也就是主函数里面ab放的值，因为地址是一样的，就给拿过来了，也会传回去
//pa放的就是地址 0x0012ff40
//pa放的就是地址 0x0012ff48
//然后加上*，就是找到他们俩的地址里面的值，把值放到*pa，*pb
int main()
{
int a = 0;
int b = 0;
//输入
scanf("%d %d", &a, &b);//3 5
//交换
printf("交换前：a=%d b=%d\n", a, b);
Swap2(&a, &b);
//输出
printf("交换后：a=%d b=%d\n", a, b);
return 0;
}pa和pb就是他们的地址，我们加上*就是解引用，去找到地址上放的值
也就是主函数里面ab放的值，因为地址是一样的，就给拿过来了，也会传回去
pa放的就是地址 0x0012ff40
pb放的就是地址 0x0012ff48
然后加上*，就是找到他们俩的地址里面的值，把值放到*pa，*pb
但是这个需要地址
但是上面那个题（就是我上面说的那个例子）为啥不需要传地址，因为第一个是不会改变xy的值，只是把ab给xy，我不修改ab和xy
但是在下面这个，会改变xy的值，也会修改ab的值，就把地址给过去，就意思就是用地址远程操控主函数里面的这俩值
五.函数的调用
1.传值调用
函数的形参和实参分别占有不同内存块，对形参的修改不会影响实参。
就像第一个例子，就是只把数传进去，进行计算啥的，不修改他们的值
2.传址调用
传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。
这种传参方式可以让函数和函数外边的变量建立起真正的联系，也就是函数内部可以直接操作函数外部的变量。
这个就是第二个例子，就是像需要改变里面的值，我们就用指针来进行远程的联系，来改变，就是传地址
五.几个小练习
1.用函数求100~200之间的素数
#include<math.h>
#include<stdio.h>
int is_prime(int n)
{
int j = 0;
for (j = 2; j <= sqrt(n); j++)
{
if (n % j == 0) //j就是要除的数，然后n一个一个除
{
return 0;//不是素数
}
}
return 1;//是素数
}
int main()
{
int i = 0;
for (i = 100; i <= 200; i++)
{
//判断i是否为素数
if (is_prime(i)) //i就是100-200里面的数，，然后放到函数里面去判断，返回的时候就是0和1，1就是真，0是假不执行
{
printf("%d ", i);
}
}
return 0;
}是素数返回1，不是素数返回0
i就是100-200里面的数，，然后放到函数里面去判断，返回的时候就是0和1，1就是真，0是假不执行
int is_prime(int n)
{
int j = 0;
for (j = 2; j <= sqrt(n); j++)
{
if (n % j == 0) //j就是要除的数，然后n一个一个除
{
return 0;//不是素数
}
}
return 1;//是素数
}我们单独看函数里面，循环用让n一个一个除以开方的数，为什么除以开方，我们以前介绍过了，
m=a*b，a和b至少有一个数字<=开平方m的
你在开平方前找不到可以除以的，在开平方后也找不到
所以试除从2到开平方这个数就可以了，需要头文件包含这个sqrt，这是库函数
再去判断，然后直接返回就好啦
2.写一个函数判断一年是不是闰年。
1. 能被4整除，并且不能被100整除是闰年
2. 能被400整除是闰年
可以这样写函数
int is_leap_year(int y)
{
if (y % 4 == 0 && y % 100 != 0)
{
return 1;
}
if (y % 400 == 0) //这个不能写else，因为都成立。
{
return 1;
}
return 0;
}
第二种
int is_leap_year(int y) // 这里要写个int y ，把y的值传进来。
{
if (((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0))
return 1;
else
return 0;
}
第三种
int is_leap_year(int y)
{
return (((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0));
}
主函数
int main()
{
int y = 0;
for (y = 1000; y <= 2000; y+=4)
{
//判断y是否为闰年
//是闰年返回1
//不是闰年返回0
if (is_leap_year(y)) //y就是要判断的数，放在函数里面进入到函数去判断，然后返回1或者0
{ //命名好习惯，要不首字母大写，要不加上_ ，用英语啊，别太low了
printf("%d ", y);
}
}
return 0;
}
这里的判断都是返回1或者0，来直接到if里面
切记函数里面也要有定义的变量 ，int is_leap_year(int y)，int y 不能忘，要接收主函数传来的值
3.用函数实现二分查找
函数部分
#include <stdio.h>
binary_search(int arr[], int k, int sz)
{ //sz就是接受传来数组里面元素的个数，减一就是右下标数
int left = 0; //下面传来什么，函数就用什么变量去接收
int right = sz - 1;//就是最后一个下标数-1，就是最后一个元素的下标
int mid = (left + right) / 2;
while (left <= right)
{
if (arr[mid] < k)
{
left = mid + 1;
}
else if (arr[mid] > k)
{
right = mid - 1;
}
else
{
return mid;
}
}
return -1;
}
对于上面函数里面用来接收主函数传过来的值，我们也要定义变量去接受
这里就是我们定义一个sz来接收
int left = 0; sz就是接受传来数组里面元素的个数，减一就是右下标数
int right = sz - 1; 就是最后一个下标数-1，就是最后一个元素的下标
主函数部分
int main()
{
//计算数组元素个数，然后传上去，
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
int k = 7;
int sz = sizeof(arr) / sizeof(arr[0]);//0是下标数，就是第一个元素，算出来sz就是元素的个数，就不用10了，直接用sz传
int pos = binary_search(arr, k, sz); // arr里面找k，10是数组里的元素的个数，还要用下标来找
//pos下标数，设计的时候找到了返回下标，找不到返回-1，拿pos接受
if (-1 == pos)
{
printf("找不到\n");
}
else
{
printf("找到了，下标是：%d\n");
}
return 0;
}跟我们前面不用函数的思路是差不多的，我们加入函数，需要注意几个地方
我们看主函数中，当我们知道数组里面元素的个数的时候，我们直接输入，当我们不知道的时候
，我们怎么计算数组中元素的个数，这里我们来计算一下。
printf("%d\n", sizeof(arr));//这里是计算整个数组的大小，单位是字节
printf("%d\n", sizeof(arr[0]));//这里是计算第一个元素的大小，单位是字节我们来看这俩个打印，一个40，一个4，让他们相除就是我们元素的个数，我们就这样来计算个数
int sz = sizeof(arr) / sizeof(arr[0]);
//0是下标数，就是第一个元素，算出来sz就是元素的个数，就不用10了，直接用sz传4.写一个函数，让我们每一次调用，num+1
我们先来分析，我们要改变函数里的值，这里我们就需要用地址来写了
#include <stdio.h>
void Add(int* p)//下面传来的是&num，直接就是地址，我们就用指针来接收
{
*p = *p + 1;
//不能用*p++，作用于p了，但是不是作用于*p
//想这样的话带括号，(*p)++;
}
int main()
{
int num = 0;
Add(&num);
printf("%d", num); //1
Add(&num);
printf("%d", num); //2
Add(&num);
printf("%d", num); //3
return 0;
}指针我们说过好多次了，我们写的p是地址，加上*后*p就是指向我们num地址里的东西
我们主函数里函数里放的是&num，所以我们上面函数写的时候，也用指针来接受
*p = *p + 1;
//不能用*p++，作用于p了，但是不是作用于*p
//想这样的话带括号，(*p)++;
当我们不用指针的时候，也可以用返回的值，直接让num加一
int Add(int n)
{
return n + 1;
}
int main()
{
int num = 0;
num = Add(num);
printf("%d\n", num);
num = Add(num);
printf("%d\n", num);
num = Add(num);
printf("%d\n", num);
return 0;
}这里再说一下好习惯
我们函数自定义的时候，我们命名用的是英语，要不首字母大写，要不加上_ 这样的格式去写
结束语
这是函数的第一部分，下一篇会有第二部分！
366
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
