C语言 函数

函数定义：

C语言可以分为库函数和自定义函数。 把一些常用的功能实现成函数，集成为库，由C语言直接提供。比如：printf，scanf，strlen等等。

库函数：

strcpy：

#include <stdio.h>
#include <string.h>

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "xxxxxxxxx";
	strcpy(arr2, arr1);

	printf("%s\n", arr2);
	return 0;
}

 memset:内存设置  即memory set

int main() 
{
	char arr[] = "hello bit";
	memset(arr, 'X', 5);
	//memset(arr+6,'X',5);  结果是  hello bit
	//设置内存的时候，一字节为单位。
	//每个字节的内容都是一样的。

	printf("%s\n", arr); //XXXXX bit
	return 0;
}

自定义函数：

1.比较大小

int get_max
{
	if (x > y)
		return x;
	else
		return 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);
	printf("%d\n", m);

	return 0;
}​

2.写一个函数可以交换两个整型变量的内容

当时参传给形参的时候，形参是实参的一份临时拷贝，对形参的修改不会影响实参。

void swap(int x, int y)//x,y是形参
{
	
	int tmp = 0;
	tmp = x;
	x = y;
	y = tmp;
}

int main()
{
	int a = 0;//a，b是实参。
	int b = 0;
	scanf("%d %d", &a, &b);
	printf("交换前：a=%d,b=%d\n", a, b);
	swap(a, b)
	printf("交换后：a%d,b=%d\n", a, b);

	
	return 0;
}

void swap2(int* pa, int* pb)
{
	int tmp = *pa;
	*pa = *pb;
	*pb = tmp;
}

int main()
{
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	printf("交换前：a=%d,b=%d\n", a, b);
	int *p1 = &a;
    int *p2 = &b;
    swap2(&a, &b);
	printf("交换后：a%d,b=%d", a, b);

	
	return 0;
}

第一种会报错。需要传地址，传值没有什么作用。

 实际参数（实参）：

这是传递给函数的参数，叫实参；

实参可以是：变量，常量，函数，表达式等；

无论是实参何种类型的量，在进行函数调用时，他们都被必须有确定的值，以便把这些值传送给形参。

形式参数（形参）：

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

传值调用：

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

传址调用：

传址调用函数外部创建变量的内存地址传递给函数参数的一种调用方式。

这种传参方式可以让函数和函数外边的变量建立起真正的联系，也就是函数内部可以直接作函数外部的变量。

例题：

先写 函数怎么使用—测试

TDD测试驱动开发：test driven development

1.写一个函数判断一个数是不是素数。函数为is_prime(i)。返回1是素数，返回0不是素数

int is_prime(int n)
{
	//2~n-1试除
	//2~sqrt(n)试除
	int j = 0;
	for (j = 2; j <= sqrt(n); j++)
	{
		if (n % j == 0)
		{
			return 0;
		}
	}
	return 1;
}
int main()
{
	int i = 0;
	for (i = 100; i <= 200; i++)
	{
		if (is_prime(i) == 1)
		{
			printf("%d", i);
		}
	}
	return 0;
}

2.写一个函数，判断该年份是不是闰年

int i_Leap_year(int y)
{
	if (((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0))
		return 1;
	else
		return 0;
}

int main()
{
	//1000~2000年的闰年
	int y = 0;
	for (y = 1000; y <= 2000; y++)
	{
		//判断y是不是闰年
		if (is_leap_year(y) == 1)
		{
			printf("%d", y);
		}
	}
}

注意：设置函数的时候，要让函数的功能比较单一。后面代码用起来比较方便。

3.写一个函数，实现一个整形有序数组的二分查找

binary_search(int arr[], int k, int sz)
{
	int left = 0;
	int right = sz - 1;

	while (left <= right)
	{
		int mid = left + (right - left) / 2;
		if (arr[mid] < k)
		{
			left = mid + 1;
		}
		else if (arr[mid] > k)
		{
			right = mid - 1;
		}
		else
		{
			return mid;
		}
	}
	return -1;//找不到
}

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int k = 0;
	scanf("%d", &k);
    //int sz = sizeof(arr)/sizeof(arr[0]);
    //int ret = binary_search(arr,k,sz);
	int binary_search(arr, k);//错误示范
	if (-1 == ret)
		printf("找不到\n");
	else
		printf("找到了，下标是：%d\n", ret);

	return 0;
}

注意：数组在传参的过程中传递的不是整个数组，传递的是数组首元素的地址。

int arr[ ]:本质上是指针 int *arr

 4.写一个函数，每调用一次，num就会增加1

