C语言学习第6周-数组与函数

数组

第一部分-初识数组 

计算平均数时我们学过这样一段程序，如下：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

int main()
{
	int x;
	int count=0;
	double sum = 0;
	printf("请输入累加数字");
	scanf("%d", &x);
	while (x != -1){
		sum += x;
		count++;
		printf("请输入累加数字");
		scanf("%d", &x);
	}
	printf("总共输入了%d个数字\n",count);
	if (count > 0){
		printf("平均数为%lf\n", sum / count);
	}
	return 0;
}

 这段程序中循环中带有scanf输入语句，把需要累加的数字逐个输入，输入-1代表输入结束了。可以求出平均数。

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

int main()
{
	int x;
	double sum = 0;
	int count = 0;
	scanf("%d", &x);
	while (x != -1){
		sum += x;
		count++;
		scanf("%d", &x);
	}
	if (count > 0){
		printf("%f\n", sum / count);
	}
	return 0;
}

这段代码的使用可以这样使用，因为scanf()，再循环内外都有，所以在输入时可以把所有要输入的数字一次性输入，只不过要在所有输入的数字之间用空格隔开。

有这样一个问题：写一段程序计算用户输入数字的平均数，并且输出输入数字中大于平均数的数字。如果一个数字一个数字的输入，那就要定义很对变量，并且输入的数字你不知道的有多少个，那该怎么办呢，这就运用到了数组。

int number[100];

这条语句的意思是：定义了一个用来记录很多个数字的数组，这个数组有一百个那么大。

这一行就是我们定义了一个变量，这个变量叫number，这个变量是一个数组，这个数组里面的每一个单元都是一个int，这个数组它的大小为100，也就是说这个数组里面可以放100个int。

    int number[100];
	int cnt;//假如说cnt是一个循环变量，每次的数字都是递增的。
	number[cnt] = x;

 第三条语句的意思就是：number中cnt那个位置上的那个单元让它等于x。

运用数组解决上述问题程序如下：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

int main()
{
	int x;
	double sum = 0;
	int count = 0;
	int number[100];//定义数组
	scanf("%d", &x);
	while (x != -1){
		number[count] = x;//对数组中的元素进行赋值。
		sum += x;
		count++;
		scanf("%d", &x);
	}
	if (count > 0){
		int i;
		double average = sum / count;
		for (i = 1; i < count; i++ ){
			if (number[i] < average){     //使用数组中的元素
				printf("%d\n", number[i]);//整个for循环是在遍历数组
			}
		}
	}
	return 0;
}

  第二部分-定义数组 

 <类型> 变量名称 [元素数量]，其中元素数量必须是整数。

对数组的理解就是：数组是一个容器（放东西的东西）。

它的特点：

• 所有元素具有相同的数据类型；
• 一旦创建，不能改变它的大小；
• 数组中的元素在内存中，是连续依次排列的。

例如：int  a[10] ，是一个int的数组，有10个单元从a[0]、a[1]、a[2].....a[9]

 

 每个单元就是一个int类型的变量，可以出现在赋值的左边或右边：a[2]=a[1]+6，在赋值左边的叫左赋值

• 数组的每个单元就是数组类型的一个变量
• 使用数组时放在[ ]中的数字，叫做下标或索引，下标从零开始计数。

下标的有效范围：

• 编译器和运行环境都不会检查数组下标是否越界，无论对数组单元做都还是写。
• 一旦运行，越界的数组访问可能会造成问题，导致程序崩溃
• 所以要保证程序只是用有效下标值从0到n-1。
• 可以创建下标为零的数组，可以存在，但是无用

C语言数组的下标只能是合法的整型值。 那字符可以做下标吗？

当下标为字符时，有两种可能：

• 以字符常量作为下标。如a['A'];表示'A'的ascii码对应的数组偏移量。在实际应用中不常见，但是从语法上来说是合法的。（因为储存的是计算机的ASCII码的值，即是数字）
• 字符本身为变量。

  第三部分-用数组做散列计算 

 写一段程序，输入数量不确定的[0 ,9]内的整数，统计每一种数字出现的次数，输入-1表示结束。

 

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

int main()
{
	const int number = 10;//
	int x;
	int count[10];//定义数组
	int i;

	for (i = 1; i < number; i++){
		count[i] = 0;    //这个for循环是用来初始化数组的。
	}
	scanf("%d", &x);
	while (x != -1){
		scanf("%d", &x);//数组参与运算。
	}
	for (i = 0; i < 10; i++){
		printf("%d:%d\n", count[i]);//遍历数组参与运算。
	}
	return 0;
}

 函数的定义与使用

 第一部分--初见函数

