使用指针调用数组元素的方法

 数组在计算机中不是二维排列，而是一维连续排列，如a[2][2]是这样排列的

a[0][0],a[0][1],a[1][0],a[1][1]

于是，我们只需要知道每行第一个元素的地址（每行的首地址），便可通过运算知道该行其他元素的地址

不带下标的数组名可以表示数组的首地址

1.使用指针数组（指针的数组）

#include<iostream>
#include<iomanip>
using namespace std;
int main()
{
    int a[4][4] = {
        1,2,3,4,
        5,6,7,8,
        9,10,11,12,
        13,14,15,16
    };          //p[0]代表a[0]的地址，以此类推
   int* p[4] = { a[0],a[1],a[2],a[3] };//指针数组
    cout << p[0][3] << endl;//1
    cout << *(p[0] + 3) << endl;//2
    cout << **p<<endl;//3
    cout << *(*(p + 1) + 1) << endl;//4
}

运行结果 4 4 1 6

*p[4]创建了4个指针，分别指向了a[0]，a[1],a[2],a[3]

分析:1.运算符[ ] 是从左到右运算，p[0]表示a[0]的地址，[3]表示地址后第三个元素

结合起来就是a[0][3],也就是4

2.同样的,p[0]表示a[0],a[0]不仅可以表示某个元素，也可以表示元素的地址，这里表示了第一行下标为0的元素的地址，也就是a[0]的地址，+3就得到a[0]这一行下标为3的元素的地址（也就是a[3][3]的地址），通过间接运算符* 得到这个地址对应的值为4

3.*运算符是从右向左运算，*p代表a[0]的地址，也就是第一行下标为0的元素的地址，**p就通过地址得到了a[0]的值，1

4.先算内层括号里的，*（p+1）表示a[1]的地址（第1行的地址），*（p+1）+1 表示了a[1]后面那个元素的地址，也就是a[1][1]的地址,通过地址就找出了a[1][1]的值6

可以简记为指针数组*p 其+1是加一行

*p是a[0][0]的地址，*p+1是a[1][0]的地址

**p是第1行的首元素1，**(p+1)是下一行的首元素5

 2.使用数组指针（数组的指针）

  int a[4][4] = {
        1,2,3,4,
        5,6,7,8,
        9,10,11,12,
        13,14,15,16
    };
    int(*p)[4];
    p = a;//将这个指针指向数组a
    cout << p[0][3]<<endl;//1
    cout << *(p[0] + 3)<<endl;//2
    cout << **(p+1)<<endl;//3
    cout << *(*(p + 1) + 1) << endl;//4

结果是4 ，4，5  ,  6

(*p)[4]创建了一个指针，指向含4列元素的数组

分析：1和2与上面情况相同

3.p=a，*p是a[0][0]的首地址，*(p+1)是a[1][0]的首地址，于是**(p+1)就是找到a[1][0],也就是5

4.*（p+1）+1是*（p+1）的地址+1，也就是a[1][1]的地址，*运算得到是6

数组指针*p  其+1是加一列

如*p是a[0][0]的地址,*p+1就是a[0][1]的地址

3.指向指针的指针

int* p = a[0];
    int** q=&p;//指针q指向p
    cout << **q;
    cout << *(*q + 1);

结果是1和2

分析:

*q是p的地址 通过地址找到p，就得到**q=1

*q+1是p的地址+1, *（*q+1）就得到了p后的元素 *（*q+1）=2

 //输出每一个元素
int i = 0, j = 0;
    for (i = 0; i < 4; i++)
    {
        for (j = 0; j < 4; j++)
        {
            cout << *(*q + 4 * i + j) << endl;
        }
    }

结果是1-16 

分析:行每次要加4，列每次加1  

比如从第一行第一个元素到第二行第一个元素 如a[0][0]与a[1][0]地址差是4

而a[1][0]与a[1][1]地址差是1

给自己看

//转置n阶方阵，这里n=4
int a[4][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
int* p[4]={a[0],a[1],a[2],a[3]};
int n=4;
int i = 0,j=0;
	int** q;//指向指针数组p
	q = p;
	for (i = 0; i < n-1; i++)//因为是使用下标，所以是n-1
	{
		for (j = 0; j < i; j++)
		{
			int temp = *(*q + 4 * i + j);//*q是a[0]的地址
			*(*q + 4 * i + j) = *(*q + 4 * j + i);
			*(*q + 4 * j + i) = temp;


			int temp = q[i][j];
			q[i][j] = q[j][i];
			q[j][i] = temp;


			int temp = *(q[i] + j);
			*(q[i] + j) = *(q[j] + i);
			*(q[j] + i) = temp;
		}
	}

这三种交换方法都能成功，最简单的是第二种，但是1和3也要理解

解释第一种:

比如想交换a[3][2]和a[2][3]，这两个在线性排列上分别是下标为14的元素和下标为11的元素

此时i=2,j=3 2*4+3=11,3*4+2=14，正好满足

于是可以得到：想转置n*n数组，外层循环设置成i<n，内层设置成j<i就成了

这也是因为最后一个元素a[3][3]不需要与自己交换