C语言数组学习

学习环境：xp ，vs 6++ 

操作符：sizeof可用于求的数组的长度。

用法：数组长度 = sizeof(数组名)/sizeof(数组第一个元素)

一维数组：

1、C语言不允许用变量来指定数组长度

	int len = 5;
	//int arr[len];//这种用变量来制定数组长度，在C语言中是不允许的，编译不通过
	int arr[5];//这样声明数组，表示定义一个指针常量，没有指向任何int型数组，C语言不会给每个元素赋初始值0
	printf("%d\n", arr[0]);//由于没有给数组赋初始值，将输出一个不确定的数，输出：-858993460
	
	//int：-858993460（十六进制OXCCCCCCCC）（二进制11001100110011001100110011001100）
	//当一个未初始化赋值的时候(至少是vc 下未初始化的内存)默认是0xCCCCCCCC;，他在内存就默认保存为-858993460
	
	for(int i=0; i < sizeof(arr)/sizeof(arr[0]); i++){
		printf("第%d个元素值：%d，对应地址：%p\n", i,arr[i], &arr[i]);//每个元素值都是-858993460
	}
	printf("\n");

输出结果：

2、只给第一个元素赋初始值，后面元素自动初始化为0

	int arr1[5] = {6};//只给第一个元素赋初始值，后面元素自动初始化为0
	for(int j=0; j < sizeof(arr1)/sizeof(arr1[0]); j++){
		printf("第%d个元素值：%d，对应地址：%p\n", j,arr1[j], &arr1[j]);
	}

输出结果：

3、定义数组时每个元素都初始化

	int arr2[5] = {4,2,-4,6,-10};//定义数组时每个元素都初始化

	for(int n=0; n < sizeof(arr2)/sizeof(arr2[0]); n++){
		printf("第%d个元素值：%d，对应地址：%p\n", n,arr2[n], &arr2[n]);
	}

输出结果：

4、定义数组不指定长度，长度自动计算为3

	int arr3[] = {4,2,-4};//定义数组不指定长度，长度自动计算为3
	for(int m=0; m < sizeof(arr3)/sizeof(arr3[0]); m++){
		printf("第%d个元素值：%d，对应地址：%p\n", m,arr3[m], &arr3[m]);
	}

输出结果：

二维数组：

1、定义一个二维数组，一维数组长度为3，一维数组元素是一个长度为4个数组

	int arr[3][4];//定义一个二维数组，一维数组长度为3，一维数组元素是一个长度为4个数组
	for(int i=0; i< sizeof(arr)/sizeof(arr[0]); i++){
		for(int j=0; j < sizeof(arr[i])/sizeof(arr[i][0]); j++){
			printf("%d,", arr[i][j]);//由于为初始化，输出-858993460
		}
		printf("\n");
	}

输出结果：

2、定义二维数组，每个元素都初始化

	//定义二维数组，每个元素都初始化
	int arr1[3][4]={
		{4,6,1,3},
		{20,30,3,4},
		{-1,5,5,8}
	};

	for(int m=0; m< sizeof(arr1)/sizeof(arr1[0]); m++){
		for(int n=0; n < sizeof(arr1[m])/sizeof(arr1[m][0]); n++){
			printf("%d,", arr1[m][n]);
		}
		printf("\n");
	}

输出结果：

3、定义二维数组，只初始化一维的部分元素，未初始化的默认为0

	int arr2[3][4] = {
		{3,6}
	};

	for(int j=0; j< sizeof(arr2)/sizeof(arr2[0]); j++){
		for(int k=0; k < sizeof(arr2[j])/sizeof(arr2[j][0]); k++){
			printf("%d,", arr2[j][k]);
		}
		printf("\n");
	}

输出结果：

4、只初始化5个元素，自动将前4位作为一维数组的第一个元素，其他未初始化的默认为0

	int arr3[3][4]={
		1,6,8,9,4
	};

	for(int a=0; a< sizeof(arr3)/sizeof(arr3[0]); a++){
		for(int b=0; b < sizeof(arr3[a])/sizeof(arr3[a][0]); b++){
			printf("%d,", arr3[a][b]);
		}
		printf("\n");
	}

输出结果：

5、连续初始化12个值，自动4个一组作为一维数组的元素

	//连续初始化12个值，自动4个一组作为一维数组的元素
	int arr4[3][4]={
		2,4,7,1,
		6,8,2,4,
		-1,4,10,5
	};
	for(int c=0; c< sizeof(arr4)/sizeof(arr4[0]); c++){
		for(int d=0; d < sizeof(arr4[c])/sizeof(arr4[c][0]); d++){
			printf("%d,", arr4[c][d]);
		}
		printf("\n");
	}

输出结果：

6、定义二维的长度为4，不指定一维的长度，自动计算长度为2

	//定义二维的长度为4，不指定一维的长度，自动计算长度为2
	int arr5[][4]={
		{5},
		{10,3,-4}
	};
	for(int e=0; e< sizeof(arr5)/sizeof(arr5[0]); e++){
		for(int f=0; f < sizeof(arr5[e])/sizeof(arr5[e][0]); f++){
			printf("%d,", arr5[e][f]);
		}
		printf("\n");
	}

输出结果：

7、必须指定二维的长度，否则编译不通过

	//int arr6[2][]={ 4,8 };//这样是不对的，必须指定二维的长度
	//int arr6[2][]={	4,8 };//这样是不对的，必须指定二维的长度
	/*
	//这样是不对的，必须指定二维的长度
	int arr6[][]={
		{4,5},
		{5,6,7}
	};
	*/

