二维数组元素指针引用
1.定义

2.数组指针和指针数组的区别

1.二维数组可以理解为是一个一维数组，不过每个数组元素又是一个一维数组

int a[2][3]={{1,2,3},{4,5,6}};

可以理解为，二维数组只有两个元素，即a[0]和a[1]，只不过元素类型为一维数组

指向二维数组的指针（行指针）

格式：类型  (*指针名) [N]

N为数组的第二维长度
2.二维数组指针与指针型数组的区别
int a[][3] = { {1,2,3},{4,5,6} };
int *p0[3] = a;    //错误，将一个二维数组赋给指针型数组

int(*p1)[3] = a;   //正确

数组指针（也称行指针）

定义 int (*p)[n];

()优先级高，首先说明p是一个指针，指向一个整型的一维数组，这个一维数组的长度是n，也可以说是p的步长。也就是说执行p+1时，p要跨过n个整型数据的长度。
如要将**二维数组**赋给一指针，应这样赋值：
int a[3][4];
int (*p)[4]; //该语句是定义一个数组指针，指向含4个元素的一维数组。
 p=a;        //将该二维数组的首地址赋给p，也就是a[0]或&a[0][0]
 p++;       //该语句执行过后，也就是p=p+1;p跨过行a[0][]指向了行a[1][  ]

比如要表示数组中i行j列一个元素：
*(p[i]+j)、*(*(p+i)+j)、(*(p+i))[j]、p[i][j]

优先级：()>[]>*

出处：

https://www.cnblogs.com/hongcha717/archive/2010/10/24/1859780.html
3.实现一个3*4阶矩阵转置 指针为形参
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<stdlib.h>
//定义一个3行4列的二维数组arr。
//定义一个函数func()完成矩阵转置，以数组指针作为参数。
//在func()函数内部，使用for循环完成矩阵转置
void func(int(*pa)[4], int(*pb)[3], int x, int y)
{
    int i, j;
    /*-------------------------begin------------------*/
    for(i=0;i<x;i++)
       for(j=0;j<y;j++){      	
       	 *(pb[j]+i)=*(pa[i]+j);
       	 // *(*(pb+j)+i)=*(*(pa+i)+j);
       	 // pb[j][i]=pa[i][j];
       	 // (*(pb+j))[i]=(*(pa+i))[j];
	   }
    /*--------------------------end-------------------*/
    printf("转置：\n");
    for (i = 0; i < y; i++)
    {
        for (j = 0; j < x; j++)
        {
            printf("%d\t", pb[i][j]);
        }
        printf("\n");
    }
}
int main()
{
    int i, j;
    int arr[3][4], brr[4][3];
    printf("输入二维数组的元素：\n");
    for (i = 0; i < 3; i++)
    {
        for (j = 0; j < 4; j++)
        {
            scanf("%d", &arr[i][j]);
        }
    }
    func(arr,brr,3,4);
    return 0;
}






另有:
数组元素访问 方法总结

三维数组可以看做二位数组的元素为一位数组的情况
给出一个三维数组char a[2][2][3]={{{1,6,3},{5,4,15}},{{3,5,33},{23,12,7}}};
怎么顺序地引用其中的每一个元素呢？

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

int main()
{
    char a[2][2][3]={{{1,6,3},{5,4,15}},{{3,5,33},{23,12,7}}};
    int i;
    for(i=0;i<12;i++)
    printf("%d ",a[i/6][(i/3)%2][i%3]);
    return 0;
}

C语言总结
第七章、数组
一维数组
一维数组的定义
一维数组的引用
一维数组的初始化
程序举例
二维数组及多维数组
二维数组的定义
二维数组元素的引用
二维数组元素的初始化
程序举例
字符数组和字符串
字符数组
字符串

第七章、数组
数组是构造数据类型之一

数组： 有序数据的集合,用数组名标识
元素： 属同一数据类型,用数组名和下标确定

一维数组
一维数组的定义
定义方式：



例： int a[6]


一维数组的引用
1、数组必须先定义，后使用。

