二位指针和二位数组理解

最新推荐文章于 2022-05-22 17:53:50 发布
最新推荐文章于 2022-05-22 17:53:50 发布
阅读量2.2k 收藏 5
点赞数
分类专栏： C&C++学习笔记 文章标签： delete im 语言 编译器 测试 存储

下面三种定义形式怎么理解？怎么动态分配空间？
(1)、int **Ptr;
(2)、int *Ptr[ 5 ]; 我更喜欢写成 int* Prt[5];
(3)、int ( *Ptr )[ 5 ];

此文引自网上，出处不详，但是觉得非常好。略改了一点。

多维数组一向很难，一般都采用一维数组，但是一旦要用到还真是头疼。
闲话少说，这里我就以三个二维数组的比较来展开讨论：
     (1)、int **Ptr;
    (2)、int *Ptr[ 5 ]; 我更喜欢写成 int* Prt[5];
     (3)、int ( *Ptr )[ 5 ];
     以上三例都是整数的二维数组，都可以用形如 Ptr[ 1 ][ 1 ] 的
方式访问其内容；但它们的差别却是很大的。下面我从四个方面对它们
进行讨论：
     一、内容：
        它们本身都是指针，它们的最终内容都是整数。注意我这里说
的是最终内容，而不是中间内容，比如你写 Ptr[ 0 ]，对于三者来说，
其内容都是一个整数指针，即 int *；Ptr[ 1 ][ 1   ] 这样的形式才
是其最终内容。
     二、意义：
        (1)、int **Ptr 表示指向"一群"指向整数的指针的指针。
        (2)、int *Ptr[ 5 ] 表示指向 5 个指向整数的指针的指针,或者说Ptr有5个指向"一群"整数的指针，Ptr是这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 ] 等也是个"野"指针，也
是不能用的。当然，用它指向某个已经定义的地址则是允许的，那是另外
的用法（类似于"借鸡生蛋"的做法），这里不作讨论（下同）。

例子：

C语言：

