The two-dimensional pointer operation in C++

C中的二维指针问题总结：
概括的说，指针其实就是可变数组的首地址，说是可变数组，是

指其包含内容的数量的可变的，并且是可动态申请和释放的，从而充

分节约宝贵的内存资源。我一向喜欢一维数组，除非万不得已，我一

般是不用二维数组的，多维的则更是很少涉足了。因为一维简单，容

易理解，而用指针指向的多维数组就具有相当的复杂性了，也因此更

具有讨论的必要。

闲话少说，这里我就以三个二维数组的比较来展开讨论：

(1)、int **Ptr;

(2)、int *Ptr[ 5 ];

(3)、int ( *Ptr )[ 5 ];

以上三例都是整数的二维数组，都可以用形如 Ptr[ 1 ][ 1 ]的

方式访问其内容；但它们的差别却是很大的。下面我从四个方面对它们

进行讨论：

一、内容：

它们本身都是指针，它们的最终内容都是整数。注意我这里说

的是最终内容，而不是中间内容，比如你写 Ptr[ 0 ]，对于三者来说，

其内容都是一个整数指针，即 int *；Ptr[ 1 ][ 1 ]这样的形式才

是其最终内容。

二、意义：

(1)、int **Ptr表示指向"一群"指向整数的指针的指针。

(2)、int *Ptr[ 5 ]表示指向 5个指向整数的指针的指针。

(3)、int ( *Ptr )[ 5 ]表示指向"一群"指向
5 个整数数

组的指针的指针。

三、所占空间：

(1)、int **Ptr和 (3)、int ( *Ptr )[ 5 ]一样，在32位平

台里，都是4字节，即一个指针。

但 (2)、int *Ptr[ 5 ]不同，它是 5个指针，它占5
* 4 = 20

个字节的内存空间。

四、用法：

(1)、int **Ptr

因为是指针的指针，需要两次内存分配才能使用其最终内容。首

先，Ptr = ( int ** )new int*[ 5 ]；这样分配好了以后，它和(2)的

意义相同了；然后要分别对 5个指针进行内存分配，例如：

Ptr[ 0 ] = new int[ 20 ];

它表示为第 0
个指针分配 20 个整数，分配好以后，Ptr[0 ]为指

向 20个整数的数组。这时可以使用下标用法 Ptr[ 0 ][ 0 ]到

Ptr[ 0 ][ 19 ] 了。

如果没有第一次内存分配，该 Ptr是个"野"指针，是不能使用

的，如果没有第二次内存分配，则 Ptr[ 0 ]等也是个"野"指针，也

是不能用的。当然，用它指向某个已经定义的地址则是允许的，那是另外

的用法（类似于"借鸡生蛋"的做法），这里不作讨论（下同）。

(2)、int *Ptr[ 5 ]

这样定义的话，编译器已经为它分配了 5个指针的空间，这相当

于(1)中的第一次内存分配。根据对(1)的讨论可知，显然要对其进行一次

内存分配的。否则就是"野"指针。

(3)、int ( *Ptr )[ 5 ]

这种定义我觉得很费解，不是不懂，而是觉得理解起来特别吃力，

也许是我不太习惯这样的定义吧。怎么描述它呢？它的意义是"一群"

指针，每个指针都是指向一个 5个整数的数组。如果想分配 k个指针，

这样写： Ptr = ( int ( * )[ 5 ] ) new int[ sizeof( int ) * 5 * k ]。

这是一次性的内存分配。分配好以后，Ptr指向一片连续的地址空间，

其中 Ptr[ 0 ]指向第 0个 5
个整数数组的首地址，Ptr[ 1 ]指向第

1 个 5
个整数数组的首地址。

综上所述，我觉得可以这样理解它们：

int ** Ptr <==> int Ptr[ x ][ y ];

int *Ptr[ 5 ] <==> int Ptr[ 5 ][ x ];

int ( *Ptr )[ 5 ] <==> int Ptr[ x ][ 5 ];

这里 x和 y是表示若干的意思。

二、二维数组　　　　＊＊＊＊＊和二维指针的关系

1.代码

