数组总结及其实例详解

一、一维数组
定义：类型名 数组名[数组大小] ;注：数组大小不可是变量，只可是数字或宏定义值
列：char arr1[5]={‘1’,’a’,’A’};
char arr3[]={“1aA”};//arr[]=”1aA”同于arr[]={“1aA”}

define N 5

int arr[10];
char arr[N];//此处arr[N]=arr[10]
sizeof(arr)/sizeof(arr[0]);//求数组大小，此法仅用于和数组定义在同一函数中，若以数组作为函数参数，则作为形参的函数中不可求数组大小（因为此时sizeof(arr)计算的是首元素所占字节，而不是数组总字节大小），因此数组作为参数时，应将数组大小一起传递。
注：一维数组名表示数组首地址
1、strlen();参数为数组地址，统计数组中传入的地址到’\0’之前的元素个数，不包含’\0’；数组中无’\0’，则返回一个随机值
2、一维数组中只能存放一个字符串，存放字符串时将其拆为多个字符存放在数组中
列：char arr3[5]=”1a\0A”;arr[0]=1;arr[1]=a,arr[2]=\0,
arr[3]=A,arr[4]=’\0’,arr[5]=null;
3、字符\0和\n打印出来为空格和换行而不是\0,\n

二、二维字符数组
1、二维数组相当于由多个一维数组组成
2、定义：
char arr[3][3]={{‘1’,’2’,’3’},{‘3’,’4’,’7’},{‘5’,’\0’,’1’}};
有3*3个元素。
二维数组大小计算：
sizeof(arr)/sizeof(arr[0][0]);//数组总大小.3*3/1=9，有3*3/1个元素，字符1个元素占1个字节
注：二维数组名代表数组首地址
1、&arr=&arr[0]=arr+0=&arr[0][0],表示0行0列元素地址
2、&arr[0][j]=arr[0]+j=arr+j=&arr[0][j]，0行j列元素地址
3、二维数组中，i行的地址与i行的第一个元素地址值相同，表示范围不同
即*（arr+i)=arr[i]//表示i行地址
sizeof(arr[0])=sizeof(*(arr+0))//第0行元素所占字节
4、字符数组存放字符（一维与二维相同），若无’\0’则用strlen()函数求出的数组大小为随机值，有’\0’则求的值为从传入递的地址到第一个’\0’之前的大小

三、二维字符串数组

定义：

char ch1[3][5]={"123","你h",{"anv"}};//前一个数3表式字符串个数，后一个数5表式每个字符串最大长度(字符个数-1)，包含'\0'

sizeof(ch1) 数组所占总字节大小

sizeof(ch1)/sizeof(ch1[0]) 计算数组可存多少字符串

strlen(ch1[i])计算第i个字符串的字符个数不含'\0'

ch1表式首地址

ch1[0] 表式第一个字符串地址

&ch1[i][j] 表式第i个字符串的第j个字符地址

sizeof(&ch1) 一个地址变量所占字节大小（4）

sizeof(ch1[i]) 一个字符串所定义字节大小 5

sizeof(&ch1[0]) 一个地址变量所占字节大小（4）

四、指针数组
定义：
char *arr2[]={“123as”};//指针数组不可省去{}
char *arr3[2]={{“\n1a”},{“123\043”}};
char *arr4[3][2]={{“12345”,”ABC”},{“abcd”},{“你好”}};//汉字可存 储在字符指针变量或字符指针数组中
注：
1、指针数组中使用strlen()计算字符串中字符个数时，会跳过’\0’，统计除’\0’的所有字符。非指针数组计算时统计’\0’之前字符
2、’\0和’\n’不可用字符方式输出打印，输出为换行和空格。注：若’\0’后有数字，则还可能输出其他字符
3、数组中的每个字符串都有 1个地址
4、指针数组arr[i],表示第i行的地址，即存放arr4[i][0]字符串的地址
5、  二维指针数组行地址相差 列数*4
6、指针数组arr[i][j]==*(&arr[i][j])表示字符串(arr[i][j])中的字符1arr[0][1])的地址
7、数组指针&arr[i][j]=*(arr+i)+j=arr[i]+j,表示字符串arr[i][j])的地址
注：指针数组的数组名计算的是数组中有多少个地址所占的字节，而不在是元素所占的地址
8、指针数组：sizeof(arr)计算的是所有地址所占字节，数组大小为几，则地址就有几个,
9、一维指针数组大小：sizeof(arr)/sizeof(arr[0]);sizeof(1[0])表示一
10、二维指针数组大小：sizeof(arr)/sizeof(arr[0][0]);sizeof(arr[0][0])为一个地址占4个字节

