在概念上是二维的，有行和列，但在内存中所有的数组元素都是连续排列的，它们之间没有 “缝隙”。以下面的二维数组 a 为例：

int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} };

从概念上理解，a 的分布像一个矩阵：

0   1   2   3
4   5   6   7
8   9  10  11

但在内存中，a 的分布是一维线性的，整个数组占用一块连续的内存：

 C 语言中的二维数组是按行排列的，也就是先存放 a [0] 行，再存放 a [1] 行，最后存放 a [2] 行；每行中的 4 个元素也是依次存放。数组 a 为 int 类型，每个元素占用 4 个字节，整个数组共占用 4×(3×4) = 48 个字节。

C 语言允许把一个二维数组分解成多个一维数组来处理。对于数组 a，它可以分解成三个一维数组，即 a [0]、a [1]、a [2]。每一个一维数组又包含了 4 个元素，例如 a [0] 包含 a [0][0]、a [0][1]、a [0][2]、a [0][3]。

假设数组 a 中第 0 个元素的地址为 1000，那么每个一维数组的首地址如下图所示：

 为了更好的理解指针和二维数组的关系，我们先来定义一个指向 a 的指针变量 p：

int (*p)[4] = a;

括号中的 * 表明 p 是一个指针，它指向一个数组，数组的类型为 int [4]，这正是 a 所包含的每个一维数组的类型。

[ ] 的优先级高于 *，( ) 是必须要加的，如果赤裸裸地写作 int *p[4]，那么应该理解为 int *(p[4])，p 就成了一个指针数组，而不是二维数组指针，这在《C 语言指针数组》中已经讲到。

对指针进行加法（减法）运算时，它前进（后退）的步长与它指向的数据类型有关，p 指向的数据类型是 int [4]，那么 p+1 就前进 4×4 = 16 个字节，p-1 就后退 16 个字节，这正好是数组 a 所包含的每个一维数组的长度。也就是说，p+1 会使得指针指向二维数组的下一行，p-1 会使得指针指向数组的上一行。

数组名 a 在表达式中也会被转换为和 p 等价的指针！

下面我们就来探索一下如何使用指针 p 来访问二维数组中的每个元素。按照上面的定义：
1) p 指向数组 a 的开头，也即第 0 行；p+1 前进一行，指向第 1 行。

2) *(p+1) 表示取地址上的数据，也就是整个第 1 行数据。注意是一行数据，是多个数据，不是第 1 行中的第 0 个元素，下面的运行结果有力地证明了这一点： 

#include <stdio.h>
int main(){
    int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} };
    int (*p)[4] = a;
    printf("%d\n", sizeof(*(p+1)));

    return 0;
}

 运行结果：  16

 3) *(p+1)+1 表示第 1 行第 1 个元素的地址。如何理解呢？

*(p+1) 单独使用时表示的是第 1 行数据，放在表达式中会被转换为第 1 行数据的首地址，也就是第 1 行第 0 个元素的地址，因为使用整行数据没有实际的含义，编译器遇到这种情况都会转换为指向该行第 0 个元素的指针；就像一维数组的名字，在定义时或者和 sizeof、& 一起使用时才表示整个数组，出现在表达式中就会被转换为指向数组第 0 个元素的指针。

4) *(*(p+1)+1) 表示第 1 行第 1 个元素的值。很明显，增加一个 * 表示取地址上的数据。
根据上面的结论，可以很容易推出以下的等价关系：
根据上面的a+i == p+i
a[i] == p[i] == *(a+i) == *(p+i)
a[i][j] == p[i][j] == *(a[i]+j) == *(p[i]+j) == *(*(a+i)+j) == *(*(p+i)+j)结论，可以很容易推出以下的等价关系：

a+i == p+i
a[i] == p[i] == *(a+i) == *(p+i)
a[i][j] == p[i][j] == *(a[i]+j) == *(p[i]+j) == *(*(a+i)+j) == *(*(p+i)+j)

 【实例】使用指针遍历二维数组。

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

    return 0;
}

 运行结果：

 0   1   2   3
 4   5   6   7
 8   9  10  11