[cpp]
viewplaincopyprint?
1. <span style="white-space: pre;"> </span>//test2
2. cout<<"test2"<<endl;
3. int b[10][10], i, j;
4. for(i = 0; i < 10; i++)
5. {
6. for(j = 0; j < 10; j++)
7. b[i][j] = i * 100 + j *10;
8. }
9. int (*pb)[10] = b;
10. cout<<pb<<' '<<pb+1<<endl;
11. cout<<(*pb)<<' '<<(*pb+1)<<endl;
12. cout<<*pb<<' '<<*(pb+1)<<' '<<*(pb+1)+1<<endl;
13. cout<<**pb<<' '<<**pb+1<<endl;
14. cout<<(*(*pb))<<' '<<(*(*pb+1))<<' '<<(*(*pb+1)+1)<<endl;
15. cout<<**(pb)<<' '<<**(pb+1)<<' '<<**(pb+1)+1<<endl;

//test2

cout<<"test2"<<endl;

int b[10][10], i, j;

for(i = 0; i < 10; i++)

{

for(j = 0; j < 10; j++)

b[i][j] = i * 100 + j * 10;

}

int (*pb)[10] = b;

cout<<pb<<' '<<pb+1<<endl;

cout<<(*pb)<<' '<<(*pb+1)<<endl;

cout<<*pb<<' '<<*(pb+1)<<' '<<*(pb+1)+1<<endl;

cout<<**pb<<' '<<**pb+1<<endl;

cout<<(*(*pb))<<' '<<(*(*pb+1))<<' '<<(*(*pb+1)+1)<<endl;

cout<<**(pb)<<' '<<**(pb+1)<<' '<<**(pb+1)+1<<endl;

2.输出结果

3.解释

第一行：
pb：b[0]的地址。pb是指向b[0]的指针，b[0]是一个int[10]数组。
pb+1：b[1]的地址。pb指向的对象是一个数组，所以pb和pb+1相差0x28
第二行：
*pb：b[0][0]的地址。*pb是指向b[0][0]的指针，b[0][0]是一个int。虽然b[0]和b[0][0]的地址是一样的，但是两个指针指向的对象是不一样的。
*pb+1：b[0][1]的地址。pb是指向b[0][1]的指针，b[0][1]是一个int。因此*pb和*pb+1相关4
第三行：
*pb：b[0][0]的地址。
*(pb+1)：b[1][0]的地址。pb+1指向b[1]。
*(pb+1)+1：b[1][1]的地址。
第四行：
**pb：pb[0][0]。pb指向pb[0]。*pb指向pb[0][0]。**pb是pb[0][0]的内容。
**pb+1：b[0][0]+1。
第五行：
*(*pb)：pb[0][0]
(*(*pb+1))：pb[1][0]
(*(*pb+1)+1)：pb[1][1]
第六行：
**(pb)：pb[0][0]
**(pb+1)：pb[1][0]
**(pb+1)+1：pb[1][0]+1

二维指针对字符串的操作：

1. #include<string>
2. using namespace std;
3. int main(){
4. char **mychr;
5. char chr[]={"I love cplusplus"};
6. char chrs[]={"I love cplusplus"};
7. char *p=chr;
8. mychr=&p;
9.
10.if(strcmp(*mychr,chrs)==0)
11.{
12.cout<<"equal"<<endl;
13.}
14.else
15.{
16.cout<<"not equal"<<endl;
17.}
18.
19.cout<<&chr[0]<<endl;
20.cout<<&p<<endl;
21.cout<<&(*mychr)<<endl;
22.cout<<**mychr<<endl;
23.system("pause");
24.return 0;
25.}

二维数组指针指向一维数组

#include<stdio.h>

int main()

{

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

int (*p)[5]=&array;

for(int i=0;i<5;i++)

{

printf("%d ",*(*p+i));

}

printf("\n");

return 0;

}

在这里面我们定义了一个指针变量p，这个指针变量指向的是一个含有5个元素的一维数组，它指向的是一个一维数组的整体，所以将用&array赋值给它，*p其实是*(p+0)，按照我们一维数组的理解，*(p+0)应该是指向我们数组的第一个元素，即p[0]，也即我们所指数组的第一个元素&array[0]，这个地址再后移i个元素后得到我们想要的地址，然后再加上*就得到本地址里面所存储的整形数据的内容。

博客：/article/8198741.html

对二维指针和二维数组讲解的非常详细

（二）二维数组和指针
（1）地址代表的意义