代码讲解：

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

int main()
{ 
 //一个汉字占4个字节
 char * ch="你好";
 char ch1[3][5]={"123","你h",{"anv"}};//前一个数3表式字符串个数，后一个数5表式每个字符串最大长度(字符个数-1)，包含'\0'
 int i=0;
 //sizeof(ch1)计算数组可存总字节数大小，
 printf("可存字符串个数：%d \n",sizeof(ch1)/sizeof(ch1[0]));//计算数组可存字符串多少
 printf("第1个字符串字符数：%d \n",strlen(ch1[0]));//strlen(ch1[i])计算第i个字符串的字符个数不含'\0'
 for(i=0;i<3;i++)//对二维数组初始化，（汉字串末尾无隐含'\0'，占1个字节）
 {
  printf("输入第%d个字符串：",i);
    scanf("%s",ch1[i]);
 }
 printf("\n********输出*********\n");
 for(i=0;i<sizeof(ch1)/sizeof(ch1[0]);i++)
    printf("%s\n",ch1[i]);//ch1[i]表式对第i个字符串输出
 //printf("%s \n",ch1[1][1]);//错误，ch1[i]即表式对第i个字符串输出
 printf("ch1[1][1]=%c \n",ch1[1][1]);//ch1[i][j]表式对第i个字符串中的第j个字符输出，汉字不在ASCLL码中，不可输出汉字，
 printf("ch=%s\n",ch);

 printf("%p \n",ch1);//ch1表式首地址
 printf("%p \n",&ch1);//表式首地址
 printf("%p \n",ch1[0]);//表式第一个字符串地址
 printf("%p \n",&ch1[0][0]);//表式第一个字符串的第一个字符地址
 printf("%p \n",&ch1[0][1]);//表式第一个字符串的第二个字符地址
 printf("%p \n",ch1[1]);//表式第二个字符串地址

 printf("可存字符串个数：%d \n",sizeof(ch1));//数组所占总字节大小 15
 printf("可存字符串个数：%d \n",sizeof(&ch1));//一个地址变量所占字节大小（4）
 printf("可存字符串个数：%d \n",sizeof(ch1[0]));//一个字符串所定义字节大小 5
 printf("可存字符串个数：%d \n",sizeof(&ch1[0]));//一个地址变量所占字节大小（4）
 printf("可存字符串个数：%d \n",sizeof(ch1[1]));//一个字符串所定义字节大小 5
 printf("可存字符串个数：%d \n",sizeof(ch1[0][0]));//一个字符所占字节 1
 printf("可存字符串个数：%d \n",sizeof(&ch1[0][0]));//一个地址变量所占字节大小（4）
 printf("可存字符串个数：%d \n",sizeof(ch1[0][1]));//一个字符所占字节 1
 printf("可存字符串个数：%d \n",sizeof(ch1[2]));//字符串ch1[2]所定义字节大小 5

 system("pause");
 return 0;
}

四、代码实例详解：

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

void Tchar_arr(void);//二维数组存放字符
void Ochar_arr(void);//一维数组
void Pchar_arr(void);//指针数组
int main()
{
 printf("\n****************一维数组********************\n");
 Ochar_arr();//一维数组
 printf("\n****************二维数组********************\n");
 Tchar_arr();//二维数组
 printf("\n****************指针数组**********************\n");
 Pchar_arr();//指针数组
 system("pause");
 return 0;
}