//动态分配二维数组空间
{
   m_iHight=10;//二维数组的高度
m_i;//二维数组的宽度
//动态分配一个二维数组m_ppTable内存空间
//其类型为int
   //m_ppTable指向该数组
   int **m_ppTable;
   m_ppTable=new int *[m_iHight];

//动态分配m_iHight个类型为int *的内存空间
//分配的是行地址空间
   for(int i=0;i
            m_ppTable[i]= new int[m_iWidth];

   //动态分配m_iWidth个类型为int的内存空间
//分配的是某行的数值空间
}
//由此分配的二维数组空间并非是连续的
//可以使用m_ppTable[row][col]来给该二维数组赋值
//其中 0<=row
//释放所分配的内存空间
{
    for(int i=0;i
       delete[m_iWidth]m_ppTable[i]; //以行为单位释放数值空间
    delete [m_iHight]m_ppTable;      //释放行地址空间
}

int **a;
a=(int **)calloc(sizeof(int *),n);
for (i=0;i   a[i]=(int *)calloc(sizeof(int),n);
这样就可以了
使用的时候就和普通的二维数组一样
最后用
for(i=0;i   cfree(a[i]);
cfree(a);释放内存
就可以了
       (2)、int *Ptr[ 5 ]
       这样定义的话，编译器已经为它分配了 5 个指针的空间，这相当
于(1)中的第一次内存分配。根据对(1)的讨论可知，显然要对其进行一次
内存分配的。否则就是"野"指针。
       (3)、int ( *Ptr )[ 5 ]
       这种定义我觉得很费解，不是不懂，而是觉得理解起来特别吃力，
也许是我不太习惯这样的定义吧。怎么描述它呢？它的意义是"一群"
指针，每个指针都是指向一个 5 个整数的数组。如果想分配 k 个指针，
这样写： Ptr = ( int ( * )[ 5 ] ) new int[ 5 * k ]。
这是一次性的内存分配。分配好以后，Ptr 指向一片连续的地址空间，
其中 Ptr[ 0 ] 指向第 0 个 5 个整数数组的首地址，Ptr[ 1 ] 指向第
1 个 5 个整数数组的首地址。
    综上所述，我觉得可以这样理解它们：
    int ** Ptr &lt;==> int Ptr[ x ][ y ];
    int *Ptr[ 5 ] <==> int Ptr[ 5 ][ x ];
    int ( *Ptr )[ 5 ] <==> int Ptr[ x ][ 5 ];
    这里 x 和 y 是表示若干的意思。

_______________________________________________________________

1. C语言动态分配二维数组
(1)已知第二维
Code-1
char (*a)[N]; //指向数组的指针
a = (char (*)[N])malloc(sizeof(char *) * m);
printf("%d/n", sizeof(a)); //4， 指针
printf("%d/n", sizeof(a[0])); //N， 一维数组
free(a);

 

(2)已知第一维
Code-2
char* a[M]; //指针的数组
int i;
for(i=0; i<M; i++)
a[i] = (char *)malloc(sizeof(char) * n);
printf("%d/n", sizeof(a)); //4*M， 指针数组
printf("%d/n", sizeof(a[0])); //4， 指针
for(i=0; i<M; i++)
   free(a[i]);

 

(3)已知第一维，一次分配内存(保证内存的连续性)
Code-3
char* a[M]; //指针的数组
int i;
a[0] = (char *)malloc(sizeof(char) * M * n);
for(i=1; i<M; i++)
a[i] = a[i-1] + n;
printf("%d/n", sizeof(a)); //4*M， 指针数组
printf("%d/n", sizeof(a[0])); //4， 指针
free(a[0]);

 

(4)两维都未知
Code-4
char **a;
int i;
a = (char **)malloc(sizeof(char *) * m); //分配指针数组
for(i=0; i<m; i++)
{
a[i] = (char *)malloc(sizeof(char) * n); //分配每个指针所指向的数组
}
printf("%d/n", sizeof(a)); //4， 指针
printf("%d/n", sizeof(a[0])); //4， 指针
for(i=0; i<m; i++)
{
free(a[i]);
}
free(a);

 

(5)两维都未知，一次分配内存(保证内存的连续性)
Code-5
char **a;
int i;
a = (char **)malloc(sizeof(char *) * m); //分配指针数组
a[0] = (char *)malloc(sizeof(char) * m * n); //一次性分配所有空间
for(i=1; i<m; i++)
{
a[i] = a[i-1] + n;
}
printf("%d/n", sizeof(a)); //4， 指针
printf("%d/n", sizeof(a[0])); //4， 指针
free(a[0]);
free(a);

 

2.C++动态分配二维数组
(1)已知第二维
Code-6
char (*a)[N]; //指向数组的指针
a = new char[m][N];
printf("%d/n", sizeof(a)); //4， 指针
printf("%d/n", sizeof(a[0])); //N， 一维数组
delete[] a;

 

(2)已知第一维
Code-7
char* a[M]; //指针的数组
for(int i=0; i<M; i++)
   a[i] = new char[n];
printf("%d/n", sizeof(a)); //4*M， 指针数组
printf("%d/n", sizeof(a[0])); //4， 指针
for(i=0; i<M; i++)
   delete[] a[i];

 

(3)已知第一维，一次分配内存(保证内存的连续性)
Code-8
char* a[M]; //指针的数组
a[0] = new char[M*n];
for(int i=1; i<M; i++)
a[i] = a[i-1] + n;
printf("%d/n", sizeof(a)); //4*M， 指针数组
printf("%d/n", sizeof(a[0])); //4， 指针
delete[] a[0];

 

(4)两维都未知
Code-9
char **a;
a = new char* [m]; //分配指针数组
for(int i=0; i<m; i++)
{
a[i] = new char[n]; //分配每个指针所指向 的数组
}
printf("%d/n", sizeof(a)); //4， 指针
printf("%d/n", sizeof(a[0])); //4， 指针
for(i=0; i<m; i++)
delete[] a[i];
delete[] a;

 

(5)两维都未知，一次分配内存(保证内存的连续性)
Code-10
char **a;
a = new char* [m];
a[0] = new char[m * n]; //一次性分配 所有空间
for(int i=1; i<m; i++)
{
a[i] = a[i-1] + n; //分配每个指针所指向的 数组
}
printf("%d/n", sizeof(a)); //4， 指针
printf("%d/n", sizeof(a[0])); //4， 指针
delete[] a[0];
delete[] a;

 

多说一句：new和delete要注意配对使用，即有多少个 new就有多少个delete，这样才可以避免内存泄漏！
3.静态二维数组作为函数参数传递
如果采用上述几种方法动态分配二维数组，那么将对应的数据类型作为函数参数就可以了。这里讨论静态二维数组作为函数参数传递，即按照以下的调用 方式：
int a[2][3];
func(a);
C语言中将静态二维数组作为参数传递比较麻烦，一般需要指明第二维的长度，如果不给定第二维长度，则只能先将其作为一维指针传递，然后利用二维 数组的线性存储特性，在函数体内转化为对指定元素的访问。
首先写好测试代码，以验证参数传递的正确性：
(1)给定第二维长度
Code-11
void func(int a[][N])
{
printf("%d/n", a[1][2]);
}

 

(2)不给定第二维长度
Code-12
void func(int* a)
{
printf("%d/n", a[1 * N + 2]); // 计算元素位置
}

 

注意：使用该函数时需要将二维数组首地址强制转换为一维指针，即func((int*)a);

 

1. C语言动态分配二维数组
(1)已知第二维
Code-1
char (*a)[N]; //指向数组的指针
a = (char (*)[N])malloc(sizeof(char *) * m);
printf("%d/n", sizeof(a)); //4， 指针
printf("%d/n", sizeof(a[0])); //N， 一维数组
free(a);
(2)已知第一维
Code-2
char* a[M]; //指针的数组
int i;
for(i=0; i<M; i++)
a[i] = (char *)malloc(sizeof(char) * n);
printf("%d/n", sizeof(a)); //4*M， 指针数组
printf("%d/n", sizeof(a[0])); //4， 指针
for(i=0; i<M; i++)
   free(a[i]);
(3)已知第一维，一次分配内存(保证内存的连续性)
Code-3
char* a[M]; //指针的数组
int i;
a[0] = (char *)malloc(sizeof(char) * M * n);
for(i=1; i<M; i++)
a[i] = a[i-1] + n;
printf("%d/n", sizeof(a)); //4*M， 指针数组
printf("%d/n", sizeof(a[0])); //4， 指针
free(a[0]);
(4)两维都未知
Code-4
char **a;
int i;
a = (char **)malloc(sizeof(char *) * m); //分配指针数组
for(i=0; i<m; i++)
{
a[i] = (char *)malloc(sizeof(char) * n); //分配每个指针所指向的数组
}
printf("%d/n", sizeof(a)); //4， 指针
printf("%d/n", sizeof(a[0])); //4， 指针
for(i=0; i<m; i++)
{
free(a[i]);
}
free(a);
(5)两维都未知，一次分配内存(保证内存的连续性)
Code-5
char **a;
int i;
a = (char **)malloc(sizeof(char *) * m); //分配指针数组
a[0] = (char *)malloc(sizeof(char) * m * n); //一次性分配所有空间
for(i=1; i<m; i++)
{
a[i] = a[i-1] + n;
}
printf("%d/n", sizeof(a)); //4， 指针
printf("%d/n", sizeof(a[0])); //4， 指针
free(a[0]);
free(a);
2.C++动态分配二维数组
(1)已知第二维
Code-6
char (*a)[N]; //指向数组的指针
a = new char[m][N];
printf("%d/n", sizeof(a)); //4， 指针
printf("%d/n", sizeof(a[0])); //N， 一维数组
delete[] a;
(2)已知第一维
Code-7
char* a[M]; //指针的数组
for(int i=0; i<M; i++)
   a[i] = new char[n];
printf("%d/n", sizeof(a)); //4*M， 指针数组
printf("%d/n", sizeof(a[0])); //4， 指针
for(i=0; i<M; i++)
   delete[] a[i];
(3)已知第一维，一次分配内存(保证内存的连续性)
Code-8
char* a[M]; //指针的数组
a[0] = new char[M*n];
for(int i=1; i<M; i++)
a[i] = a[i-1] + n;
printf("%d/n", sizeof(a)); //4*M， 指针数组
printf("%d/n", sizeof(a[0])); //4， 指针
delete[] a[0];
(4)两维都未知
Code-9
char **a;
a = new char* [m]; //分配指针数组
for(int i=0; i<m; i++)
{
a[i] = new char[n]; //分配每个指针所指向 的数组
}
printf("%d/n", sizeof(a)); //4， 指针
printf("%d/n", sizeof(a[0])); //4， 指针
for(i=0; i<m; i++)
delete[] a[i];
delete[] a;
(5)两维都未知，一次分配内存(保证内存的连续性)
Code-10
char **a;
a = new char* [m];
a[0] = new char[m * n]; //一次性分配 所有空间
for(int i=1; i<m; i++)
{
a[i] = a[i-1] + n; //分配每个指针所指向的 数组
}
printf("%d/n", sizeof(a)); //4， 指针
printf("%d/n", sizeof(a[0])); //4， 指针
delete[] a[0];
delete[] a;
多说一句：new和delete要注意配对使用，即有多少个 new就有多少个delete，这样才可以避免内存泄漏！
3.静态二维数组作为函数参数传递
如果采用上述几种方法动态分配二维数组，那么将对应的数据类型作为函数参数就可以了。这里讨论静态二维数组作为函数参数传递，即按照以下的调用 方式：
int a[2][3];
func(a);
C语言中将静态二维数组作为参数传递比较麻烦，一般需要指明第二维的长度，如果不给定第二维长度，则只能先将其作为一维指针传递，然后利用二维 数组的线性存储特性，在函数体内转化为对指定元素的访问。
首先写好测试代码，以验证参数传递的正确性：
(1)给定第二维长度
Code-11
void func(int a[][N])
{
printf("%d/n", a[1][2]);
}
(2)不给定第二维长度
Code-12
void func(int* a)
{
printf("%d/n", a[1 * N + 2]); // 计算元素位置
}
注意：使用该函数时需要将二维数组首地址强制转换为一维指针，即func((int*)a);
echo_qiang
关注
专栏目录
二维指针是什么
zhiying678的专栏
11-08 1227
看到群里有人问二维指针的问题， 就写代码测试了一下， #define M 3 #define N 5 int array[M][N]={ 1,2,3,4,5, 6,7,8,9,10, 11,12,13,14,15 };//这是一个二维数组，全局变量 typedef int (*myPointer)[N];//定义一种变量类型，指向 含有N个元素的一维数组 的指针 type
c语言二维指针类型转换,二维数组和指针(C语言）
weixin_32421297的博客
05-19 1472
二维数组和指针二维数组和指针1、二维数组和数组元素的地址若有以下定义：int *p,a[3][4];1)二维数组a由若干个一维数组组成在C语言中定义的二维数组实际上是一个一维数组，这个一维数组的每一个成员又是一个一维数组。如以上定义的a数组，则可视a数组由a[0]、a[1]、a[2]等三个元素组成，而a[0]、a[1]、a[2]等每个元素又分别是由4个整型元素组成的一维数组。可用a[0][0]、a...
二位数组名的理解
xiezhongkai08的专栏
10-31 765
二维指针（指向指针的指针）
weixin_43384504的博客
07-11 1872
参考博主：https://blog.csdn.net/liuweiyuxiang/article/details/84769438 看一下 下面的代码： #include<stdio.h> int find(char *s, char src, char *rt)//从s中查询出src字符所在的位置并在rt中返回。 { int i = 0; while (*(s + i)) { if (*(s + i) == src)//只会出现一次满足条件，此时将此地址给*rt，即p {
二维数组和二维指针
songxueyu的专栏
09-25 793
入职一年了，这一年自己学到许多，但是忘记也很多，于是决定定下心来整理以前学到的，并且继续学习          二维数组和二级指针，这真是头疼的问题，困扰了我好几次，         先转一下wanpengcoder的二维数组和二级指针  前两天写个程序，传参数的时候想传个二维数组进去，结果悲剧了，函数写成Fun (int **p){},原来没有这么写过， 以为这么写也是对
C语言中，一级指针，二级指针，数组，一位数组指针，二位数组指针浅谈
孤峰傲竹的专栏
02-04 508
最近在做linux内核中发现，有很多关于指针和数组的应用问题，细细研究，发现受益匪浅，将整个分析和收获分享出来，希望高手指正。 1.指针     指针，顾名思义，就是指向一个内存单元的特殊数据单元，这个很好理解，如:         int a;         int *p;         a = 10;         p = &a;         printf("a=%
c语言二维数与指针,二维数组与指针（教程）
weixin_39712821的博客
05-19 852
二维数组与指针(教程)二维数组与指针1．二维数组元素在内存中的存放方式在C++中，二维数组元素值在内存中是按行的顺序存放的。若定义二维整型数组a[3][3]，假设编译系统为数组a分配的内存空间从1000开始到1035为止，则数组中各元素a[0][0]~a[2][2]在内存中按行存放次序如图7.6所示。因此，与一维数组类似，可用指针变量来访问二维数组元素。【例7.7】用指针变量输出二维数组各元素...
二级指针与二维数组
FKDXM的博客
04-26 4207
二级指针 一级指针指向的是变量的首地址，二级指针指向的是一级指针的首地址。 整型变量a；一级整型指针变量p；二级整型指针变量s。 s本身是p的地址；p本身是a的地址；a本身是数据0。 *s是p本身；*p是a本身。 **s是a本身。 int main() { int a = 0; int* p = &a; int** s = &p; printf("%d \n", a); printf("%p \n", p); printf("%p \n", s); **s += 1;
指针和二维数组-使用普通指针访问二维数组
零界
01-01 833
#include <stdlib.h> #include <stdio.h> int main(void){ int A[3][4] ={ {81, 32, 33, 44}, {35, 60, 85, 20}, {16, 53, 45, 555} }; //指针存储值 int *p = NULL; int *you = NULL; //定义指针用于遍历二维数组 you = &A[0][0]; //等同于 you = A[0]; p =.
读取二维数组所有数据_labview读取数组_
09-29
打开VI，通过分析连线和VI结构，可以更深入地理解如何在LabVIEW中操作二维数组。 总的来说，LabVIEW提供了一套完整的工具来处理二维数组，包括创建、读取、遍历和保存。熟练掌握这些技巧，将使你在处理复杂数据任务...
二维指针的详解
06-26
很好的讲解了二维指针，可以看文档自学，很适合初学者。
第 七篇，二维指针和二维数组知识讲解。
weixin_44651073的博客
02-22 2539
二维指针和数组详细讲解
C语言二维指针
qq_65337539的博客
05-22 2611
c语言二维指针操作
C语言进阶——3.二维指针
Sunrise的博客
04-11 5227
C语言进阶——3.二维指针 1. 什么是二维指针 二维指针与一维指针一样都是保存地址的变量。 示例1 #include <stdio.h> int main(){ int n=0,m=0; printf("&n=%p\n",&n); printf("&m=%p\n",&m); int* p = NULL; ...
二维指针的具体含义
CYL641的博客
03-06 1234
对初学者而言，多维指针可能属于比较难辨析明白的内容，下面用具体例子表示其不同之处 #include<stdio.h> #define pr printf int main(void) { int a = 1; int* b = &a; int**c = &b; pr("a为int变量，b为指向a的int指针，c为指向指针b的二维指针\n\n"); pr("证明...
二维数值与指针
刘先森的博客
08-17 3147
在讨论二维指针时，我们可以把二维指针看成由多个一维指针构成，然后对他进行理解。 由一个简单的表格： 该图表示二维数组地址、二维数组名、一维数组地址、一维数组名、元素地址、元素的关系图： 他们之间的关系：二维数组地址代表这个二维数组的地址，二维数组名表示二维数组名同时也存储了一维数组的地址，一维数组名也存储了元素的地址，（注：二维数组的地址和一维数组的地址和数组首个元素的地址他
二维指针的使用
qq_42754083的博客
10-12 6307
#include #include #include int main() { int ** p; // p = (int **)malloc(10*sizeof(int ));//p指向一个指针 p = new int[10]; for (int i = 0; i &lt; 10; i++) { // *(p + i ) = (int )malloc(10sizeof(int)); *(p...
二维数组指针
热门推荐
chengchaonan的博客
04-04 1万+
int a[5]={1,2,3,4,5}; int *p=(int *)(&a+1); int *q=(int *)&a; printf("%p,%p,%p",a,p,q+1); 本身a作为一个地址，p作为指向a的地址，相当于一个二维指针， 一个二维指针加一相当于移动了一行，所以这里是移动了5*4个字节，而对于q+1的情况，说明移动了4个字节...
C语言指针与数组：输出二维数组元素
"C语言编程-二维数组元素的输出与指针操作" 在C语言中，二维数组可以看作是一维数组的数组，每个一维数组又包含若干个元素。本题涉及的知识点主要包括二维数组的定义、指针的使用以及通过指针遍历二维数组并输出...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值