C语言函数的基本使用和递归

库函数学习网站

下来我们根据库函数学习网学习几个库函数：

#include<stdio.h>
#include<string.h>//strcpy库函数所需的头文件

//string copy 字符串拷贝
//char * strcpy ( char * destination, const char * source );
int main()
{
	char arr1[] = "hello bit";
	char arr2[20] = { 0 };
	strcpy(arr2, arr1);
	printf("%s\n", arr2);
	return 0;
}

输出结果：

#include<stdio.h>
#include<string.h>//memset所需的库函数的头文件
//memset memory set 内存设置
//void * memset(void * ptr, int value, size_t num);

int main()
{
	char arr[] = "hello bit";
	memset(arr, '*', 5);//arr-需要修改的数组 ' '-修改的内容 5-修改数组里的个数
	printf("%s\n", arr);
	return 0;
}

输出结果：




传值调用：

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

//自己创建的自定义函数
int get_max(int x, int y)
{
	int c = (x > y ? x : y);
	return c;
}

int main()
{
	//写一个函数找出2个数的较大值
	int num1 = 4;
	int num2 = 7;
	int max = get_max(num1,num2);
	printf("%d\n", max);
	return 0;
}

输出结果：

形参实例化之后其实相当于实参的一份临时拷贝。
传址调用：

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

//写一个函数把x y的值交换
//找bug的过程叫调试 f10主函数调试 f11进入自定义函数
//当时参传给形参的时候，形参是实参的一份临时拷贝
//对形参的修改不会影响实参
void swap(int* x, int* y)//x y - 形参 形式参数
{
	int z = 0;
	z = *x;
	*x = *y;
	*y = z;
}

int main()
{
	int a = 6;
	int b = 8;
	printf("%d %d\n", a, b);//交换前6 8
	swap(&a,&b);//a，b - 实参 实际参数
	printf("%d %d\n", a, b);//交换后8 6
	return 0;
}

输出结果：

#include<stdio.h>
#include<string.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;
}

输出结果：

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

int main()
{
	//1
	int len = strlen("abcdef");
	printf("%d\n", len);
	
	//2 - 链式访问
	printf("%d\n", strlen("abcdef"));
	return 0;
}

输出结果：

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

int main()
{
	//printf的返回值是打印的字符数
	printf("%d", printf("%d", printf("%d", 43)));//4321
	return 0;
}

输出结果：

输出结果：

注意：

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

//递归解决这个问题
//(123)4
//(12)3
//1 2
void print(int n)
{
	if (n > 9)//存在限制条件，当满足这个限制条件的时候，递归便不再继续。
	{
		print(n / 10);//每次递归调用之后越来越接近这个限制条件。
	}
	printf("%d ", n % 10);
}


int main()
{
	unsigned int num = 0;
	scanf("%d", &num);
	print(num);//1234 ---> 1		2	  3  	4
	return 0;
}

输出结果：

递归例子：

1.编写函数不允许创建临时变量，求字符串的长度。
以下采用非递归创建临时变量的方法：

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

int my_strlen(char* str)
{
	int count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}

int main()
{
	char arr[] = "abcdef";
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

输出结果：

以下采用递归不创建临时变量的方法：

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

//my_strlen("abc")
//1+my_strlen("bc")
//1+1+my_strlen("c")
//1+1+1+my_strlen("")
//1+1+1+0=3

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

int main()
{
	char arr[] = "abcdef";
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

输出结果：

2.求n的阶乘。（不考虑溢出）

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

int func(int x)
{
	if (x > 1)
	{
		return x*func(x - 1);
	}
	else
	{
		return 1;
	}
}

int main()
{
	int n = 5;
	int ret = func(n);
	printf("%d\n", ret);
	return 0;
}

输出结果：

3.求第n个斐波那契数（不考虑溢出）

递归法：（效率低）

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

//斐波那契数列：1 1 2 3 5 8 13 21 34 55
int Fibo(int x)
{
	if (x > 2)
	{
		return Fibo(x - 1) + Fibo(x - 2);
	}
	else
	{
		return 1;
	}
}

int main()
{
	int n = 5;
	printf("%d\n", Fibo(n));
	return 0;
}

输出结果:

非递归法：（效率高）

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

//非递归求法
//斐波那契数列：1 1 2 3 5 8 13 21 34 55
//1            a b c
//2              a b c
//3                a b c

int Fibo(int x)
{
	int a = 1;
	int b = 1;
	int c = 1;
	while (x > 2)
	{
		c = a + b;
		a = b;
		b = c;
		x--;
	}
	return c;
}

int main()
{
	int n = 5;
	printf("%d\n", Fibo(n));
	return 0;
}

输出结果：