void Ochar_arr(void)//一维数组
{
 //strlen();参数为数组地址，统计数组中传入的地址到'\0'之前的元素个数，不包含'\0'；数组中无'\0'，则返回一个随机值
 //一维数组中只能存放一个字符串，存放字符串时将其拆为多个字符存放在数组中
 //列：char arr3[5]="1a\0A";arr[0]=1;arr[1]=a,arr[2]=\0,arr[3]=A,arr[4]='\0',arr[5]=null;
 //字符\0和\n打印出来为空格和换行而不是\0,\n
 char arr[]={'1','a','A'};
 char arr1[]={'1','a','\0','A'};
 char arr2[]="1aA";//隐含'\0'占一个字符数组大小为4，即arr[4]={"1aA"};而不是arr[3]={"1aA"}
 char arr3[]={"1a\0A"};//arr[]="1aA"同于arr[]={"1a\0A"}
 //数组可用指针访问
 char *parr;
 parr=arr;//指向首地址，即&arr[0];
 
 printf("\nchar arr[]={'1','a','A'}\n");
 printf("\nchar *parr=arr\n");
 printf("arr[0]=%c\n",arr[0]);
 printf("*parr=%c\n",*parr);
 printf("parr=%p\n",parr);
 parr++;//指向下一个地址，即&arr[1];
 printf("\nparr++\n");
 printf("arr[0]=%c\n",arr[1]);
 printf("*parr=%c\n",*parr);
 printf("parr=%p\n",parr);

 printf("\n首地址:%p\n",arr);//首地址，即第一个元素地址
 printf("第一个元素地址:%p\n",&arr[0]);//第一个元素地址
 printf("第二个元素地址:%p\n",arr+1);//第二个元素地址

 printf("\nchar arr[]={'1','a','A'}\n");
 printf("arr大小%d\n",sizeof(arr)/sizeof(arr[0]));//3,计算数组大小
 printf("strlen(arr)=%d\n",strlen(arr));//随机值
 printf("sizeof(&arr)=%d\n",sizeof(&arr));//4,第一个元素地址所占字节
 //printf("strlen(&arr)=%d\n",strlen(&arr));//随机值,错误表达式
 printf("sizeof(&arr[0])=%d\n",sizeof(&arr[0]));//4，第一个元素地址所占字节
 printf("strlen(&arr[0])=%d\n",strlen(&arr[0]));//随机值

 printf("\nchar arr1[]={'1','a','\\0','A'}\n");//  \\0 表示打印 \0
 printf("arr1大小%d\n",sizeof(arr1)/sizeof(arr1[0]));//4,计算数组大小
 printf("strlen(arr)=%d\n",strlen(arr1));//3,计算数组中元素到'\0'字符之前个数不包含'\0'

 printf("\nchar arr2[]=\"1aA\"\n");
 printf("arr2大小%d\n",sizeof(arr2)/sizeof(arr2[0]));//4,计算数组大小
 printf("strlen(arr2)=%d\n",strlen(arr2));//3,计算数组中元素到'\0'字符之前个数不包含'\0'
 printf("strlen(&arr2[0])=%d\n",strlen(&arr2[1]));//2随机值
 
 printf("\nchar arr3[]={\"1a\\0A\"}\n");//  \" 表示打印"
 printf("arr3[0]=%c\n",arr3[0]);
 printf("arr3[0]=%c\n",arr3[1]);
 printf("arr3[2]=%c\n",arr3[2]);//打印空格
 printf("arr3[3]=%c\n",arr3[3]);
 printf("arr3大小%d\n",sizeof(arr3)/sizeof(arr3[0]));//4,计算数组大小
 printf("strlen(arr3)=%d\n",strlen(arr3));//2，计算数组中元素到'\0'字符之前个数不包含'\0'
}

