数组

一维数组：

1. 相同数据类型的集合，内存都是连续的，若不初始化数组，则默认值为随机值；数组整体赋值仅在初始化时有一次机会（数组和结构体都是聚合类型），且不能用赋值符将一个数组赋给另一个数组；若数组局部初始化，则其他数据默认值为0，在运行程序前编译时就确定内存大小，在运行时最大分配内存为1M/2M，数组地址由低地址向高地址（由栈顶指向栈底），存放局部变量分配先在高地址

#include <stdio.h>
#define count_ 10
int main()
{
	int const count1 = 10;
	int arr[count1] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };  //[]内不允许为变量，在编译时确定内存大小
	int arr_[count2] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };  
	int *p = arr + 1;  //访问arr[1]的地址，也可以写为 * (arr+1)
	printf("%d\n", p[2]);  //相当于*(p+2)，也就是arr[3]
	printf("%d\n", p + 6);  //输出地址，表示arr+9或&arr[9]
	printf("%d\n", *p + 6);  //相当于arr[1]+6，*(p+6)才是arr[9]
	printf("%d\n", &p);  //输出地址，合法但编译器不知道该读取arr数组的哪个位置
	printf("%d\n", p[-1]);  //合法，它访问的是arr[0],相当于arr[1]左移了一位
	printf("%d\n", p[9]);  //不合法，因为数组长度为10，p[9]指向arr[10],越过了数组右边界
	printf("%d\n", 2[arr]);  //合法相当于*(2+(arr)),去掉里面的括号后，相当于*（arr+2）;
	return 0;
}

2. 数组长度

#include<stdio.h>
void test(int arr[], char  ch[])
{
	int len1 = sizeof(arr) / sizeof(arr[0]);
	int len2 = sizeof(ch) / sizeof(ch[0]);
	printf("子函数测量arr长度:%d\n", sizeof(arr));  //测量接收的指针长度，4
	printf("子函数len1:%d\n", len1);  //指针长度除以数组首元素长度，1
	printf("子函数测量ch长度:%d\n", sizeof(ch));  //测量接收的指针长度,4
	printf("子函数len2:%d\n", len2);  //指针长度除以数组首元素长度，4
}
int main()
{
	int arr[10] = { 0 };
	char ch[10] = { 0 };
	int len1 = sizeof(arr) / sizeof(arr[0]);
	int len2 = sizeof(arr) / sizeof(arr[0]);
	printf("主函数测量arr长度%d\n", len1);  //实际长度，10
	printf("主函数测量ch长度:%d\n", len2);  //实际长度，10
	test(arr,ch);
	return 0;
}

3. 字符串长度

#include <stdio.h>
#include <string.h>
int main()
{
	char a1[100] = "abcdef";  //100就是数组长度
	char a2[] = "abcdef";  //sizeof计算数组长度包括\0，strlen遇到\0停止计算，计算字符串长度
	char *a3 = "abcdef";//指向首地址，sizeof输出指针长度为4
	char a4[100] = "abcdef\0xyz";
	char a5[] = "abcdef\0xyz";  //sizeof计算数组长度包括\0
	char *a6 = "abcdef\0xyz";
	char a7[100] = "abcdef\n\0xyz";  //\n算一个字符
	char a8[] = "abcdef\n\0xyz";
	char *a9 = "abcdef\n\0xyz";
	printf("%d,%d\n", sizeof(a1), strlen(a1));  //100,6
	printf("%d,%d\n", sizeof(a2), strlen(a2));  //7,6
	printf("%d,%d\n", sizeof(a3), strlen(a3));  //4,6
	printf("%d,%d\n", sizeof(a4), strlen(a4));  //100,6
	printf("%d,%d\n", sizeof(a5), strlen(a5));  //11,6
	printf("%d,%d\n", sizeof(a6), strlen(a6));  //4,6
	printf("%d,%d\n", sizeof(a7), strlen(a7));  //100,7
	printf("%d,%d\n", sizeof(a8), strlen(a8));  //12,7
	printf("%d,%d\n", sizeof(a9), strlen(a9));  //4,7
	return 0;
}

二维数组

1. 二维数组存储是连续的，是特殊的一维数组，创建时可以只写列数，系统会根据数据自动生成行数
2. 二维数组的使用也是通过下标的方式。
3. 数组名：代表数组的首地址，但此时首地址是一个一维数组，数组首元素是一堆数组的地址

#include <stdio.h>
void show(int(*p)[3], int x)//传址，传参传的是数组指针
{	
    //数组不需要返回值，传址
}
int main()
{
    //数组的创建与初始化
	int i,j;
	int a1[2][3];  //二行三列
	int a1[2][3] = { 0 };  //二维数组的内存是连续的,特殊的一维数组
	int a3[3][2] = { 1, 2, 3, 4, 5, 6 };  //不可以同时不写行数和列数
	int a4[3][3] = { {1,2} , {4,5,6}, {8,9} };
	int a5[][3] = {1,2};  //可以只写列数，自动分配行数
	int(*p1)[3] = a1;  //二维数组名代表数组的首地址，此时首地址是一个一维数组，数组首元素是一堆数组的地址
	int(*p2)[3] = a4;  //数组指针：指向数组的指针,一维数组的地址
	int a6[3] = { 1, 2, 3 };
	int *p3 = a6;  //指向首地址
	int(*p4)[3] = &a6;  //指向数组
	show(a4, 3);
	return 0;
}

4. 练习二维数组初始化与传参：

#include <stdio.h>
void show1(int arr[][5], int row, int col)  //赋值上三角
{
	int i, j, temp = 1;
	for (i = 0; i < row; i++)
	{
		for (j = i; j < col; j++)
		{
			arr[i][j] = temp++;
		}
	}
}
void show2(int arr[][5], int row, int col)  //赋值下三角
{
	int i, j, temp = 1;
	for (i = 0; i < row; i++)
	{
		for (j = i; j < col; j++)
		{
			arr[j][i] = temp++;
		}
	}
}
void show3(int arr[][5], int row, int col)  //输出矩阵
{
	int i = 0, j = 0;
	for (i = 0; i < row; i++)
	{
		for (j = 0; j < col; j++)
		{
			printf("%-2d  ", arr[i][j]);
		}
		printf("\n");
	}
}
int main()
{
	int arr1[5][5] = { 0 };
	int arr2[5][5] = { 0 };
	int arr3[5][5] = { 0 };
	show1(arr1, 5, 5);
	show3(arr1, 5, 5);
	printf("\n");
	show2(arr2, 5, 5);
	show3(arr2, 5, 5);
	printf("\n");
	show1(arr1, 5, 5);
	show2(arr3, 5, 5);
	show3(arr3, 5, 5);
	return 0;
}

输出结果为：