指针数组和二维数组指针的区别

指针数组和二维数组指针在定义时非常相似，只是括号的位置不同：

int *(p1[5]);  //指针数组，可以去掉括号直接写作 int *p1[5];
int (*p2)[5];  //二维数组指针，不能去掉括号

指针数组和二维数组指针有着本质上的区别：指针数组是一个数组，只是每个元素保存的都是指针，以上面的 p1 为例，在 32 位环境下它占用 4×5 = 20 个字节的内存。二维数组指针是一个指针，它指向一个二维数组，以上面的 p2 为例，它占用 4 个字节的内存。

二级指针

使用二级指针初始化一级指针

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
enum
{
    Success,NameErr,SexErr,StrNumErr,ScoreErr
};
typedef struct stu
{
    char *name;
    char *sex;
    char *strNum;
    float *score;
}STU;
int init(STU ** p)
{
    *p = (STU *)malloc(sizeof(STU));//*p就是ps,申请一块空间里面存放4个不同类型的指针，将首地址赋值给ps
    //初始化一级指针，使这4个不同类型的指针都有所指向
    (*p)->name = (char *)malloc(sizeof(100));
    if((*p)->name == NULL)
        return NameErr;
    (*p)->sex = (char *)malloc(sizeof(char));
    if((*p)->sex == NULL)
        return SexErr;
    (*p)->strNum = (char *)malloc(sizeof(30));
    if((*p)->strNum == NULL)
        return StrNumErr;
    (*p)->score = (float *)malloc(sizeof(float));
    if((*p)->score == NULL)
        return ScoreErr;
    return Success;
}
int main(void)
{
    STU * ps = NULL;

    int ret = init(&ps);
    if(ret != Success)
        return -1;
    strcpy(ps->name,"wahaha");
    *(ps->sex) = 'x';
    strcpy(ps->strNum,"语文");
    *(ps->score) = 66.5;

    printf("姓名：%s\n性别：%c\n科目：%s\n分数：%.2f\n",ps->name,*(ps->sex),ps->strNum,*(ps->score));
    return 0;
}

一、问题

下面这些声明合法吗？

	int vector[10], *vp = vector;
	int matrix[3][10], *mp=matrix,
	

二、答案

第1个声明是合法的。它为一个整型数组分配内存，并把vp声明为一个指向整型的指针,并把它初始化为指向 vector数组的第1个元素。 vector和vp具有相同的类型：指向整型的指针。

第2个声明是非法的。它正确地创建了 matrix数组，并把mp声明为一个指向整型的指针。但是,mp的初始化是不正确的,因为matrix并不是一个指向整型的指针，而是一个指向整型数组的指针。正确的初始化方法是

int matrix[3][10];
int (*mp)[10] = matrix;

三、如何声明一个指向整型数组的指针

int(*p)[10];

这个声明比我们以前见过的所有声明更为复杂,但它事实上并不是很难。你只要假定它是一个表达式并对它求值。下标引用的优先级高于间接访问,但由于括号的存在,首先执行的还是间接访问。所以，p是个指针,但它指向什么呢?接下来执行的是下标引用,所以p指向某种类型的数组。这个声明表达式中并没有更多的操作符，所以数组的每个元素都是整数。

声明并没有直接告诉你p是什么,但推断它的类型并不困难——当我们对它执行间接访问操作时,我们得到的是个数组,对该数组进行下标引用操作得到的是一个整型值。所以p是一个指向整型数组的指针。
我们在声明中加上初始化后是下面这个样子

int(*p)[10] = matrix;// 一个指针，它指向一个有10个int元素的数组

它使p指向matrix的第1行。
p是一个指向拥有10个整型元素的数组的指针。当你把p与一个整数相加时,该整数值首先根据10个整型值的长度进行调整,然后再执行加法。所以我们可以使用这个指针一行一行地在 matrix中移动。

四、实例

现在，我们来观察一个矩阵

int matrix[3][10] ;
...
Func(matrix);

这里,参数 matrix的类型是指向包含10个整型元素的数组的指针。Func的原型应该是怎样的呢?