void Tchar_arr(void)
{
 char arr[3][3]={{'1','2','3'},{'3','4','7'},{'5','\0','1'}};
 //char arr1[2][3]={{"123","abc"},{"ABC"}};//错误表达式，不可直接用二维数组存放字符串，应用指针数组

 printf("char arr[3][3]={{'1','2','3'},{'3','4','7'},{'5','\\0','1'}}\n");
 printf("\nsizeof(arr)=%d\n",sizeof(arr));//数组总大小.3*3/1=9，有3*3个元素，字符1个元素占1个字节
 
 //&arr=&arr[0]=arr+0=&arr[0][0],表示0行0列元素地址
 printf("\n&arr=%d\n",&arr);//首地址，0行地址第一个元素地址
 printf("sizeof(&arr)=%d\n",sizeof(&arr));//4，计算的是地址所占的大小，一个地址占4个字节

 printf("\narr+0=%d\n",arr+0);//0行第一个元素地址,即arr[0][0]地址
 printf("sizeof(arr+0)=%d\n",sizeof(arr+0));//4，0行0列元素地址所占字节所占的大小，一个地址占4个字节
 printf("&arr[0]=%d\n",&arr[0]);//0行第一个元素地址，即arr[0][0]地址
 printf("sizeof(&arr[0])=%d\n",sizeof(&arr[0]));//4，0行0列元素地址所占字节所占的大小，一个地址占4个字节
 //&arr[0][j]=arr[0]+j=arr+j=&arr[0][j]，0行j列元素地址
 printf("\n&arr[0][1]=%d\n",&arr[0][1]);//0行1列元素地址，即arr[0][1]地址
 printf("sizeof(&arr[0][1])%d\n",sizeof(&arr[0][1]));//4，0行1列元素所占字节所占的大小，一个地址占4个字节
    printf("arr[0]+1=%d\n",arr[0]+1);//0行1列地址，，即arr[0][1]地址
 printf("sizeof(arr[0]+1)%d\n",sizeof(arr[0]+1));//4，0行1列元素地址所占字节所占的大小，一个地址占4个字节
 //注：二维数组中，i行的地址与i行的第一个元素地址值相同，表示范围不同
 //即*（arr+i)=arr[i]//表示i行地址
 //sizeof(arr[0])=sizeof(*(arr+0))//第0行元素所占字节
 printf("\narr[0]=%d\n",arr[0]);//0行地址
 printf("sizeof(arr[0])=%d\n",sizeof(arr[0]));//3，第0行元素所占字节
 printf("*(arr+0)=%d\n",*(arr+0));//0行地址
 printf("sizeof(*(arr+0))=%d\n",sizeof(*(arr+0)));//3，第0行元素所占字节

 printf("\narr[1]=%d\n",arr[1]);//1行地址
    printf("arr+1=%d\n",arr+1);//1行第一个元素地址

 printf("\n&arr[1][1]=%d\n",&arr[1][1]);//1行1列元素地址

 printf("\n*********************************\n");
 //注：字符数组存放字符（一维与二维相同），若无'\0'则用strlen()函数求出的数组大小为随机值，有'\0'则求的值为从传入递的地址到第一个'\0'之前的大小
 //char arr[3][3]={{'1','2','3'},{'3','5','6'},{'5','\0'}};
 //数组该地址起到'\0'之前的大小
 printf("strlen(arr[0])=%d\n",strlen(arr[0]));//7
 printf("strlen(*(arr+0))=%d\n",strlen(*(arr+0)));//7，arr+1表示0行地址
 printf("strlen(arr[1]+0)=%d\n",strlen(arr[1]+0));//4，arr[1]+0表示1行0列地址
 printf("strlen(&arr[1][1])=%d\n",strlen(&arr[1][1]));//3，&arr[1][1]表示1行1列地址
 printf("strlen(arr[1])=%d\n",strlen(arr[1]));//4，arr[1]表示1行地址
 printf("strlen(*(arr+1))=%d\n",strlen(*(arr+1)));//4，arr[1]表示1行地址
 printf("strlen(&arr[2][0])=%d\n",strlen(&arr[2][0]));//1,
 printf("strlen(*(arr+2))=%d\n",strlen(*(arr+2)));//1，
 
 printf("\n**********************************************\n");
}