写一段求和的代码：计算1到10的和，20到30的和，35到45的和。

我们可以想到使用for循环来写。

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

int main()
{
	int i;
	int sum;
	for (i = 1,sum=0; i <= 10; i++){
		sum += i;
	}
	printf("%d到%d的和是%d\n", 1, 10, sum);


	for (i = 20,sum=0; i <= 30; i++){
		sum += i;
	}
	printf("%d到%d的和是%d\n", 20, 30, sum);


	for (i = 35,sum=0; i <= 40; i++){
		sum += i;
	}
	printf("%d到%d的和是%d\n", 35, 40, sum);

	return 0;
}

 使用了三个同样的for循环，这是代码质量不良的表现，可不可以使用一个函数来代替呢，可以。

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

void sum(int begin, int end)
{
	int i;
	int sum = 0;
	for (i = begin; i <= end; i++){
		sum += i;
	}
	printf("%d到%d的和为%d\n\n",begin,end, sum);
}


int main()
{
	sum(1, 10);
	sum(20, 30);
	sum(35, 45);
	return 0;
}

  第二部分--函数的定义和使用

什么是函数：函数是一块代码，接收零个或多个参数做一件事，并返回零个或一个值。可以将它想象成数学中的函数但是不完全一样。 

viod sum(int begin, int end)//这个叫函数头
{
	函数体;                 //这个叫函数体
}

 特别要注意的是：函数的大括号中即使只有一条语句，大括还是要有的。即使函数头中的圆括号中没有任何东西，在主函数中调用时也是不能省略的。

void cheer(){
	printf("cheer\n");
}

int main()
{
	cheer();
}

 这个调用是正确的。

void cheer(){
	printf("cheer\n");
}

int main()
{
	cheer;
}

这个调用是错误的。

如果调用的函数中有参数，那就要给出正确数量和顺序。

第三部分--从函数中返回

int max(int a, int b){
	int ret;
	if (a > b){
		ret = a;
	}
	else{
		ret = b;
	}
	return ret;
}

这里的return就是要返回一个值给max。

• return停止函数的执行，并送回一个值
• 有两种类型：return；和return 表达式；单一的一个变量也是表达式，这个变量是一个值。这个值会交给调用函数的地方。

在上面定义的函数，我们遵行了单一出口的理念，这样写更好一点。因为这样有利于后期的维护。如下情况调用函数都是可以的：

 

 也可以直接这样调用max(a,b)；没有把它的结果交给任何人，这样也是可以的。

没有返回值的函数的类型为void类型，这类函数不能使用带值的return，当然也可以在函数体中没有return。在调用的时候不能做返回值的赋值。

函数的参数和变量

第一部分--函数原型 

函数先后关系：C语言编译器，自上而下顺序分析你的代码，在一段程序中在看到调用函数之前一定要先看到你定义的函数。如：在使用sum(1,10)之前一定要先读取到sum（）这个函数。也就是在调用函数之前，C语言编译器需要知道你的函数长什么样子，需要几个参数，每个参数的类型如何，返回什么类型的值。这样他才能检查你对sum()的调用是否正确。如下程序所示。

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

int sun(int a, int b){
	int ret;
	if (a > b){
		ret = a;
	}
	else{
		ret = b;
	}
	return ret;
}

int main()
{
	sum(1, 10);
	sum(20, 30);
	sum(35, 40);
	return 0;
}

这种程序的写法是一定没有问题的。但是这样的程序不便于理解，我们在理解程序时，想要第一眼就看到函数的主题内容是怎么样的。那么这种情况该怎么办呢。我们可以使用函数声明。所谓声明就是只把函数的头放到main函数的前面并且在这条声明后面加上分号。如下

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>


int sun(int a, int b);//这一行称为函数的原型声明。

int main()
{
	sum(1, 10);
	sum(20, 30);
	sum(35, 40);
	return 0;
}

int sun(int a, int b){      //15行-24行称为函数的定义。
	int ret;
	if (a > b){
		ret = a;
	}
	else{
		ret = b;
	}
	return ret;
}

声明不是函数，声明只是告诉编译器，某个函数是什么样子，有几个参数，是什么类型。

函数原型：