首先理解，二维数组，例如

int arry[2][3]={{2,3,1},

{23,45,6}};
这样写是最好理解的，也就是说2行3列。其中也可以看成是2个一维数组的整合，也就是

arry[0] = {2,3,1};

arry[1] = {23,45,6};
简单测试一下一些符号究竟代表的是什么意思

printf("n%x",arry);

printf("n%x",arry[0]);

printf("n%x",&arry[0][0]);

printf("n%x",arry+1);

printf("n%x",arry[1]+1);

printf("n%x",&arry[1][1]+1);

从编译运行的结果来看

12ff68

12ff68

12ff68

12ff74

12ff78

12ff7c

arry 是这个数组的名字，也就是代表着入口地址，刚才说了，二维数组实际可以看成N个

一维数组，例如本例中，arry[0] 代表着其中的第一个一维数组，那么 arry[1] 就代表着

第二个一维数组，而且这里是地址，注意 arry[0] 本身就代表着地址了。

arry[0][0]本身代表着这个元素，那么取地址之后 &arry[0][0] 就变成了，这个元素的地址

然而将每个地址加一后发现，这些地址代表的语义并不相同。

arry+1 之后地址变成 12ff68 到 12ff74 也就是说，指向了第二行第一个元素 23

arry[1]本身就代表着第二个一维数组的入口地址，加一之后就只想这个数组的第二个元素

那么就应该指向 45，从地址可以看出。

&arry[1][1]+1 这个是以元素为单位，首先 arry[1][1]这个元素为基准，也就是 45 ，然后

再后移一个元素，所以应该指向 6.

参考

（2）二维数组怎么传递参数
void disparry(int a[2][3])

{

printf("n%d,%d,%d",a[0][0],a[0][1],a[0][2]);

}
void main(void)

{

int arry[2][3]={{2,3,1},

{23,45,6}};

int (*c)[3]=arry;

int *p;
p =(int *)arry;

disparry((int (*)[3])p);
disparry(c);
}
可以通过两种办法，第一是通过 int * 类型的指针 *p 来处理。首先因为 p 是 int* 类型，

而 arry是二维数组，不等价不能直接赋值，那么就简单的将二维数组指针转换为 int* 类型

这样就匹配了，产生的效果是 p 指向了 arry 的入口。

然后 disparry 函数需要的参数的类型是 inta[2][3]，很显然，这个时候 p又不能作为参数

了，当然直接传递的话，运行结果不错，但是会有 warning 的。于是再一次将 int * 转换为

需要的 int (*)[3] 类型，说白了，就是 数组指针。

那么第二种办法就很干脆，定义一个数组指针c指向 arry，那么 c就可以直接传递了。
（3）使用 typedef 定义二维数组

typedef int A[2];

A b[3]={32,11,23,45,6,7};

printf("n%d",b[1][0]);
可以看出，先定义一种新的数据类型 A，他是一个 2个元素的一维数组。然后再定义一个含有

3个 A 类型的一维数组b，这样b其实就是一个二维数组了，b[3]代表的是有3行这样的一维数组

所以这样下来实际上等效于 b[3][2]。

C/C++中的二维指针问题--转载
(内存分配)

指针是可变数组的首地址。正因为是可变数组，所以一般使用指针时都是采用动态内存分配和释放的方式。一维指针形式简单，容易理解。平时应用较多。二维数组和二维指针比较复杂，并且在动态内存分配与释放方面比较复杂且难以理解。但是二维数组和二维指针是非常有用的。

考虑以下应用：对一幅图像进行模板运算。这必然会牵涉到对图像的各象素点的操作。此时使用一维指针进行图像传递时，不可避免的会使用形如*(p+i*width+j)的方式完成对图像象素点的访问。这种方式很不直观并且编写程序时容易出错。如果使用二维指针进行图像数据的传递，则会收到很好的效果。可以采用p[i][j]的方式直接操作象素点，直观又便于维护。因此掌握二维数组和二维指针是必要的。

使用http://www.wangchao.net.cn/bbsdetail_59038.html中的示例。

定义如下3个二维数组和二维指针进行说明：

1. int** ptr;

2. int *ptr[M];

3. int (*ptr)[M];

以上都是存放整数的二维数组，并且都可以通过ptr[i][j]的形式访问内容。但是它们之间有很大的差别。以下依照文中提到的方面进行分析。