void Pchar_arr(void)
{
   char arr1[]="123a\0s";//可省去{}
   char *arr2[]={"123as"};//指针数组不可省去{}
   char *arr3[2]={{"\n1a"},{"123\043"}};
   char *arr4[3][2]={{"12345","ABC"},{"abcd"},{"你好"}};//汉字应存储在字符指针变量或字符指针数组中
  
   //指针数组中使用strlen()计算字符串中字符个数时，会跳过'\0'，统计除'\0'的所有字符。非指针数组计算时统计'\0'之前的字符
   // '\0和'\n'不可用字符方式输出打印，输出为换行和空格，注：若'\0'后有数字，则还可能输出其他字符
   //数组中的每个字符串都为一个地址
   //数组指针arr[i],表示第i行的地址，即存放arr4[i][0]字符串的地址
   //二维数组行地址相差  列数*4
   //数组指针arr[i][j]==*(&arr[i][j])表示字符串(arr[i][j])中的字符1arr[0][1])的地址
   //数组指针&arr[i][j]=*(arr+i)+j=arr[i]+j,表示字符串arr[i][j])的地址
   //注：数组指针的数组名计算的是数组中有多少个地址所占的字节，而不在是元素所占的地址
   //数组指针：sizeof(arr)计算的是所有地址所占字节，数组大小为几，则地址就有几个,
   //一维数组指针大小：sizeof(arr)/sizeof(arr[0]);sizeof(arr1[0])表示一个地址所占的字节（4）
   //二维指针数组大小：sizeof(arr)/sizeof(arr[0][0]);sizeof(arr[0][0])为一个地址占4个字节
 
   printf("\n******************************************\n");
   printf("\nchar arr1[]=\"123a\\0s\"\n");//  \\0表示打印\0
   //printf("arr1[0]=%s\n",arr1[0]);//错误表达式 不可用 %s 输出字符
   printf("arr1[0]=%c\n",arr1[0]);//打印第一个字符
   printf("arr1=%d\n",sizeof(arr1));//计算数组中所有元素所占大小大小，包含隐含'\0'
   printf("strlen(arr1)=%d\n",strlen(arr1));//arr[0]字符串中'\0'之前的字符个数
   printf("arr1[4]=%c\n",arr1[4]);//打印'\0'结果为空格

   printf("\n******************************************\n");
   printf("\nchar *arr2[]={\"123as\"}\n");
   //printf("arr2[0]=%s\n",arr2[0]);//错误表达式
   //printf("*arr2[0]=%s\n",*arr2[0]);//错误表达式
   printf("*arr2[0]=%c\n",*arr2[0]);//第一个字符值
   printf("arr2[0]=%p\n",arr2[0]);//打印第一个字符串地址
   printf("sizeof(arr2)=%d\n",sizeof(arr2));//计算的是所有地址所占字节（4），数组大小为几就有几个地址
   printf("sizeof(arr2[0])=%d\n",sizeof(arr2[0]));//计算的是1个地址所占字节（4）
   printf("sizeof(&arr2)=%d\n",sizeof(&arr2));//计算的是1个地址所占字节（4）
   printf("sizeof(&arr2[0])=%d\n",sizeof(&arr2[0]));//计算的是1个地址所占字节（4）
   printf("sizeof(&(*arr2[0]))=%d\n",sizeof(&(*arr2[0])));//计算的是1个地址所占字节（4）
   printf("strlen(arr2[0])=%d\n",strlen(arr2[0]));//字符串中字符个数

   printf("\n******************************************\n");
   printf("\nchar *arr3[2]={{\"\\n1a\"},{\"123\\043\"}}\n");
   //printf("arr3[0]=%s\n",arr3[0]);//错误表达式
   printf("*(&arr3[0])=%s\n",*(&arr3[0]));//打印第二个字符串，指针可打印字符'\0'
   printf("*(&arr3[1])=%s\n",*(&arr3[1]));
   printf("arr3[0]=%p\n",arr3[0]);//打印第一个字符串地址
   printf("arr3=%d\n",sizeof(arr3));//8,计算数组中所有地址所占字节
   printf("%d\n",strlen(arr3[0]));//arr[0]字符串的字符个数，字符串结尾无\0
   printf("%d\n",strlen(arr3[1]));//arr[1]字符串的字符个数，包含字符串中原有的\0

   printf("sizeof(arr3)=%d\n",sizeof(arr3));//计算的是所有地址所占字节，数组大小为几就有几个地址
   printf("sizeof(arr3[0])=%d\n",sizeof(arr3[0]));//计算的是1个地址所占字节（4）
   printf("sizeof(&arr3)=%d\n",sizeof(&arr3));//计算的是1个地址所占字节（4）
   printf("sizeof(&arr3[0])=%d\n",sizeof(&arr3[0]));//计算的是1个地址所占字节（4）
   printf("sizeof(&(*arr3[0]))=%d\n",sizeof(&(*arr3[0])));//计算的是1个地址所占字节（4）

   printf("\n************字符串输出**************\n");
   printf("\n char *arr4[3][2]={{\"12345\",\"ABC\"},{\"abcd\"},{\"你好\"}}\n");
   printf("*(&arr4[0][0])=%s\n",*(&arr4[0][0]));//打印第一个(arr[0][0])字符串
   printf("*arr4[0]+0=%s\n",*(arr4[0]+0));//打印第一个(arr[0][0])字符串
   printf("*arr4[0]+1=%s\n",*(arr4[0]+1));//打印(arr[0][1])字符串
   printf("*(&arr4[1][0])=%s\n",*(&arr4[1][0]));//打印(arr[1][0])字符串
   printf("*arr4[2]=%s\n",*(arr4[2]));//打印(arr[2][0])字符串

   printf("\n*************字符输出****************\n");
   //printf("*arr4[0][0]=%s\n",*arr4[0][0]);//错误表达式,不可用 %s 输出
   printf("*arr4[0][0]=%c\n",*arr4[0][0]);//打印第一个字符串(arr[0][0])中的第一个字符1
   printf("*arr4[0][0]=%c\n",*arr4[0][1]);//打印第一个字符串(arr[0][1])中的第一个字符1
   printf("*arr4[0][0]=%c\n",*arr4[2][0]);//打印第一个字符串(arr[2][0])中的第一个字符1(由于汉字不是ASCLL字符,所以打印乱码）

   printf("\n******************************************\n");
   //printf("arr4[0]=%s\n",arr4[0]);//错误表达式
   printf("arr4[0]=%p\n",arr4[0]);//打印第0行地址，即存放arr4[0][0]字符串的地址
   printf("arr4[1]=%p\n",arr4[1]);//打印第行1地址，与相邻行地址差  列数*4
   printf("arr4[0][0]=%p\n",arr4[0][0]);//第一个字符串(arr[0][0])中的字符1的地址
   printf("&(*arr4[0][0])=%p\n",&(*arr4[0][0]));//第一个字符串中的字符1的地址
   printf("arr4[0][1]=%p\n",arr4[0][1]);//第二个字符串中的字符1arr[0][1])的地址
   printf("&arr4[0][0]=%p\n",&arr4[0][0]);//第一个字符串(&(*arr[0][0]))的地址
   printf("*(arr4+0)=%p\n",*(arr4+0));//第一个字符串(&(*arr[0][0]))的地址
   printf("*(arr4+0)+0=%p\n",*(arr4+0)+0);//第一个字符串(&(*arr[0][0]))的地址
   printf("&arr4[0][1]=%p\n",&arr4[0][1]);//第二个字符串(&(*arr[0][1]))的地址
   printf("*(arr4+0)+1=%p\n",*(arr4+0)+1);//第一个字符串(&(*arr[0][1]))的地址
   printf("arr4[0]+1=%p\n",arr4[0]+1);//第一个字符串(&(*arr[0][1]))的地址
   printf("&arr4[1][0]=%p\n",&arr4[1][0]);//字符串(*(&arr[1][0]))的地址
   printf("arr4[1]+0=%p\n",arr4[1]+0);//第一个字符串(&(*arr[0][0]))的地址
   printf("*(arr4+0)+2=%p\n",*(arr4+0)+2);//第二个字符串(&(*arr[1][0]))的地址

   printf("sizeof(arr4[0])=%d\n",sizeof(arr4[0]));//8,arr4[0]表示行地址，一行地址共占8个字节，
   printf("sizeof(arr4[0][0])=%d\n",sizeof(arr4[0][0]));//字符串(arr[0][0])中的字符1的地址，一个元素地址占4个字节
   printf("sizeof(arr4)=%d\n",sizeof(arr4));//24,地址共占24个字节
   printf("数组大小%d\n",sizeof(arr4)/sizeof(arr4[0])[0]);//  6=24/4  (地址共占24个字节，一个地址占4个字节）
  
   printf("strlen(arr4[0])=%d\n",strlen(arr4[0][0]));//字符串a[0][0]的长度
   printf("\n******************************************\n");
}