2、只能逐个引用数组元素，不能一次引用整个数组。

3、数组元素表示形式： 数组名[下标] ,下标可以是常量或整型表达式

 。
一维数组的初始化
初始化方式：


说明：

1、数组不初始化，其元素值为随机数。

2、对static数组元素不赋初值，系统会自动赋以0值。



3、只给部分数组元素赋初值。



4、当全部数组元素赋初值时，可不指定数组长度。


程序举例
例1： 读10个整数存入数组，找出其中最大值和最小值


/*示例1*/
#include <stdio.h>
#define SIZE 10
main()
{   int x[SIZE],i,max,min;
    printf("Enter 10 integers:\n");
    for(i=0;i<SIZE;i++)
    {   printf("%d:",i+1);
	scanf("%d",&x[i]);
    }
    max=min=x[0];
    for(i=1;i<SIZE;i++)
    {  if(max<x[i])  max=x[i];
       if(min>x[i])  min=x[i];
    }
    printf("Maximum value is %d\n",max);
    printf("Minimum value is %d\n",min);
}

例2： 用数组求Fibonacci数列前20个数


/*示例2*/
#include <stdio.h>
main()
{   int i;
     int f[20]={1,1};
    for(i=2;i<20;i++)
       f[i]=f[i-2]+f[i-1];
    for(i=0;i<20;i++)
    {   if(i%5==0)  printf("\n");
         printf("%12d",f[i]);
    }
}

例3： 用冒泡法对10个数排序




/*示例3*/
#include <stdio.h>
main()
{   int a[11],i,j,t;
    printf("Input 10 numbers:\n");
    for(i=1;i<11;i++)
       scanf("%d",&a[i]);
    printf("\n");
    for(j=1;j<=9;j++)
       for(i=1;i<=10-j;i++)
          if(a[i]>a[i+1])
         {t=a[i]; a[i]=a[i+1]; a[i+1]=t;}
    printf("The sorted numbers:\n");
    for(i=1;i<11;i++)
	printf("%d ",a[i]);
}

例4： 用简单选择法对10个数排序


 /*示例4*/
#include <stdio.h>  
main()
{   int a[11],i,j,k,x;
    printf("Input 10 numbers:\n");
    for(i=1;i<11;i++)
       scanf("%d",&a[i]);
    printf("\n");
   for(i=1;i<10;i++)
   {  k=i;
      for(j=i+1;j<=10;j++)
            if(a[j]<a[k])  k=j;
      if(i!=k)
      {  x=a[i]; a[i]=a[k]; a[k]=x;}
   }
    printf("The sorted numbers:\n");
    for(i=1;i<11;i++)
	printf("%d ",a[i]);
}

二维数组及多维数组
二维数组的定义
定义方式：　





数组元素的存放顺序

1、原因： 内存是一维的

2、二维数组： 按行序优先

3、多维数组： 最右下标变化最快


数组a[m][n]，m行n列，共m*n个元素


这些元素占用m*n个单元，每个单元的大小取决于

元素的类型。
任意元素a[i][j]在数组中的位置计算公式为：
i×n＋j      （从0开始）
a——数组的起始地址；a[0]——0行0列元素的地址。
二维数组元素的引用
形式：  数组名[下标][下标]
二维数组元素的初始化
1、分行初始化

2、按元素排列顺序初始化
程序举例
例1：将二维数组行列元素互换，存到另一个数组中


/*示例1*/
#include <stdio.h>
main()
{   int a[2][3]={{1,2,3},{4,5,6}};
     int b[3][2],i,j;
    printf("array a:\n");
    for(i=0;i<=1;i++)
    {   for(j=0;j<=2;j++)
	{   printf("%5d",a[i][j]);
	    b[j][i]=a[i][j];
	}
	printf("\n");
    }    
    printf("array b:\n");
    for(i=0;i<=2;i++)
    {   for(j=0;j<=1;j++)
	   printf("%5d",b[i][j]);
         printf("\n");
    }
}

例2：求二维数组中最大元素值及其行列号