我们可以使用下面两种形式中的任何一种

void Func( int (*mat)[10])
void Func( int mat[][10])

在这个函数中，mat的第1个下标根据包含10个元素的整型数组的长度进行调整，接着第2个下标根据整型的长度进行调整，这和原先的 matrIx数组一样。这里的关键在于编译器必须知道第2个及以后各维的长度，才能对各下标进行求值。因此在原型中必须声明这些维的长度。第1维的长度并不需要,因为在计算下标值时用不到它。在编写一维数组形参的函数原型时,你既可以把它写成数组的形式,也可以把它写成指针的形式。

但是,对于多维数组,只有第1维可以进行如此选择。尤其是,把Func写成下面这样的原型是不正确的。

void Func( int **mat，int row,int col）

它把mat声明为一个指向整型指针的指针,它和指向整型数组的指针并不是一回事。

可以进行强制转换如下调用。

	Func((int**)matrix,3,3);

其他实例

在该例中，指向有 10 个 int 元素的数组的指针会被初始化为 NULL。然而，如果把合适数组的地址分配给它，那么表达式 *arrPtr 会获得数组，并且（*arrPtr）[i] 会获得索引值为 i 的数组元素。根据下标运算符的规则，表达式（*arrPtr）[i] 等同于 *((*arrPtr)+i)。因此，**arrPtr 获得数组的第一个元素，其索引值为 0。 

    int (* arrPtr)[10] = NULL;   // 一个指针，它指向一个有10个int元素的数组    
    int matrix[3][10];            // 3行，10列的数组
                              // 数组名称是一个指向第一个元素的指针，也就是第一行的指针
    arrPtr = matrix;            // 使得arrPtr指向矩阵的第一行
    (*arrPtr)[0] = 5;       // 将5赋值给第一行的第一个元素
    arrPtr[2][9] = 6;           // 将6赋值给最后一行的最后一个元素
    ++arrPtr;                   // 将指针移动到下一行
    (*arrPtr)[0] = 7;           // 将7赋值给第二行的第一个元素

在前文 arrPtr 的声明语句（int（*arrPtr）[10]=NULL；）中，删除其中标识符 arrPtr，就可得到 int（*）[10]，即对应的数组指针类型。然而，为了提高可读性和灵活性，可以利用 typedef 为所用的类型定义一个简单的名字：

	typedef int ARRAY_t[10];    // 定义一个“具有10个元素数组”类型名称
	ARRAY_t  array,                     // 具有该类型的数组
		*arrPtr;               // 一个指向该数组类型的指针
	arrPtr = (ARRAY_t *)array;  // 使得arrPtr指向array

 参考：

C语言数组指针和指针数组

如何将二维数组作为函数的参数传递_manba-CSDN博客_二维数组 函数参数

** p——指向指针的指针

指针是一种特殊的数据类型，也是占内存的能寻址的，这跟电脑的操作系统的位数有关，我是64位的。

int 类型

以整型指针数组为例，先定义一组指向整型的指针数组*p，再定义一组指向整形指针的指针数组**p：

#include<iostream>
#include<iomanip>
#include<string>
using namespace std;
int main()
{
    int val[5]={1,2,3,5};
    int *p[5];
    int **pp[5];
    for(int i=0;i<5;i++)
    {
        p[i]=&val[i];//一阶指针指向数组的各个元素
        pp[i]=&p[i];//二阶指针指向各个一阶指针
        cout<<p[i]<<setw(20)<<pp[i]<<setw(7)<<*p[i]<<setw(7)<<**pp[i]<<endl;
    }
    
    return 0;
}

运行结果为

0x7ffe6cfddfe0      0x7ffe6cfde000      1      1                                                                        
0x7ffe6cfddfe4      0x7ffe6cfde008      2      2                                                                        
0x7ffe6cfddfe8      0x7ffe6cfde010      3      3                                                                        
0x7ffe6cfddfec      0x7ffe6cfde018      5      5                                                                        
0x7ffe6cfddff0      0x7ffe6cfde020      0      0

可以看出，p[i]输出的是数组元素的存储地址，pp[i]输出的是指针元素的存储地址，发现一个整型数据需要4个字节的存储空间，而一个指针需要8个字节的存储空间；同时，可以知道*p[i]和**pp[i]最终指向一个地址，他们的值是一样的。二阶指针沿着一阶指针找到val[]。

字符型指针的指针

字符数组的每一个元素都是一个字符，占一个字节
pp[i]输出的是一阶指针的地址，而**pp[i]输出的和*p[i]输出的是一样的，都是所指向元素的字符的值。
对于字符数组，和整形数组在一阶指针上有所区别，如下：

#include<iostream>
#include<iomanip>
#include<string>
using namespace std;
int main()
{
    char val[5]={'1','2','3','5'};
    char *p[5];
    char **pp[5];
    cout<<val<<endl;
    cout<<&val<<endl;
    for(int i=0;i<5;i++)
    {
        p[i]=&val[i];//一阶指针指向数组的各个元素
        pp[i]=&p[i];//二阶指针指向各个一阶指针
        cout<<setw(7)<<p[i];//输出的p[i]与整型数组有所不同，不再是地址
        cout<<setw(20)<<pp[i];//输出一阶指针的存储地址
        cout<<setw(7)<<*p[i];
        cout<<setw(7)<<**pp[i];
        cout<<setw(20)<<static_cast<void *>(p[i])<<endl;//输出每一个元素的存储地址
        
    }
    return 0;
}

运行结果如下

1235                                                                                                                    
0x7ffd7b4acac3                                                                                                          
   1235      0x7ffd7b4aca60      1      1      0x7ffd7b4acac3                                                           
    235      0x7ffd7b4aca68      2      2      0x7ffd7b4acac4                                                           
     35      0x7ffd7b4aca70      3      3      0x7ffd7b4acac5  
       5      0x7ffd7b4aca78      5      5      0x7ffd7b4acac6                                                           
                0x7ffd7b4aca80                     0x7ffd7b4acac7 

可以看出，cout<<val，直接输出字符数组的内容；
cout<<&val，输出的是字符串的首地址，也就是数组中第一个元素，第一个字符的存储地址；
cout<<p[i]，输出的是所指地址的元素及其后面的元素，直到读到\0的时候停止读取；
cout<<pp[i]，输出的是一阶指针的存储地址，每个指针占八个字节；
cout<<*p[i]和**pp[i]，输出的都是所指地址的那个元素；
cout<<static_cast<void *>(p[i])，可以输出每一个元素的存储地址。

指向字符串指针的指针

和指向字符的指针用法是一样的，不同的是，一个字符串包含多个字符，占多个字节，但是
cout<<*p[i]和**pp[i]输出的都是所指地址的字符串中第一个字符的值。
cout<<p[i]会输出每一个字符串的值
cout<<static_cast<void *>(p[i])，可以输出每一个字符串的存储首地址。

#include<iostream>
#include<iomanip>
using namespace std;
int main()
{
    char *pc[5]={"happy","wife","happy","life","haha"};
    char **pcc[5];
    for(int i=0;i<5;i++)
    {
        pcc[i]=&pc[i];
        cout<<setw(7)<<pc[i];//输出的是每一个字符串的值
        cout<<setw(20)<<pcc[i];//输出一阶指针的存储地址
        cout<<setw(7)<<*pc[i];
        cout<<setw(7)<<**pcc[i];
        cout<<setw(20)<<static_cast<void *>(pc[i])<<endl;//输出每一个元素的存储地址
    }
    return 0;
}

运行结果如下

happy      0x7fff567d6170      h      h            0x400bf7                                                           
   wife      0x7fff567d6178      w      w            0x400bfd                                                           
  happy      0x7fff567d6180      h      h            0x400bf7                                                           
   life      0x7fff567d6188      l      l            0x400c02                                                           
   haha      0x7fff567d6190      h      h            0x400c07 

自己在学的过程中终于弄懂了指针在各种数据类型中的各种表示所代表的数据是什么，以上内容如有错误，欢迎评论指正哦。