l 内容

三个ptr本身都是指针，并且是二维指针，但是它们的最终内容总是整数。但中间内容，形如ptr[i]并不是整数，而是指针int *.

l 意义

1. int** ptr 表示指向（一组指向整数数据指针）的指针；

2. int *ptr[M] 是指针数组，表示指向（M个指向整数指针）的指针；

3. int (*ptr)[M]表示指向一组（指向包含M个整型数据的指针）的指针。

l 所占空间

1和3占用一个内存空间，在32位平台上为4个字节，也就是一个指针。

2是M个指针，在其定义过程中编译器即对其进行了分配，占用4*M共4M个字节。

l 用法

1. int** ptr 表示指向（一组指向整数数据指针）的指针，是一个二维指针。在其定义过程中，编译器并不对其进行内存的分配，因此必须自己管理其内存的分配与释放。典型使用如下：

使用上述方法分配内存，最终ptr耗费的内存空间为M*sizeof(int*)+M*N*sizeof(int)

2. int *ptr[M] 是指针数组，表示指向（M个指向整数指针）的指针。是一个二维指针。但是在定义的时候，编译器已经为ptr指向的M个指向整数的指针ptr[0:M-1]分配了内存。也就是说，定义之后即可得到ptr的地址以及用于存放ptr[0:M-1]的内存空间4MB。要使用ptr必须对ptr[i]分配内存。分配内存后，ptr地址相应内存空间填入ptr[i]指向内存地址。使用如下操作：

使用上述方法分配内存，最终ptr耗费的内存空间为M*sizeof(int*)+M*N*sizeof(int)，其中M*sizeof(int*)为编译器分配，M*N*sizeof(int)为程序员自己分配。

3. int (*ptr)[M]表示指向一组（指向包含M个整型数据的指针）的指针。该定义限定了ptr[i][0:M-1]，所有指针ptr[i]必须指向长度为M的数组。使用方式如下：

使用上述方法分配内存后，ptr所占内存空间为M*N*sizeof(int)（不考虑不同操作系统用于管理的内存）。ptr内存空间中保存的为最终内容而非ptr[i]地址。

最后回到开始考虑的应用，使用以下解决方案：

[cpp] view plaincopy

// Function Prototype: int test( char* data,
// const int N_H, const int N_V);
// Function name: test
// Return type: int
// Argument: char* data 输入图像数据
// Argument: const int N_H, const int N_V 图像尺寸
int test( char* data, const int N_H, const int N_V);
{
char** ppData = NULL;
int i = 0;

ppData = (char**)malloc(sizeof(char*)*N_V);

if (ppData == NULL)
{
printf("Error in mem location!/n");
return 0;
}

for (i=0;i<N_V;i++)
{
ppData[i] = data + i * N_H;
}

//其他操作
free(ppData);
return 1;
}

C++中用new给二维指针分配内存及delete删除

C++中用new可以通过以下方法为二维指针分配内存,例如分配整型5*4的空间：

1、化二维为一维

int *p;

p=new int[5*4]；

2、可以直接定义二维指针，通过两步申请内存，但是从二维数组的角度看内存不连续。

int **p;

int x;

p=new int*[5];

for (int i=0;i<5;i++)

{

p[i]=new int[4];

}

使用时：

for(int i=0;i<5;i++)

for(int j=0;j<4;j++)

p[i][j]=i+j;

for(int i=0;i<5;i++)

for(int j=0;j<4;j++)

{

std::cout<<p[i][j];

if(j==3)

std::cout<<std::endl;

}

释放内存时应该注意释放方法：

for(int i=0;i<5;i++)

delete[] p[i];

delete[] p;

3、可以先定义一维指针并分配够需要的空间，然后自己根据情况映射到二维指针。

int *p1=new int[5*4];

int **p;

int x;

p=new int*[5];

for (int i=0;i<5;i++)

{

p[i]=p1+i*4;

}

使用时仍然是：

for(int i=0;i<5;i++)

for(int j=0;j<4;j++)

p[i][j]=i+j;

for(int i=0;i<5;i++)

for(int j=0;j<4;j++)

{

std::cout<<p[i][j];

if(j==3)

std::cout<<std::endl;

}

此时释放空间：

delete[] p;