全部代码：ArrayTest1.cpp

#include <stdio.h>

void test1(){
	int len = 5;
	//int arr[len];//这种用变量来制定数组长度，在C语言中是不允许的，编译不通过
	int arr[5];//这样声明数组，表示定义一个指针常量，没有指向任何int型数组，C语言不会给每个元素赋初始值0
	printf("%d\n", arr[0]);//由于没有给数组赋初始值，将输出一个不确定的数，输出：-858993460
	
	//int：-858993460（十六进制OXCCCCCCCC）（二进制11001100110011001100110011001100）
	//当一个未初始化赋值的时候(至少是vc 下未初始化的内存)默认是0xCCCCCCCC;，他在内存就默认保存为-858993460
	
	for(int i=0; i < sizeof(arr)/sizeof(arr[0]); i++){
		printf("第%d个元素值：%d，对应地址：%p\n", i,arr[i], &arr[i]);//每个元素值都是-858993460
	}
	printf("\n");

	int arr1[5] = {6};//只给第一个元素赋初始值，后面元素自动初始化为0
	for(int j=0; j < sizeof(arr1)/sizeof(arr1[0]); j++){
		printf("第%d个元素值：%d，对应地址：%p\n", j,arr1[j], &arr1[j]);
	}

	printf("\n");
	int arr2[5] = {4,2,-4,6,-10};//定义数组时每个元素都初始化

	for(int n=0; n < sizeof(arr2)/sizeof(arr2[0]); n++){
		printf("第%d个元素值：%d，对应地址：%p\n", n,arr2[n], &arr2[n]);
	}
	printf("\n");

	int arr3[] = {4,2,-4};//定义数组不指定长度，长度自动计算为3
	for(int m=0; m < sizeof(arr3)/sizeof(arr3[0]); m++){
		printf("第%d个元素值：%d，对应地址：%p\n", m,arr3[m], &arr3[m]);
	}
	printf("\n");
}

void test2(){
	int arr[3][4];//定义一个二维数组，一维数组长度为3，一维数组元素是一个长度为4个数组
	for(int i=0; i< sizeof(arr)/sizeof(arr[0]); i++){
		for(int j=0; j < sizeof(arr[i])/sizeof(arr[i][0]); j++){
			printf("%d,", arr[i][j]);//由于为初始化，输出-858993460
		}
		printf("\n");
	}

	//定义二维数组，每个元素都初始化
	int arr1[3][4]={
		{4,6,1,3},
		{20,30,3,4},
		{-1,5,5,8}
	};

	for(int m=0; m< sizeof(arr1)/sizeof(arr1[0]); m++){
		for(int n=0; n < sizeof(arr1[m])/sizeof(arr1[m][0]); n++){
			printf("%d,", arr1[m][n]);
		}
		printf("\n");
	}
	
	//定义二维数组，只初始化一维的部分元素，未初始化的默认为0
	int arr2[3][4] = {
		{3,6}
	};

	for(int j=0; j< sizeof(arr2)/sizeof(arr2[0]); j++){
		for(int k=0; k < sizeof(arr2[j])/sizeof(arr2[j][0]); k++){
			printf("%d,", arr2[j][k]);
		}
		printf("\n");
	}

	printf("\n");

	//只初始化5个元素，自动将前4位作为一维数组的第一个元素，其他为初始化的默认为0
	int arr3[3][4]={
		1,6,8,9,4
	};

	for(int a=0; a< sizeof(arr3)/sizeof(arr3[0]); a++){
		for(int b=0; b < sizeof(arr3[a])/sizeof(arr3[a][0]); b++){
			printf("%d,", arr3[a][b]);
		}
		printf("\n");
	}
	printf("\n");
	//连续初始化12个值，自动4个一组作为一维数组的元素
	int arr4[3][4]={
		2,4,7,1,
		6,8,2,4,
		-1,4,10,5
	};
	for(int c=0; c< sizeof(arr4)/sizeof(arr4[0]); c++){
		for(int d=0; d < sizeof(arr4[c])/sizeof(arr4[c][0]); d++){
			printf("%d,", arr4[c][d]);
		}
		printf("\n");
	}

	printf("\n");
	//定义二维的长度为4，不指定一维的长度，自动计算长度为2
	int arr5[][4]={
		{5},
		{10,3,-4}
	};
	for(int e=0; e< sizeof(arr5)/sizeof(arr5[0]); e++){
		for(int f=0; f < sizeof(arr5[e])/sizeof(arr5[e][0]); f++){
			printf("%d,", arr5[e][f]);
		}
		printf("\n");
	}

	printf("\n");
	
	//int arr6[2][]={ 4,8 };//这样是不对的，必须指定二维的长度
	//int arr6[][]={	4,8 };//这样是不对的，必须指定二维的长度
	/*
	//这样是不对的，必须指定二维的长度
	int arr6[][]={
		{4,5},
		{5,6,7}
	};
	*/
}

main.cpp

#include <stdio.h>

//声明其他源文件里的函数，即声明外部函数
//返回值 函数名(参数类型 形参名1,参数类型 形参名2);
void test1();

void test2();
int main(int argc, char argv[]){
	//调用外部函数
	test1();
	test2();

	return 0;
}