/*示例2*/
#include <stdio.h>
main()
{  int a[3][4]={{1,2,3,4},
                        {9,8,7,6},
                        {-10,10,-5,2}};
    int i,j,row=0,colum=0,max;
    max=a[0][0];
    for(i=0;i<=2;i++)
       for(j=0;j<=3;j++)
           if(a[i][j]>max)
	  {  max=a[i][j];
	     row=i;
	     colum=j;
	  }
    printf("max=%d,row=%d,\colum=%d\n",max,row,colum);
}

例3：分别求n阶方阵两条对角线上的元素之和
/*示例3*/
#define N 3
main()
{   int i,j,a[N][N];
int sum1=0,sum2=0;
for(i=0;i<N;i++)
  for(j=0;j<N;j++)
    scanf(“%d”,&a[i][j]);
for(i=0;i<N;i++)
  for(j=0;j<N;j++)
    if(i==j) sum1+=a[i][j];
for(i=0;i<N;i++)
  for(j=N-1;j>=0;j--)
    if((i+j)==N-1) sum2+=a[i][j];
printf(“sum1=%d,sum2=%d\n”,sum1,sum2);
}

字符数组和字符串
字符数组
定义 ： 每个元素存一个字符，主要用来对字符串操作。

字符数组的初始化：
1、逐个字符赋值

2、用字符串常量
字符数组的引用：







字符串
字符串及其结束标志
（1）、无字符串变量，用字符数组处理字符串。

（2）、字符串结束标志：‘\0’。


字符串的输入输出

输入:

用scanf函数

（1）.输入单个字符：％c  需用循环语句

（2）.输入字符串：%s  scanf(“%s”,str);
用gets函数：gets(str);

输出:

用printf函数

（1）.输出单个字符：％c  需用循环语句

（2）.输出字符串：%s  printf(“%s”,str);
用puts函数：puts(str);


常用的字符串处理函数： 加粗样式包含在头文件   string.h
字符串输出函数puts
格式： puts(字符数组)

功能： 向显示器输出字符串（输出完，换行）

说明： 字符数组必须以‘\0’结束
字符串输入函数gets
格式： gets(字符数组)

功能： 从键盘输入一以回车结束的字符串放入字符数组中，并自动加‘\0’

说明： 输入串长度应小于字符数组维数
字符串连接函数strcat
格式： strcat(字符数组1,字符数组2)

功能： 把字符数组2连到字符数组1后面

返值： 返回字符数组1的首地址

说明：

1、字符数组1必须足够大

2、连接前,两串均以‘\0’结束;连接后,串1的‘\0’取消, 新串最后加‘\0’
字符串拷贝函数strcpy
格式： strcpy(字符数组1,字符串2)

功能： 将字符串2，拷贝到字符数组1中去

返值： 返回字符数组1的首地址

说明：

1、字符数组1必须足够大

2、拷贝时‘\0’一同拷贝

3、不能使用赋值语句为一个字符数组赋值


字符串比较函数strcmp
格式： strcmp(字符串1,字符串2)

功能： 比较两个字符串

比较规则： 对两串从左向右逐个字符比较（ASCII码），直到遇到不同字符或‘\0’为止

返值： 返回int型整数，

a. 若字符串1< 字符串2， 返回负整数

b. 若字符串1> 字符串2， 返回正整数

c. 若字符串1== 字符串2， 返回零

说明： 字符串比较不能用“==”,必须用strcmp
字符串比较函数strcmp
字符串长度函数strlen

格式：strlen(字符数组)

功能：计算字符串长度

返值：返回字符串实际长度，不包括‘\0’在内

前面我们已经学习了指针，如果指针存储了某个变量的地址，我们就可以说指针指向这个变量。数组及其数组元素都占有存储空间，都有自己的地址，因此指针变量可以指向整个数组，也可以指向数组元素。



一、用指针指向一维数组的元素


 1 // 定义一个int类型的数组
 2 int a[2];
 3 
 4 // 定义一个int类型的指针
 5 int *p;
 6 
 7 // 让指针指向数组的第0个元素
 8 p = &a[0];
 9 
