C语言学习4

。

                                                                                shutdown -s -t 60(六十秒内关机）

shutdown -a(取消关机）

#include
#include
#include
int main()
{
	//C语言提供了一个函数system（）-执行系统命令
	char input[20] = { 0 };//存放输入的信息
	system("shutdown -s -t 60");
again:
	printf("请输入我是猪取消关机\n");
	scanf("%s", input);
	if (strcmp(input, "我是猪") == 0)//两个字符串的比较不能使用==，应该使用strcmp（）-string compare
	{
		system("shutdown -a");
	}
	else
	{
		goto again;
	}
}

goto语句只能在一个函数范围内跳转，不能跨函数

-------------

函数

IO函数：输入输出函数，例如printf scanf getchar.....

字符串 *** 作函数:如strcmp strlen

字符 *** 作函数：如toupeper

内存 *** 作函数：如memcpy memcmp memset=

时间/日期函数：如time

数学函数：如sqrt pow

其他库函数

自定义函数和库函数一样，有函数名，返回值类型和函数参数。

但是不一样的是这些都是我们自己来设计。

这给程序员一个很大的发挥空间。

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

函数返回类型的地方写出：void，表示这个很难书不返回任何值，也不需要返回

void swap(int* pa, int* pb)
{
	int tmp = 0;
	tmp = *pa;
	*pa = *pb;
	*pb = tmp;
}
int main()
{
	int a = 10;
	int b = 30;
	swap(&a, &b);
	printf("a=%d b=%d", a, b);
	return 0;
}

交换两个整型变量的值，形参是实参的一份临时拷贝。

改变形参不能改变实参

实际参数(实参）：真实传递给函数的参数，叫实参。

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

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

形式参数（形参）：形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内存单元），所以叫形式参数。

形式参数当函数调用完成之后就自动销毁了，因此形式参数只在函数中有效。

函数的调用：

传值调用：函数的形参和实参分别占有不同的内存块，对形参的改变不会影响实参。

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

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

写一个函数判断100--200之间的素数

#include
#include
int is_prime(int n)
{
	int j = 0;
	for (j = 2; j <= sqrt(n); j++)
	{
		if (n%j == 0)
		{
			return 0;
		}
	}
	return 1;
}
int main()
{
	int count = 0;
	int i = 0;
	for (i = 100; i <= 200; i++)
	{
		if (is_prime(i) == 1)
		{
			count++;
			printf("%d  ", i);
		 }
	}
	printf("count = %d", count);
	return 0;
}

数组进行传参，实际传递的不是数组本身，仅仅传过去了数组首元素的地址

-------------

函数递归

函数调用自身的编程技巧称之为递归。

递归作为一种算法在程序设计语言中广泛应用。

一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。

递归的主要思考方式在于：把大事化小

递归的两个必要条件

存在限制条件，当满足这个限制条件的时候，递归便不再继续。

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

%u用于打印无符号整型 

接受一个整型值（无符号），按照顺序打印它的每一位。

例如：输入：1234，输出：1 2 3 4

#include
void print(unsigned int num)
{
	if (num >9)
	{
		print(num / 10);
	}
	printf("%d  ", num % 10);
}
int main()
{
	unsigned int num = 0;
	scanf("%u", &num);
	print(num);
	return 0;
}

写递归代码的时候防止栈溢出：

1，不能死递归，都有跳出条件，每次递归逼近跳出条件；

2，递归层次不能太深。

递归与迭代

求第n个斐波拉契数

#include
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", ret);
	return 0;
}

上述程序代码效率太低，有重复大量的计算

将代码修改如下：

#include
int fib(int n)
{
	int a = 1;
	int b = 1;
	int c = 1;
	while (n > 2)
	{
		c = a + b;
		a = b;
		b = c;
		n--;
	}
	return c;
}
int main()
{
	int n = 0;
	scanf("%d", &n);
	int ret = fib(n);
	printf("%d", ret);
	return 0;
}

计算出1/1-1/2+1/3-....+1/99-1/100

#include
int main()
{
	int i = 0;
	double sum = 0.0;
	int flag = 1;
	for (i = 1; i <= 100; i++)
	{
		sum += flag * 1.0/ i;
		flag = -flag;
	}
	printf("%lf", sum);
	return 0;
}

编写一个函数 reverse_string(char*string)(递归实现）

实现将参数字符中的字符反向排列，不是逆向打印。

要求不能使用C语言库函数中的字符串 *** 作函数。

例如：char arr[]='abcdef'逆序之后数组内容变成'fedcba'

#include
int my_strlen(char* arr)
{
	int count = 0;
	while (*arr != '\0')
	{
		count++;
		arr++;
	}
	return count;
}
void reverse_string(char* arr)
{
	char tmp = *arr;
	int len = my_strlen(arr);
	*arr = *(arr + len - 1);
	*(arr + len - 1) = '\0';
	if (my_strlen(arr + 1) >= 2)
	{
		reverse_string(arr + 1);
	}
	*(arr + len - 1) = tmp;
}
int main()
{
	char arr[] = "abcdef";
	reverse_string(arr);
	printf("%s", arr);
	return 0;
}