• 函数的头加上一个分号结尾，就构成了函数原型。
• 函数原型的目的就是告诉编译器函数长什么样子。包括名称，参数（数量和类型），返回值类型
• int sun(int , int );这样写函数原型也是OK的。

第二部分--参数传递

调用函数：1.如果函数有参数，调用函数时必须传递给他数量，类型正确的值。

                 2.传递给函数的值，可以是表达式的结果。这包括字面量、变量、函数的返回值、计算                      结果。

C语言中，表达式是一个很泛的范围，单一的字面量时表达式，单一的变量是表达式，赋值也是表达式，计算的结果也是表达式，调用函数本身也是表达式。

 如果调用函数给的值和函数参数的类型不匹配会怎么样。如果函数的参数类型是int，你给它一个double类型的数，他会自动化帮你转为int类型的数，但是这个返回的结果可能不是你期望的那个结果。

但是如果是c++/Java语言在这方面可能会严格很多。

问题：调用函数的时候传过去的到底是什么。看一下下面这段程序。

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

int swap(int , int );

int main()
{
	int a = 5;
	int b = 6;
	swap(a, b);
	printf("a=%d b=%d\n",a, b);
	return 0;
}

int swap(int a, int b){ 
	int t=a;
	a = b;
	b = a;
}

 这段程序目的是输入两个数，然后可以调换两个数的值，然后输出。但是运行之后会发现和我们的期望不一样。没有交换数值输出。那在调用函数的时候，传过去的是什么呢？

C语言在调用函数的时候，永远只能传值给函数。上述代码中，调用swap（a，b）时只是把a=5传递给了swap（）函数中的a。就只是这样的关系。除此之外，main中a,b两个变量和，swap函数中的两个参数没有任何联系。

传值：

• 每个函数有自己的变量空间，参数也位于这个独立的空间中，和其他函数没有关系。
• 对于函数参数表中的参数，叫做形式参数。调用函数时给的值，叫做实际参数。但是我们初学者，非常容易把这个地方混肴。所以我们干脆直接，就称他们为参数和值，如下

第三部分--本地变量  

函数的每次运行，就产生了一个独立的变量空间，在这个空间中的变量，是函数这次运行所独有的，称作本地变量。

定义在函数内部的变量就是本地变量。参数也是本地变量。有些地方把本地变量也叫局部变量。

 变量的生存期和作用域：

• 生存期：什么时候这个变量开始出现了，到什么时候它消亡了。
• 作用域：在代码的什么范围内可以访问这个变量（这个变量可以起作用）
• 对于本地变量来说，生存期和作用域都是大括号内，我们又称它为块。

程序在运行main函数的时候，当运行到swap的时候，回去转身调用swap函数。在main中的变量a,b与swap中的变量没有任何关系没有任何关系。程序在运行main的时候，main有它的变量空间，当转身调用swap的时候，swap也有自己的变量空间。当调用swap的时候，我们是要离开main函数的。离开main，离开的是什么，离开的就是它的变量空间。条用swap的时候我们不在，main的空间里了，我们来到了swap的空间，在swap空间的变量a,变量b即使变量的名称和main中的一样但是和main中的变量已经没有任何关系了。因此我们在swap中无论我们怎么对a,对b进行赋值都和main中的没有关系了，因为他们不在一起。当我们调用完swap后，再回到main后，swap的那个变量空间已经不存在了。

本地变量的规则：

1>本地变量是定义再块内的

• 它可以是定义在函数的块内。
• 也可以是定义在语句的块内的。
• 甚至可以随便拉一对大括号来定义变量。随便拉一对大括号，在里面定义的变量，当程序运行到这对大括号之前变量不存在，离开这个块后，变量也就消失了。
• 在块的外面定义的变量，再块的里面仍然有效。
• 如果在块里面定义了和块外面同名变量则掩盖了外面的。
• 不能在同一个块中定义同名的变量。
• 本地变量不会被默认初始化。
• 而参数在进入函数的时候会被初始化。(调用函数的时候一定要给参数对应的值，那个值在进入函数的时候就会用来初始化参数)。

第四部分--函数的其他细节

当函数没有参数的时候要怎么写呢，是写成void f（void），还是写成void f( )呢。

void f ()这个在传统的C语言中表示，f 函数的参数表未知，并不表没有参数。

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

int swap();//在声明函数原型的时候，我们没有声明参数的数量和类型，
           //这种情况编译器会猜测我们的参数是什么样的。

