下载文档原格式
指针数组和数组指针释放指针数组和数组指针是C语言中常见的概念，它们在内存管理和数据访问方面起着重要作用。
本文将从人类视角出发，以真实的叙述方式介绍指针数组和数组指针的释放。
在C语言中，指针数组和数组指针都是指针的应用形式，它们与普通的数组有所不同。
指针数组是一个数组，其元素是指针类型；而数组指针是一个指针，指向一个数组。
两者在释放内存时需要注意不同的操作。
我们来看指针数组的释放。
假设我们有一个指针数组ptrArray，其中包含了若干个指针。
在释放内存之前，我们需要逐个释放数组中的指针指向的内存块。
可以通过循环遍历数组的方式，依次释放每个指针指向的内存。
释放完毕后，再使用free函数释放指针数组本身所占用的内存。
这样，我们就完成了指针数组的释放过程。
接下来，我们来看数组指针的释放。
假设我们有一个数组指针pArray，指向一个数组。
在释放内存之前，我们只需使用一次free 函数即可释放整个数组所占用的内存。
因为数组指针指向的是一个连续的内存块，只需释放一次即可。
需要注意的是，在释放指针数组和数组指针时，应确保内存的正确释放顺序。
先释放指针数组中的指针，再释放指针数组本身；先释放数组指针指向的内存，再释放数组指针本身。
这样可以避免内存泄漏和悬空指针的问题。
总结一下，指针数组和数组指针的释放方法是不同的。
对于指针数组，需要逐个释放数组中的指针，并最后释放指针数组本身；对于数组指针，只需一次释放即可。
在释放内存时，需要注意释放的顺序，以确保内存的正确释放。
通过以上的叙述，希望读者能够更好地理解指针数组和数组指针的释放方法，并能够正确地应用于实际的程序开发中。
同时也希望读者能够通过本文的描述，感受到指针数组和数组指针的重要性，以及在内存管理中的作用。
让我们一起努力，深入理解指针数组和数组指针，提升自己在C语言中的编程能力。
C语言中的数组和指针赋值引言在C语言中，数组和指针是常用的数据类型，并且在许多情况下需要使用赋值操作来初始化数组或为数组元素赋值。
本文将全面介绍C语言中数组和指针的赋值操作，并详细解释它们之间的关系。
数组赋值数组是一种存储相同数据类型元素的集合，并且在内存中是连续分布的。
在C语言中，可以使用以下方式来声明和初始化一个数组：// 声明一个包含5个整数的数组int arr[5];// 初始化数组的元素arr[0] = 10;arr[1] = 20;arr[2] = 30;arr[3] = 40;arr[4] = 50;上述代码中，我们首先声明了一个包含5个整数的数组arr，然后通过arr[index]的方式为数组的每个元素赋值。
需要注意的是，数组的索引从0开始，因此数组的第一个元素的索引是0，第二个元素的索引是1，以此类推。
除了逐个赋值的方式，C语言还提供了一种便捷的初始化数组的方法，即使用花括号（{}）将元素的值括起来，多个元素之间用逗号分隔。
下面是使用这种方式初始化数组的示例：int arr[5] = {10, 20, 30, 40, 50};此时，数组arr的元素会按照花括号中的顺序被赋予对应的值。
如果数组的大小小于花括号中的元素个数，剩余元素将被自动赋值为0。
如果数组的大小大于花括号中的元素个数，将初始化数组的前面几个元素，其他元素保持默认值（0）。
我们还可以通过循环来赋值数组的元素，特别是在数组非常大的情况下。
下面是使用循环赋值数组元素的示例：int arr[100];int i;for (i = 0; i < 100; i++) {arr[i] = i;}在上述代码中，我们声明了一个包含100个整数的数组arr，然后使用循环为数组的每个元素赋值。
循环变量i的值从0递增到99，依次为数组的索引。
指针赋值指针是一种特殊的数据类型，用于存储内存地址。
在C语言中，可以使用指针来访问和修改内存中的数据。
● 数组：数组是具有一定顺序关系的若干对象的集合体，组成数组的对象称为该数组的元素。
▲ 每个元素有n个下标的数组称为n维数组。
▲ a［100］：下标从0开始，到99止，不能为100。
▲ a［i］［j］：i为行标，j为下标。
● 数组的声明：数组类型数组名［表达式1］［表达式2］……● 数组的使用：数组类型数组名［表达式1］［表达式2］……● 数组的存储：数组元素在内存中是顺序、连续存储的。
● 数组的初始化：就是在声明数组时给部分或全部元素赋初值。
▲ int a[3]={1,2,3}; 等价于 int[]{1,2,3};▲ int a[5]={1,2,3}; //部分初始化，必须连续，不能间隔赋初值▲ int a[2][3]={1,2,3,4,5,6}; 等价于 int a[][3]={1,2,3,4,5,6} //给出全部的初值时，行标可省▲ int a[2][3]={{1,2},{3,4},{5,6}};● 数组作为函数参数▲ 使用数组名传递数据时，传递的是地址▲ 使用数组名做函数的参数，则实参和形参都应该是数组名，且类型要相同▲ 对形参数组的修改，也就是对实参数组的修改▲ int ss(int a[][4],int bb) 调用：ss(b,x); //b是数组，x传递的是第一维的维数● 对象数组▲ 声明：类名数组名[下标表达式]▲ 引用：数组名[下标].成员名▲ 当一个数组中的元素对象被删除时，系统会调用析构函数来完成扫尾工作。
● 指针：是对地址直接操作的手段。
动态内存分配和管理也离不开指针● 指针类型：用来存放内存单元地址的变量类型，就是指针类型。
● 指针变量的声明：数据类型 *标识符；● 与地址相关的运算——"*"和"&"▲ "*"称为指针运算符（也称解析（dereference））,表示获取指针所指向的变量的值，是一元操作符。
C语言指针用法详解C语言指针用法详解指针可以说是集C语言精华之所在，一个C语言达人怎么可以不会指针呢。
下面店铺给大家介绍C语言指针用法，欢迎阅读!C语言指针用法详解(1)关于指针与数组的存储a、指针和数组在内存中的存储形式数组p[N]创建时，对应着内存中一个数组空间的分配，其地址和容量在数组生命周期内一般不可改变。
数组名p本身是一个常量，即分配数组空间的地址值，这个值在编译时会替换成一个常数，在运行时没有任何内存空间来存储这个值，它和数组长度一起存在于代码中(应该是符号表中)，在链接时已经制定好了;而指针*p创建时，对应内存中这个指针变量的空间分配，至于这个空间内填什么值即这个指针变量的值是多少，要看它在程序中被如何初始化，这也决定了指针指向哪一块内存地址。
b、指针和数组的赋值与初始化根据上文，一般情况下，数组的地址不能修改，内容可以修改;而指针的内容可以修改，指针指向的内容也可以修改，但这之前要为指针初始化。
如：int p[5];p=p+1; 是不允许的而p[0]=1; 是可以的;//int *p;p=p+1; 是允许的p[0]=1; 是不允许的，因为指针没有初始化;//int i;int *p=&i;p[0]=1; 是允许的;对于字符指针还有比较特殊的情况。
如：char * p="abc";p[0]='d'; 是不允许的为什么初始化了的字符指针不能改变其指向的内容呢?这是因为p 指向的是“常量”字符串，字符串"abc"实际是存储在程序的静态存储区的，因此内容不能改变。
这里常量字符串的地址确定在先，将指针指向其在后。
而char p[]="abc";p[0]='d'; 是允许的这是因为，这个初始化实际上是把常量直接赋值给数组，即写到为数组分配的内存空间。
这里数组内存分配在先，赋值在后。
(2)关于一些表达式的含义char *p, **p, ***p;char p[],p[][],p[][][];char *p[],*p[][],**p[],**p[][],*(*p)[],(**p)[],(**p)[][];能清晰地知道以上表达式的含义吗?(知道的去死!)第一组：char *p, **p, ***p;分别为char指针;char*指针，即指向char*类型数据地址的指针;char**指针，即指向char**类型数据的指针;他们都是占4字节空间的指针。
数组与指针一个变量有地址，一个数组包含若干元素，每个数组元素都在内存中占用存储单元，它们都有相应的地址，所谓数组元素的指针就是数组元素的地址。
引用数组元素可以用下标（如a[3]），也可以用指针法，即通过指向数组元素的指针找到所需的元素。
使用指针法能使目标程序质量高（占内存少，运行速度快）。
一维数组和指针1．指向数组元素的指针例：int a[10]; /*定义a为包含10个整型数据的数组*/int *p; /*定义p为指向整型变量的指针变量*/p=&a[0]; 把a[0]元素的地址赋给指针变量p。
也就是说，p指向a数组的第0号元素。
C 语言规定数组名代表数组中第一个元素（即序号为0的元素）的地址，因此下面两个语句等价：p=&a[0]; 与p=a 等价。
注意：数组名不代表整个数组，“p=a”的作用把a数组的首元素的地址赋给指针变量p，而不是把数组a各元素的值赋给p.在定义指针变量时，可以对它赋初值：int *p=&a[0];或int *p=a;2．通过数组的首地址引用数组元素由以上可知：a是a数组元素的首地址，a(即:a+0)的值就等于&a[0]；则a+1的值，就等于&a[1], a+2就等于&a[2],……a+9就等于&a[9]这里，可以通过”取地址运算符*”来引用地址所在的存储单元，因此，对于数组元素a[0]，可以通过表达式*&a[0]来引用，也可以用*(a+0)来引用，对此也可以写成:*a;而对于数组元素a[1]，可以用表达式*&a[1]来引用，也可以用*(a+1)来引用……对于a[9]可以用*&a[9]来引用，也可以用*(a+9)来引用。
因此可以通过以下的语句输出a数组元素中的值：for(k=0;k<10;k++) printf(“%4d”,*(a+k));就相当于：for(k=0;k<10;k++) printf(“%4d”,a[k]);3.通过指针引用数组元素假如p已定义为一个指向整型数据的指针变量，并已给它赋了个整型数组元素的地址，使它指向某一个数组元素。
数组指针和指针数组的区别数组指针（也称⾏指针）定义 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][]所以数组指针也称指向⼀维数组的指针，亦称⾏指针。
指针数组定义 int *p[n];[]优先级⾼，先与p结合成为⼀个数组，再由int*说明这是⼀个整型指针数组，它有n个指针类型的数组元素。
这⾥执⾏p+1时，则p指向下⼀个数组元素，这样赋值是错误的：p=a；因为p是个不可知的表⽰，只存在p[0]、p[1]、p[2]...p[n-1],⽽且它们分别是指针变量可以⽤来存放变量地址。
但可以这样 *p=a; 这⾥*p表⽰指针数组第⼀个元素的值，a的⾸地址的值。
如要将⼆维数组赋给⼀指针数组:int *p[3];int a[3][4];p++; //该语句表⽰p数组指向下⼀个数组元素。
注：此数组每⼀个元素都是⼀个指针for(i=0;i<3;i++)p[i]=a[i]这⾥int *p[3] 表⽰⼀个⼀维数组内存放着三个指针变量，分别是p[0]、p[1]、p[2]所以要分别赋值。
这样两者的区别就豁然开朗了，数组指针只是⼀个指针变量，似乎是C语⾔⾥专门⽤来指向⼆维数组的，它占有内存中⼀个指针的存储空间。
指针数组是多个指针变量，以数组形式存在内存当中，占有多个指针的存储空间。
还需要说明的⼀点就是，同时⽤来指向⼆维数组时，其引⽤和⽤数组名引⽤都是⼀样的。
⽐如要表⽰数组中i⾏j列⼀个元素：*(p[i]+j)、*(*(p+i)+j)、(*(p+i))[j]、p[i][j]优先级：()>[]>*=========================================================================⼀、指针数组和数组指针的内存布局初学者总是分不出指针数组与数组指针的区别。
指针二维数组的各种表示指针是C语言中的一种数据类型，它存储了一个变量的地址。
而二维数组是由多个一维数组组成的数据结构。
在C语言中，我们可以使用指针来表示二维数组。
本文将介绍指针二维数组的各种表示方法，包括指针数组、数组指针和指针的指针。
一、指针数组指针数组是一种由指针组成的数组，每个指针指向一个一维数组。
我们可以使用指针数组来表示二维数组。
假设有一个二维数组arr，它有m行n列，我们可以定义一个指针数组来表示它。
```cint *ptr[m];```这里ptr是一个指针数组，它有m个元素，每个元素都是一个指针，指向一个一维数组。
我们可以通过给每个指针赋值来初始化指针数组。
```cfor(int i=0; i<m; i++){ptr[i] = arr[i];}```二、数组指针数组指针是指向数组的指针，我们可以使用数组指针来表示二维数组。
假设有一个二维数组arr，它有m行n列，我们可以定义一个数组指针来表示它。
```cint (*ptr)[n];```这里ptr是一个数组指针，它指向一个有n列的一维数组。
我们可以通过给数组指针赋值来初始化它。
```cptr = arr;```三、指针的指针指针的指针是指向指针的指针变量，我们可以使用指针的指针来表示二维数组。
假设有一个二维数组arr，它有m行n列，我们可以定义一个指针的指针来表示它。
```cint **ptr;```这里ptr是一个指针的指针，它指向一个指针数组。
我们可以通过给指针的指针赋值来初始化它。
```cptr = (int **)malloc(m * sizeof(int *));for(int i=0; i<m; i++){ptr[i] = arr[i];}```四、比较与应用通过以上的介绍，我们可以看到指针数组、数组指针和指针的指针都可以用来表示二维数组。
它们各有优缺点，适用于不同的场景。
指针数组比较灵活，可以动态改变指针的指向，适用于需要频繁修改二维数组的情况。
CC++——⼆维数组与指针、指针数组、数组指针（⾏指针）、⼆级指针的⽤法1. ⼆维数组和指针要⽤指针处理⼆维数组，⾸先要解决从存储的⾓度对⼆维数组的认识问题。
我们知道，⼀个⼆维数组在计算机中存储时，是按照先⾏后列的顺序依次存储的，当把每⼀⾏看作⼀个整体，即视为⼀个⼤的数组元素时，这个存储的⼆维数组也就变成了⼀个⼀维数组了。
⽽每个⼤数组元素对应⼆维数组的⼀⾏，我们就称之为⾏数组元素，显然每个⾏数组元素都是⼀个⼀维数组下⾯我们讨论指针和⼆维数组元素的对应关系，清楚了⼆者之间的关系，就能⽤指针处理⼆维数组了。
设p是指向⼆维数组a[m][n]的指针变量，则有：int* p=a[0];//此时P是指向⼀维数组的指针。
P++后，p指向 a[0][1]。
如果定义int (*p1)[n];p1=a;p1++后，p1指向a[1][0];则p+j将指向a[0]数组中的元素a[0][j]。
由于a[0]、a[1]┅a[M-1]等各个⾏数组依次连续存储，则对于a数组中的任⼀元素a[i][j]，指针的⼀般形式如下：p+i*N+j 相应的如果⽤p1来表⽰，则为*(p1+i)+j元素a[i][j]相应的指针表⽰为：*( p+i*N+j) 相应的如果⽤p1来表⽰，则为*(*(p1+i)+j)同样，a[i][j]也可使⽤指针下标法表⽰，如下：p[i*N+j]例如，有如下定义：int a[3][4]={{10,20,30,40,},{50,60,70,80},{90,91,92,93}};则数组a有3个元素，分别为a[0]、a[1]、a[2]。
⽽每个元素都是⼀个⼀维数组，各包含4个元素，如a[1]的4个元素是a[1][0]、a[1][1]、a[1]2]、a[1][3]。
若有：int *p=a[0];则数组a的元素a[1][2]对应的指针为：p+1*4+2元素a[1][2]也就可以表⽰为：*( p+1*4+2)⽤下标表⽰法，a[1][2]表⽰为：p[1*4+2]特别说明：对上述⼆维数组a，虽然a[0]、a都是数组⾸地址，但⼆者指向的对象不同，a[0]是⼀维数组的名字，它指向的是a[0]数组的⾸元素，对其进⾏“*”运算，得到的是⼀个数组元素值，即a[0]数组⾸元素值，因此，*a[0]与a[0][0]是同⼀个值；⽽a是⼀个⼆维数组的名字，它指向的是它所属元素的⾸元素，它的每⼀个元素都是⼀个⾏数组，因此，它的指针移动单位是“⾏”，所以a+i指向的是第i个⾏数组，即指向a[i]。
一、指针数组和数组指针的内存布局
初学者总是分不出指针数组与数组指针的区别。
其实很好理解：
指针数组：首先它是一个数组，数组的元素都是指针，数组占多少个字节由数组本身决定。
它是“储存指针的数组”的简称。
数组指针：首先它是一个指针，它指向一个数组。
在32 位系统下永远是占4 个字节，至于它指向的数组占多少字节，不知道。
它是“指向数组的指针”的简称。
下面到底哪个是数组指针，哪个是指针数组呢：
A)
int *p1[10];
B)
int (*p2)[10];
每次上课问这个问题，总有弄不清楚的。
这里需要明白一个符号之间的优先级问题。
“[]”的优先级比“*”要高。
p1 先与“[]”结合，构成一个数组的定义，数组名为p1，int *修饰的是数组的内容，即数组的每个元素。
那现在我们清楚，这是一个数组，其包含10 个指向int 类型数据的指针，即指针数组。
至于p2 就更好理解了，在这里“（）”的优先级比“[]”高，“*”号和p2 构成一个指针的定义，指针变量名为p2，int 修饰的是数组的内容，即数组的每个元素。
数组在这里并没有名字，是个匿名数组。
那现在我们清楚p2 是一个指针，它指向一个包含10 个int 类型数据的数组，即数组指针。
我们可以借助下面的图加深理解：
二、int (*)[10] p2-----也许应该这么定义数组指针
这里有个有意思的话题值得探讨一下：平时我们定义指针不都是在数据类型后面加上指针变量名么？这个指针p2 的定义怎么不是按照这个语法来定义的呢？
也许我们应该这样来定义p2：
int (*)[10] p2;
int (*)[10]是指针类型，p2 是指针变量。
这样看起来的确不错，不过就是样子有些别扭。
其实数组指针的原型确实就是这样子的，只不过为了方便与好看把指针变量p2 前移了而已。
你私下完全可以这么理解这点。
虽然编译器不这么想。
^_^
三、再论a 和&a 之间的区别
既然这样，那问题就来了。
前面我们讲过a 和&a 之间的区别，现在再来看看下面的代码：
int main()
{
char a[5]={'A','B','C','D'};
char (*p3)[5] = &a;
char (*p4)[5] = a;
return 0;
}
上面对p3 和p4 的使用，哪个正确呢？p3+1 的值会是什么？p4+1 的值又会是什么？毫无疑问，p3 和p4 都是数组指针，指向的是整个数组。
&a 是整个数组的首地址，a是数组首元素的首地址，其值相同但意义不同。
在C 语言里，赋值符号“=”号两边的数据类型必须是相同的，如果不同需要显示或隐式的类型转换。
p3 这个定义的“=”号两边的数据类型完全一致，而p4 这个定义的“=”号两边的数据类型就不一致了。
左边的类型是指向整个数组的指针，右边的数据类型是指向单个字符的指针。
在Visual C++6.0 上给出如下警告：warning C4047: 'initializing' : 'char (*)[5]' differs in levels of indirection from 'char *'。
还好，这里虽然给出了警告，但由于&a 和a 的值一样，而变量作为右值时编译器只是取变量的值，所以运行并没有什么问题。
不过我仍然警告你别这么用。
既然现在清楚了p3 和p4 都是指向整个数组的，那p3+1 和p4+1 的值就很好理解了。
但是如果修改一下代码，会有什么问题？p3+1 和p4+1 的值又是多少呢？
int main()
{
char a[5]={'A','B','C','D'};
char (*p3)[3] = &a;
char (*p4)[3] = a;
return 0;
}
甚至还可以把代码再修改：
int main()
{
char a[5]={'A','B','C','D'};
char (*p3)[10] = &a;
char (*p4)[10] = a;
return 0;
}
这个时候又会有什么样的问题？p3+1 和p4+1 的值又是多少？
上述几个问题，希望读者能仔细考虑考虑。
四、地址的强制转换
先看下面这个例子：
struct Test
{
int Num;
char *pcName;
short sDate;
char cha[2];
short sBa[4];
}*p;
假设p 的值为0x100000。
如下表表达式的值分别为多少？
p + 0x1 = 0x___ ?
(unsigned long)p + 0x1 = 0x___?
(unsigned int*)p + 0x1 = 0x___?
我相信会有很多人一开始没看明白这个问题是什么意思。
其实我们再仔细看看，这个知识点似曾相识。
一个指针变量与一个整数相加减，到底该怎么解析呢？
还记得前面我们的表达式“a+1”与“&a+1”之间的区别吗？其实这里也一样。
指针变量与一个整数相加减并不是用指针变量里的地址直接加减这个整数。
这个整数的单位不是byte 而是元素的个数。
所以：p + 0x1 的值为0x100000+sizof （Test）*0x1。
至于此结构体的大小为20byte，前面的章节已经详细讲解过。
所以p +0x1 的值为：0x100014。
(unsigned long)p + 0x1 的值呢？这里涉及到强制转换，将指针变量p 保存的值强制转换成无符号的长整型数。
任何数值一旦被强制转换，其类型就改变了。
所以这个表达式其实就是一个无符号的长整型数加上另一个整数。
所以其值为：0x100001。
(unsigned int*)p + 0x1 的值呢？这里的p 被强制转换成一个指向无符号整型的指针。
所以其值为：0x100000+sizof（unsigned int）*0x1，等于0x100004。
上面这个问题似乎还没啥技术含量，下面就来个有技术含量的：在x86 系统下，其值为多少？
intmain()
{
int a[4]={1,2,3,4};
int *ptr1=(int *)(&a+1);
int *ptr2=(int *)((int)a+1);
printf("%x,%x",ptr1[-1],*ptr2);
return 0;
}
这是我讲课时一个学生问我的题，他在网上看到的，据说难倒了n 个人。
我看题之后告诉他，这些人肯定不懂汇编，一个懂汇编的人，这种题实在是小case。
下面就来分析分析这个问题：
根据上面的讲解，&a+1 与a+1 的区别已经清楚。
ptr1：将&a+1 的值强制转换成int*类型，赋值给int* 类型的变量ptr，ptr1 肯定指到数组a 的下一个int 类型数据了。
ptr1[-1]被解析成*(ptr1-1)，即ptr1 往后退4 个byte。
所以其值为0x4。
ptr2：按照上面的讲解，(int)a+1 的值是元素a[0]的第二个字节的地址。
然后把这个地址强制转换成int*类型的值赋给ptr2，也就是说*ptr2 的值应该为元素a[0]的第二个字节开始的连续4 个byte 的内容。
其内存布局如下图：
好，问题就来了，这连续 4 个byte 里到底存了什么东西呢？也就是说元素a[0],a[1]里面的值到底怎么存储的。
这就涉及到系统的大小端模式了，如果懂汇编的话，这根本就不是问题。
既然不知道当前系统是什么模式，那就得想办法测试。
大小端模式与测试的方法在第一章讲解union 关键字时已经详细讨论过了，请翻到彼处参看，这里就不再详述。
我们可以用下面这个函数来测试当前系统的模式。
int checkSystem( )
{
union check
{
int i;
char ch;
} c;
c.i = 1;
return (c.ch ==1);
}
如果当前系统为大端模式这个函数返回0；如果为小端模式，函数返回1。
也就是说如果此函数的返回值为1 的话，*ptr2 的值为0x2000000。
如果此函数的返回值为0 的话，*ptr2 的值为0x100。