void test(int* p)
{
	*p = *p + 1;
}
int main()
{
	int num = 0;
	test(&num);
	printf("%d\n", num);
	return 0;
}

注意：不能是 *p++。 因为++的优先级更高。而应该是（*p）++

嵌套调用和链式访问

嵌套调用
//函数可以嵌套调用，但是不能嵌套定义
//
//链式访问
//

void test()
{

}
int main()
{
	test();
	return 0;
}

int main()
{
	//int len = strlen("abcdef");
	//printf("len = %d\n", len);

	//printf("len = %d\n", strlen("abcdef"));

	printf("%d", printf("%d", printf("%d", 43)));

	return 0;
}

函数的声明和定义

函数声明：

1.告诉编译器函数叫什么，参数是什么，返回类型是什么。但具体是不是存在，函数声明决定不了。

2.函数的声明一般出现在函数的使用之前。要满足先证明后使用。

3.函数的声明一般要放在头文件中的。

//函数的声明
//形参的名字可以省略 
int add(int x, int y);
int main()
{
	int a = 10;
	int b = 20;
	int sum = add(a, b);
	printf("%d\n", sum);

	return 0;
}

int add(int x, int y)
{
	return x + y;
}

函数定义：

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

#include <stdio.h>
#include "add.h"
//导入静态库
#pragma comment(lib, "add.lib")

int main()
{
	int a = 10;
	int b = 20;
	int sum = Add(a, b);//函数的使用
	printf("%d\n", sum);
	return 0;
}

 注意：自己定义的头文件用  “”  用双引号去引，不能用尖括号去引

配置静态库

 test.h的内容：放置函数的声明

#ifndef _TEST_H_
#define _TEST_H_
//函数声明
int add(int x,int y)

#endif //_TEST_H_

test.c内容：放置函数实现

#include<stdio.h>
int add(int x,int y)
{
    return x+y;
}

int main()
{

}

注意：要适应分文件的书写形式。

函数的递归（递推-回归）

定义：函数调用自身的编程技巧被称为递归。它通常把一个大型的复杂问题转化为一个与原问题相似的规模较小的问题来求解，递归策略只需要少量程序就可以描述出解决问题所需要的重复计算，大大减少了程序的代码量。（把大事化小）

//最简单的递归，调用main 函数
int main()
{
	printf("hehe\n");
	
	main();
	return 0;
}

递归的两个必要的条件：

1.存在限制条件，当满足这个条件是，递归将不再继续。

2.每次递归调用之后越来越接近这个限制条件。

例题：

1.接收一个整型值,按照顺序打印她的每一位；例如：1234  变成4321

//接收一个整型值,按照顺序打印她的每一位；例如：1234  变成4321

void printf(int n)  // 1234
{
	if (n > 9)
	{
		printf(1 / 10);
	}
	printf("%d", n % 10);
}
int main()
{
	unsigned int num = 0;
	scanf("%d", &num);
	printf(num);  //printf函数可以把num的每一位打印出来
	//1234%10=4
	//1234/10=123
	//123%10=3
	//123/10=12
	//.....
	//[4,3,2,1]
	//
	return 0;
}

2.编写函数变量，不允许创建临时变量，求字符串长度

int my_strlen(char* str)
{
	int count = 0;//统计字符的个数
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}

my_strlen("abcdef")
1+my_strlen("bcdef")
1+1+my_strlen("cdef")
1+1+1+ my_strlen("def")
1+1+1+1+ my_strlen("ef")
1 + 1 + 1 + 1 +1+my_strlen("f")
1 + 1 + 1 + 1 + 1 + 1+ my_strlen("")
1 + 1 + 1 + 1 + 1 + 1 + 0 = 6

int my_strlen(char* str)
{
	if (*str != '\0')
		return 1 + my_strlen(str+1);
	else
		return 0;
}

                                                                                  

 

递归与迭代

循环是一种迭代

练习：

阶乘

int main()
{
	if (n < 1)
		return 1;
	else
		return n * fac(n - 1);
}
int main()
{
	int n = 0;
	scanf("%d", &n);
	int ret = fac(n);
	printf("%d\n", ret);

	return 0;
}

int fac(int n)
{
	int i = 0;
	int ret = 1;
	for (i = 1; i <= n; i++)
	{
		ret = ret * i;
	}
	return ret;
}

int main()
{
	int n = 0;
	scanf("%d", &n);
	int ret = fac(n);
	printf("%d\n", ret);

	return 0;
}

 2.求第n个斐波那契数

//斐波那契数列  1 1 2  3 5 8 13   即前两个数相加等于第三个数

int fib(int n)
{
	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);

	return 0;
}

3.汉诺塔

青蛙跳台阶