10 // 修改所指向元素的值
11 *p = 10;
12 
13 // 打印第一个元素的值
14 printf("a[0] = %d", a[0]);



输出结果：，说明已经通过指针间接修改了数组元素的值，跟指向一个普通int类型变量是一样的。

由于数组名代表着数组的首地址，即a == &a[0]，因此第8行代码等价于：

// 让指针指向数组的第0个元素
p = a;


内存分析图如下，一个指针变量占用2个字节，一个int类型的数组元素占用2个字节








二、用指针遍历数组元素

1.最普通的遍历方式是用数组下标来遍历元素


1 // 定义一个int类型的数组
2 int a[4] = {1, 2, 3, 4};
3 
4 int i;
5 for (i = 0; i < 4; i++) {
6     printf("a[%d] = %d \n", i, a[i]);
7 }



输出结果：

 

2.接下来我们用指针来遍历数组元素

先定义一个指针，指向数组的第一个元素

// 定义一个int类型的数组
int a[4] = {1, 2, 3, 4};

// 定义一个int类型的指针，并指向数组的第0个元素
int *p = a;




p的值是a[0]的地址，因此，现在我们利用指针p只能访问数组的第0个元素a[0]，用*p就可取出a[0]的值1。要想访问其他元素，就必须拿到元素的地址，可以发现每个元素的地址差值为2，因为在16位编译器环境下，一个int类型的变量占用2个字节。现在只是知道a[0]的地址值为p，怎么根据a[0]的地址获取其他元素的地址呢？其实非常简单，p+1就是a[1]的地址。注意了，这里的p+1代表着p的值加2，并不是p的值加1，比如p的值为ffc3，p+1则为ffc5，而非ffc4。依次类推，p+2就是a[2]的地址ffc7，p+3就是a[3]的地址ffc9。

我先解释一下，为什么p+1代表p的值加2，而不是加1呢？

其实，p+1不一定代表p的值加2，也可能是加1、加4或者加8。究竟加多少，这跟指针的类型有关。下图是在16位编译器环境下的情况。



聪明的你可能已经找到规律了，因为char类型的变量要占用1字节，所以p+1代表p的值加1；float类型的变量占用4字节，所以p+1代表p的值加4。从这一点，也可以很好地说明为什么指针一定要分类型，不同类型的指针，p+1的含义是不一样的。

上述代码中的p指向了int类型的数组元素a[0]，所以p+1代表p的值加2。知道怎么获取其他元素的地址了，那么就可以利用指针p遍历数组元素了。


 1 // 定义一个int类型的数组
 2 int a[4] = {1, 2, 3, 4};
 3 
 4 // 定义一个int类型的指针，并指向数组的第0个元素
 5 int *p = a;
 6 
 7 int i;
 8 for (i = 0; i < 4; i++) {
 9     // 利用指针运算符*取出数组元素的值
10     int value = *(p+i);
11     
12     printf("a[%d] = %d \n", i, value);
13 }



注意第10行的代码，*(p+i)代表根据p+i的值(其实就是第i个数组元素的地址)访问对应的存储空间，并取出存储的内容(也就是取出第i个数组元素的值)，赋值给左边的value。

最后的输出效果是一样的：。注意的是：遍历完毕后，指针变量p还是指向a[0]，因为p值一直没有变过，一直都是a[0]的地址ffc3。

补充一下，其实第10行改成下面的代码也是可以的：

int value = *(a+i);


大家都知道，a值代表数组的首地址，也就是a[0]的地址ffc3。a+1则代表a的值加2，即a[1]的地址ffc5，也就是说，a+i代表着元素a[i]的地址。相信大家也能猜出来了，a+1不一定代表着a值加2，究竟加多少，取决于数组的类型。a+i的计算方法与p+i相同。

 

利用上面的方法遍历完数组元素后，p一直指向元素a[0]。其实我们也可以直接修改p的值来访问数组元素，只需要改一下第10行的代码即可

