函数
1.函数基本用法
1.1 定义和三要素
函数是一个可以完成特定功能的代码模块，其程序代码是独立的，通常有返回值，也可以没有。
函数的三要素：
功能：函数要实现的功能。
参数：在函数声明和调用时定义的遍历，它用于传递数据给函数。
【1】形参：就是在函数声明的时候定义的变量，用于传递信息给函数。此时它没有具体的数值。
【2】实参：就是在调用函数时传递给函数的实际数值。
返回值：函数调用后留下的右值。
1.2 函数的声明和定义
1.2.1 函数声明
存储类型 数据类型 函数名(数据类型 形参1,数据类型 形参2,…);
1.2.2 函数定义格式
存储类型 数据类型 函数名(数据类型 形参1,数据类型 形参2,…)
{
函数体；
}
函数名：是一个标识符，要符合标识符命名规则。
数据类型：是整个函数的返回值类型，如果没有返回值为void。
形式参数说明：是逗号分隔的多个变量的形式说明，简称形参。
形参就是函数声明或定义时括号中的变量，因为形式参数只有在函数调用时也被传递真实的数值。
大括号对{语句序列}，称为函数体，函数体由大于等于零个语句组成的。
函数的数据总结：
（1）没有参数：括号中的参数列表可以省略，也可以写void。
（2）没有返回值：数据类型为void，函数内没有return语句。
（3）有返回值：要跟根据返回值的数据类型定义函数的数据类型，可以用return接收返回值。
（4）定义子函数时可以直接在主函数上面，如果想在主函数下面定义需要在主函数上面事先声明。
1.3 函数调用
（1）没有返回值：直接调用
函数名(实参);
（2）有返回值：要在函数内定义一个与返回值类型相同的变量用return接收。如果不需要接收返回值，就直接调用函数。如果想拿到返回值来用，可以在调用函数前设一个同类型变量去接收。
实参：在调用有参数函数时，函数名后面括号中的参数称为“实参”，此时是我们传递给函数的真实数值。实参可以是：常量、变量、表达式、函数等。
代码示例：
#include<stdio.h>
void fun() //实现打印功能
{
printf("in fun\n");
}
void add(int a,int b) //实现两数相加函数，无返回值。
{
int c=a+b;
printf("a+b=%d\n",c);
}
int add2(int a,int b) //实现两数相加函数，有返回值。
{
return a+b;
}
int dec(int a,int b); //实现两数相减函数，子函数在主函数下面定义需要在上面事先声明。
int main(int argc, char const *argv[])
{
int n1=2,n2=3;
int rel=0,diff=0;
fun();
add(2,3);
add(n1,n2);
rel=add2(n1,n2);
printf("in main add:%d\n",rel);
diff=dec(6,5);
printf("in main dec :%d\n",diff);
return 0;
}
int dec(int a, int b)
{
return a-b;
}
练习：定义求x的n次方值的函数（ x是实数, n为正整数）。
#include<stdio.h>
float mypow(float x, int n)
{
float rel=1;
if(n<0)
{
printf("error\n");
return -1;
}
for(int i=0;i<n;i++)
rel *=x;
return rel;
}
int main(int argc, char const *argv[])
{
float result=mypow(1.5,2);
printf("result= %f\n",result);
return 0;
}
练习：编写一个函数，函数的2个参数，第一个是一个字符，第二个是一个char *,
返回字符串中该字符的个数。
#include<stdio.h>
int str_fang(char c,char *p)
{
int n=0;
while (*p)
{
if(*p == c)
n++;
p++;
}
return n;
}
int main(int argc, char const *argv[])
{
char s[100]="helloooooo";
int val=str_fang('o',s);
printf("%d\n",val);
return 0;
}
练习：编程实现strlen函数的功能，strlen计算字符串实际长度，不包含’\0’
#include<stdio.h>
int mystrlen(char *s)
{
int n=0;
while(*s != '\0')
{
n++;
s++;
}
return n;
}
int main(int argc, char const *argv[])
{
int len=mystrlen("hello");
printf("%d\n",len);
return 0;
}
1.4 函数传参
【1】值传递
单向传递，将实参传递给形参使用，改变形参实参不会受影响。
void fun(int a, int b)
{
a++;
b++;
printf("in fun: a=%d b=%d\n", a, b);
}
int main(int argc, char const *argv[])
{
int n1 = 10, n2 = 20;
fun(n1, n2);
printf("in main: a=%d b=%d\n", n1, n2);
return 0;
}
【2】地址传递
双向传递，在函数中修改形参，实参也会随之变化。
void fun2(int *a, int *b)
{
*a = 40;
*b = 90;
printf("in fun2: a=%d b=%d\n", *a, *b);
}
int main(int argc, char const *argv[])
{
int n1 = 10, n2 = 20;
fun2(&n1, &n2);
printf("in main: a=%d b=%d\n", n1, n2);
return 0;
}
【3】数组传递
和地址传递一样，参数中存在数组的定义，也认为是指针。
void fun3(int *arrp, int n)
{
int *p = arrp;
printf("in fun3 array:\n");
*(p + 1) = 100;
for (int i = 0; i < n; i++)
{
printf("%d %d\n", p[i], *(p + i));
}
printf("in fun3: *(p+1)= %d\n", *(p + 1));
}
int main(int argc, char const *argv[])
{
int arr[5] = {1, 2, 3, 4, 5};
fun3(arr, 5);
printf("in main array:\n");
for (int i = 0; i < 5; i++)
{
printf("%d %d\n", arr[i], *(arr + i));
}
printf("in main: *(arr+1)= %d\n", *(arr + 1));
return 0;
}
1.5 函数和栈区
栈用来存储函数内部（包括main()函数）的变量。它是一个FILO（First In Last Out）,先进后出的结构。当一个函数运行结束后，这个函数所有在栈中的变量都会被删除，并且它们所占的空间将会被释放。这就产生了函数内的局部变量。栈区由CPU自动管理，不需要手动申请和释放。
2.开辟堆空间
2.1 堆的概念
申请的空间种分为五个区域栈区（堆栈区），堆区，全局区，字符常量区，代码区，我们之前讲的这些定义局部变量、数组都是在内存的栈区存储。
栈区和堆区的区别
栈区：是由CPU自动申请和释放的，不需要我们手动申请。
堆区：需要我们自己随时申请，由我们自己去释放的。随用随取，用完释放。
3.malloc函数
3.1 定义
#include <stdlib.h>
void *malloc(size_t size);
功能：在堆区开辟大小为size的空间
参数：size:开辟空间的大小，单位为字节。
返回值：
成功：返回开辟空间的首地址
失败：空指针NULL
malloc()要和free()搭配使用
3.2 用法
malloc内的参数是需要动态分配的字节数，而不是可以存储的元素个数！
代码格式：
type* var_name = (type *)malloc(sizeof(type)*n);
3.3 free()函数定义
#include <stdlib.h>
void free(void *ptr);
功能：释放之前用malloc、calloc和realloc所分配的内存空间。
参数：ptr:堆空间的首地址。
返回值：无
可以释放完堆空以后，把指针赋值为空指针：
free§;
p=NULL;
malloc和free搭配用法：
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char const *argv[])
{
int *p=(int *)malloc(sizeof(int)*100);
if(p==NULL)
printf("lost!\n");
else
printf("success\n");
free(p);
p=NULL;
return 0;
}
注意：
1.手动开辟堆区空间，要注意内存泄漏
当指针指向开辟堆区空间后，又对指针重新赋值，则没有指针指向开辟的堆区空间，就会造成内存泄漏。
2.使用完堆区空间后及时释放空间
例如：
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char const *argv[])
{
char *p=(char *)malloc(sizeof(char)*32);
// p=“hello”; //错误，指针指向别的地方，没有对堆空间进行操作
scanf(“%s”,p);
printf(“%s\n”,p);
free§;
p=NULL;
return 0;
}
3.4 函数中开辟堆空间
思考：如下代码输出结果
#include <stdio.h>
#include <stdlib.h>
void fun(char *p)
{
p= (char *)malloc(32);
scanf(“%s”,p);
}
int main(int argc, char const *argv[])
{
char *m=NULL;
fun(m);
printf(“%s\n”,m);
//free(m);
//m=NULL;
return 0;
}
Segmentation fault (core dumped)出现段错误。
是因为m没有指向椎空间，还是最初定义的空指针，所以没有内容输出，报错。如下图
因为根据图可以明显看到：
把m里存储的地址传递给p,这时m和p都指向这个地址，当p申请到一个椎空间，这时p的指向椎空间的地址，m因为没有修改它的指向，所以m还是指向最初的地址。
解决方法1：通过返回值
#include <stdio.h>
#include <stdlib.h>
char *fun()
{
char *p= (char *)malloc(32);
scanf(“%s”,p);
return p;
}
int main(int argc, char const *argv[])
{
char *m=fun();
char *n=fun();
printf(“%s\n”,m);
printf(“%s\n”,n);
free(m);
m=NULL;
free(n);
n=NULL;
return 0;
}
解决方法2：通过传参（二级指针）
#include <stdio.h>
#include <stdlib.h>
void fun(char **p)
{
*p = (char *)malloc(32);
scanf(“%s”, *p);
}
int main(int argc, char const *argv[])
{
char *m=NULL;
fun(&m);
printf(“%s\n”,m);
free(m);
m=NULL;
return 0;
}
*p变成一级指针，和之前出现的问题一样，但是因为p是二级指针，里面存的是m的地址，所以也相当于m同时接受malloc返回值，此时m的指向椎空间，*p也指向椎空间
如图：
4.string函数族
4.1 strcpy
#include <string.h>
char *strcpy(char *dest, const char *src);
功能：实现字符串的复制，包括\0
参数：dest:目标字符串首地址
src:源字符串首地址
返回值：目标字符串首地址
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char const *argv[])
{
char s1[32]="hello";
char s2[32]="world";
strcpy(s1,s2);
printf("%s\n",s1);
return 0;
}
4.2 strlen
#include <string.h>
size_t strlen(const char *s);
功能：计算字符串长度
参数：s:字符串的首地址
返回值：返回字符串实际长度，不包括‘\0’在内。
4.3 strcat
#include <string.h>
char *strcat(char *dest, const char *src);
功能：用于字符串拼接
参数：dest:目标字符串首地址
src:源字符串首地址
返回值：目标字符串首地址
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char *strncat(char *dest, const char *src, size_t n)；
int main(int argc, char const *argv[])
{
char s1[32]="hello ";
char s2[32]="world";
strcat(s1,s2);
printf("%s\n",s1);
return 0;
}
4.4 strcmp
#include <string.h>
int strcmp(const char *s1, const char *s2);
功能：用于比较字符串
参数：s1和s2是比较的字符串的首地址
返回值：
1：s1>s2
0: s1==s2
-1: s1<s2
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char const *argv[])
{
int a=strcmp("hello","world");
if(a==0)
printf("相等！\n");
else
printf("不相等！\n");
return 0;
}
int strncmp(const char *s1, const char *s2, size_t n);
比较两个字符串前n个字符的大小
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, char const *argv[])
{
int a=strncmp("hello world","hello",5);
if(a==0)
printf("相等！\n");
else
printf("不相等！\n");
return 0;
}
5.递归函数
5.1 概念
所谓递归函数是指一个函数体中直接或者间接调用了该函数本身，这里的直接调用是指一个函数的函数体中含有调用自身的语句，间接调用是指一个函数在函数体里有调用了其它函数，而其它函数又反过来调用了该函数的情况。
5.2 执行过程
递归函数调用的执行过程分为两个阶段：
（1）递归阶段：从原问题出发，按递归公式递推从未知到已知，最终达到递归终止条件。就是从最里层开始算，然后一层层算，直到终止。
（2）回归阶段：按递归终止条件求出结果，逆向逐步带入递归公式，回到原问题求解。
例子：求5的阶乘5！
递归公式：
fac(n)= 1 n=1
n*fac(n-1) n>1
#include<stdio.h>
int fac(int n)
{
if(n==1)
return 1;
else
return n*fac(n-1);
}
int main(int argc, char const *argv[])
{
int n=5,ret=fac(n);
printf("ret=%d\n",ret);
return 0;
}
练习：斐波那契数列：指的是这样一个数列：1、1、2、3、5、8、13、21、34、……在数学上，斐波纳契数列以如下被以递归的方法定义：F(1)=1，F(2)=1, F(n)=F(n-1)+F(n-2)（n>=2，n∈N*） 求第五个数。
F(n) : 1 n<=2
F(n-1)+F(n-2) n>2
include <stdio.h>
int fun(int n)
{
if (n <= 2)
return 1;
else
return fun(n - 1) + fun(n - 2);
}
int main()
{
int rel = fun(5);
printf("rel=%d\n", rel);
return 0;
}
练习：封装函数实现strcat功能
#include <stdio.h>
#include <string.h>
char *myStrcat(char *dest, char *src)
{
int len = strlen(dest);
char *p = dest + len;
while (*src != '\0')
{
*p = *src;
p++;
src++;
}
*p = '\0';
}
int main()
{
char s1[32] = "hello ";
char s2[32] = "world~";
myStrcat(s1, s2);
printf("%s\n", s1);
}
1015
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