int main()
{
	int a = 5;
	int b = 6;

	swap(a, b);//当编译器运行到这一行的时候，他会猜你的swap要两个int。如果我们的swap就是需要两个int那没有问题，如果不是会怎样。
	printf("a=%d b=%d\n",a, b);
	return 0;
}

int swap(double a, double b){   //如果我们的swap需要两个double编译器会怎样呢？
	int t=a;
	a = b;
	b = a;
}

首先要讲一点，作为新手我们一定不要写出这样的原型声明，因为原型声明本就是告诉编译我们有那些用来那些函数，函数的参数数量和类型是什么样的。上述的程序我在运行的时候什么都没有显示。这就说程序有问题了，它既没有报错也没有提醒。

原型声明的作用不仅仅是又来检查你对函数的调用是不是对的，也用于检查你对函数的定义是不是对的。

还有一个问题，逗号运算符：  我们在调用函数的时候会如果是两个参数我们会用逗号隔开，那逗号也是运算符，如  f  (  a , b  )这种情况不应该是保留b的吗。

• 调用函数的时候逗号和逗号运算符怎么区分呢
• 调用函数时的圆括号里的逗号是标点符号不是运算符。
• f(a,b)这个里面的是逗号标点符号，f((a,b))如果是这种的话就是只有一个参数，这个参数是一个表达式，要计算（a,b）这个逗号运算符的结果。

函数里面能定义函数吗？不能，C语言中不允许函数的嵌套定义。我们可以在一个函数中放另外一个函数的声明，但是不能放另外一个函数的定义。

关于main函数，main是一个程序的入口，同时它也是一个函数。在main函数之前也有很多语句，如函数的原型声明，这些都是为main函数的运行做准备的。那些准备工作做完之后，会来调用你的main函数。所以main是一个函数。所以那个return 0；也是有意义的，main函数运行完之后，会把那个0返回给调用它的地方。return 0；是有人看的，操作系统会看。

二维数组

int a[3][5];

通常理解为一个3行5列的矩阵。

 二维数组的遍历

int a[3][5];
int i;
int j;
for (i = 0; i < 3; i++){
	for (j = 0; j < 5; j++){
		a[i][j] = i*j;
	}
}

a [ i ] [ j ]表示一个int，表示一个第i行 第j列上的单元，和一维数组一样，我们是从0开始编号的。

a [ i , j ]是什么呢？因为逗号在这里是运算符，所以这里 [i，j]是一个表达式，它的运算结果就是

a[ j ]，这在二维数组里面不是一个正确的表达式。

二维数组的初始化

•  列数必须是要给出的，行数可以有编译器来数。
• 每行一个{ }，用逗号隔开。
• 最后的逗号可以存在，这是有古老的传统。
• 如果省略，表示补零。

井字棋游戏程序(了解)

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

int main(){
	const int size = 3;
	int board[size][size];
	int i, j;
	int num0fx;
	int num0f0;
	int result = -1;

	//读入矩阵
	for (i = 0; i < size; i++){
		for (j = 0; j < size; j++){
			scanf("%d", &board[i][j]);
		}
	}

	//检查行
	for (i = 0; i < size&&result == -1; i++){
		num0f0 = num0fx = 0;
		for (j = 0; j < size; j++){
			if (board[i][j] == 1){
				num0fx++;
			}
			else{
				num0f0++;
			}
		}
		if (num0f0 == size){
			result = 0;
		}
		else if (num0fx == size){
			result = 1;
		}
	}
	if (result == -1){
		for (j = 0; j < size&&result == -1; j++){
			num0f0 = num0fx = 0;
			for (i = 0; i < size; i++){
				if (board[i][j] == 1){
					num0fx++;
				}
				else{
					num0f0++;
				}
			}
			if (num0f0 == size){
				result = 0;
			}
			else if (num0fx == size){
				result = 1;
			}
		}
	}
	//检查对角线
	num0f0 = num0fx = 0;
	for (i = 0; i < size:i++){
		if (board[i][j] == 1){
			num0fx++;
		}
		else{
			num0f0++;
		}
	}
	if (num0f0 == size){
		result = 0;
	}
	else if (num0fx == size){
		result = 1;
	}
	num0f0 = num0fx = 0;
	for (i = 0; i < size; i++){
		if (board[i][size - i - 1] == 1){
			num0fx++;
		}
		else{
			num0f0++;
		}
	}
}