// 利用指针运算符*取出数组元素的值
int value = *(p++);


p++其实就是相当于p = p + 1，直接修改了p值，而且每次是加2。因此，每执行一次p++，指针p就会指向下一个数组元素。

输出结果肯定是一样的：。但是，遍历完毕后，指针变量p没有指向任何数组元素，因为一共执行了4次p++，最后p值为ffcb。当然，可以重新让p指向a[0]：p
 = &a[0];或者p = a;

注意，这里的写法是错误的

int value = *(a++);


a++相当于a=a+1，数组名a是个常量！不能进行赋值运算！

 



三、指针与数组的总结

p是指针，a是一个数组

1> 如果p指向了一个数组元素，则p+1表示指向数组该元素的下一个元素。比如，假设p = &a[0]，则p+1表示a[1]的地址

2> 对于不同类型的数组元素，p值的改变是不同的。如果数组元素为int类型，p+1代表着p的值加上2(16位编译器环境下)

3> 如果p的初值是&a[0]，那么
p+i和a+i都可以表示元素a[i]的地址，它们都指向数组的第i个元素。a代表数组首地址，a+i也是地址，它的计算方法与p+i相同

*(p+i)和*(a+i)都表示数组元素a[i]
虽然p+i和a+i都指向数组的第i个元素,但二者使用时还是有区别的。因为作为指针变量的p可以改变自身值，如p++,使p的值自增。而数组名a是一个代表数组首地址的常量，它的值是不能改变的，即a++是不合法的

4> 引用一个数组元素可以有两种方法:

下标法: 如a[i]

指针法: 如*(p+i) 或 *(a+i)

 



四、数组、指针与函数参数

1.用数组名作为函数实参时，是把实参数组的首地址传递给形参数组，两个数组共同占用同一段内存空间，这样形参数组中的元素值发生变化就会使实参数组的元素值也同时变化


 1 void change(int b[]) {
 2     b[0] = 10;
 3 }
 4 
 5 int main()
 6 {
 7     // 定义一个int类型的数组
 8     int a[4] = {1, 2, 3, 4};
 9 
10     // 将数组名a传入change函数中
11     change(a);
12     
13     // 查看a[0]
14     printf("a[0]=%d", a[0]);
15     
16     return 0;
17 }



change函数的形参是数组类型的，在第11行调用change函数时，将数组名a，也就是数组的地址传给了数组b。因此数组a和b占用着同一块内存空间。

输出结果：

 

2.这种地址的传递也可以用指针来实现。函数的实参和形参都可以分别使用数组或指针。这样就有4种情况:



也就是说，如果一个函数的形参类型是一个数组，调用函数时，你可以传入数组名或者指针变量；


 1 void change(int b[]) {
 2     b[0] = 10;
 3 }
 4 
 5 int main()
 6 {
 7     // 定义一个int类型的数组
 8     int a[4] = {1, 2, 3, 4};
 9     
10     int *p = a;
11 
12     // 将数组名a传入change函数中
13     change(p);
14     
15     // 查看a[0]
16     printf("a[0]=%d", a[0]);
17     
18     return 0;
19 }



注意第1行的形参类型是个数组int b[]，第10行定义了指针变量p，第13行将p当做实参传入函数

 

如果一个函数的形参类型是一个指针变量，调用函数时，你可以传入数组名或者指针变量。


 1 void change(int *b) {
 2     b[0] = 10;
 3     // 或者*b = 10;
 4 }
 5 
 6 int main()
 7 {
 8     // 定义一个int类型的数组
 9     int a[4] = {1, 2, 3, 4};
10 
11     // 将数组名a传入change函数中
12     change(a);
13     
14     // 查看a[0]
15     printf("a[0]=%d", a[0]);
16     
17     return 0;
18 }



注意第1行的形参类型是个指针变量int *b，第12行将数组名a当做实参传入函数。

由第2行可以看出，在很多情况下，指针和数组是可以相互切换使用的。但是，并不能说指针就等于数组。