C语言的函数笔记（未完成）

函数的分类

• 库函数
• • 库函数的常用种类
  • 库函数的举例
  • • strcpy（复制数组）
    • memset（内存设置）
• 自定义函数
• • 自定义函数举例
  • • 求一个最大值
    • (重点）函数只能返回一个值
  • 函数的参数（重点）
  • • 实际参数（实参）
    • 形式参数（形参）
  • 函数的调用
  • • 传值调用
    • 传址调用
  • 函数的嵌套调用和链式访问
  • • 嵌套调用
    • 链式访问
  • 函数的声明和定义（重点）
  • • 函数声明
    • 函数的定义
  • 函数的递归（重点）
  • • 递归是什么
    • 递归的条件
    • 递归的举例

库函数 库函数的常用种类

简单的总结，C语言常用的库函数都有：
IO函数
字符串操作函数
字符操作函数
内存操作函数
时间/日期函数
数学函数
其他库函数
学习库函数的网站：链接: link

库函数的举例 strcpy（复制数组）

strcpy库函数的作用复制数组内容
char * strcpy ( char * destination, const char * source );
						要复制到的地方             要复制的内容

#include 
使用库函数，必须包含 #include 对应的头文件。example:strcpy的库函数就是string.h
#include 

int main ()
{
  char str1[]="Sample string";
  char str2[40];
  char str3[40];
  strcpy (str2,str1);
  strcpy (str3,"copy successful");
  printf ("str1: %snstr2: %snstr3: %sn",str1,str2,str3);
  return 0;
}
输出结果如下
str1: Sample string
str2: Sample string
str3: copy successful

memset（内存设置）

void * memset ( void * ptr, int value, size_t num );
			需要设置的地方    设置的内容    设置的个数（从左到右数有几个就更改几个）

#include 
#include 

int main ()
{
  char str[] = "almost every programmer should know memset!";
  memset (str,'-',6);
  puts (str);
  return 0;
}
输出结果如下
------ every programmer should know memset!

自定义函数

ret_type fun_name(para1, * )
{
 statement;//语句项
}//函数体
ret_type 返回类型
fun_name 函数名
para1    函数参数

自定义函数举例 求一个最大值

#include 
//get_max函数的设计
int get_max(int x, int y) {
 return (x>y)?(x):(y);
}
int main()
{
 int num1 = 10;
 int num2 = 20;
 int max = get_max(num1, num2);
 printf("max = %dn", max);
 return 0; 
 }

(重点）函数只能返回一个值

#include 
//实现成函数，但是不能完成任务
void Swap1(int x, int y) {//形式参数//传值调用
 int tmp = 0;
 tmp = x;
 x = y;
 y = tmp; }
//正确的版本采用指针的方法将地址传过来
void Swap2(int *px, int *py) {//形式参数//传址调用
 int tmp = 0;
 tmp = *px;
 *px = *py;
 *py = tmp; }
int main()
{
 int num1 = 1;
 int num2 = 2;
 Swap1(num1, num2);//实际参数
 printf("Swap1::num1 = %d num2 = %dn", num1, num2);
 Swap2(&num1, &num2);//实际参数
 printf("Swap2::num1 = %d num2 = %dn", num1, num2);
 return 0; 
 }

函数的参数（重点） 实际参数（实参）

真实传给函数的参数，叫实参。 实参可以是：常量、变量、表达式、函数等。 无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形 参。

形式参数（形参）

重点：形参实例化之后其实相当于实参的一份临时拷贝。(实参和形参使用的不是同一空间)

形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内 存单元），所以叫形式参数。形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有 效。

举例如上（函数只能返回一个值）：
上面 Swap1 和 Swap2 函数中的参数 x，y，px，py 都是形式参数。
在main函数中传给 Swap1 的 num1 ，num2 和传给 Swap2 函数的 &num1，&num2 是实际参数。

函数的调用 传值调用

函数的形参和实参分别占有不同内存块，对形参的修改不会影响实参。

传址调用

传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。 这种传参方式可以让函数和函数外边的变量建立起真正的联系，也就是函数内部可以直接操 作函数外部的变量。

举例：

#include 
void Add(int*p)//修改的是地址里面的值
{
(*p)++;
}
int main()
{
 int num = 0;
 //调用函数，使得num每次增加1
 Add(&num);//将变量num的地址值传过去
 printf("%dn",num);
 return 0; }

函数的嵌套调用和链式访问 嵌套调用

函数和函数之间可以根据实际的需求进行组合的，也就是互相调用的。
函数可以嵌套调用，但是不能嵌套定义。

#include 
void new_line()
{
 printf("hehen");
}
void three_line()
{
    int i = 0;
 for(i=0; i<3; i++)
   {
        new_line();//嵌套调用
   }
}
int main()
{
 three_line();//嵌套调用
 return 0; 
 }

链式访问

把一个函数的返回值作为另外一个函数的参数。

#include 
#include 
int main()
{
    char arr[20] = "hello";
 int ret = strlen(strcat(arr,"bit"));
//strcat函数表示追加字符串arr表示目标数组"bit"表示追加到结尾的内容
//strlen计算字符串的长度，直到空结束字符，但不包括空结束字符。
 printf("%dn", ret);
 return 0; }
#include 
int main()
{
    printf("%d", printf("%d", printf("%d", 43)));
    //打印为4321
    //printf返回的是打印的个数
    return 0; }

函数的声明和定义（重点） 函数声明

1. 告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。但是具体是不是存在，函数声明决定不了。
2. 函数的声明一般出现在函数的使用之前。要满足先声明后使用。
3. 函数的声明一般要放在头文件中的（重点）
   链接: link

函数的定义

函数的定义是指函数的具体实现，交待函数的功能实现。

int main()
{
int a = 10;
int b = 20;
//函数声明
//当函数写在main函数之后时需要提前声明函数*不然会报错
//当函数的定义写在main函数之前则不需要声明
int Add(int,int)
int c = Add(a,b);
printf("%d",c);
return 0;
}
//函数的定义
int Add(int x,int y)
{
return x+y;
}

函数的递归（重点） 递归是什么

程序调用自身的编程技巧称为递归（ recursion）。 递归做为一种算法在程序设计语言中广泛应用。
一个过程或函数在其定义或说明中有直接或间接 调用自身的
一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解， 递归策略
只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。 递归的主要思考方式在于：把大事化小

递归的条件

存在限制条件，当满足这个限制条件的时候，递归便不再继续。
每次递归调用之后越来越接近这个限制条件。

递归的举例

#include 
接受一个整型值（无符号），按照顺序打印它的每一位。
例如：
输入：123，输出 1 2 3 
void print(int n) 将值传入这
{
 if(n>9)
 {
 print(n/10);
 }
 printf("%d ", n%10);
}

int main()//主函数
{
 int num = 123;
 print(num);运行到这时
 return 0; }

1.当主函数的开始运行到print(num);时
2. 会将num的值传入print函数
3.开始判断是否大于9
4.123大于9则采用递归
5.123/10之后再次进入print函数
6.12大于9则采用递归
7.12/10之后再次进入print函数
8.1小于9则执行printf函数1%10后打印进行得到1
9.函数执行完毕后回到第七步的12/10进行递归的地方
10.然后执行printf函数12%10后打印进行得到2
11.函数执行完毕后回到第5步的123/10进行递归的地方
12.然后执行printf函数123%10后打印进行得到3
函数执行完毕以后要回到函数开始执行的地方