再谈指针数组与数组指针

【导语】“别打直球可以吗”通过精心收集，向本站投稿了10篇再谈指针数组与数组指针，以下是小编整理后的再谈指针数组与数组指针，希望你喜欢，也可以帮助到您，欢迎分享！

篇1：再谈指针数组与数组指针

经常遇到这两个概念，很容易混淆，这里细细总结一下，

指针数组:是一个数组，数组的元素是指针。数组占多少个字节由数组本身决定。

数组指针：是一个指针，它指向一个数组。在32位系统下永远是占4 个字节。

举例说明：

1）int *p1[n];

2）int (*p2)[n];

1）“[]”的优先级比“*”要高。p1 先与“[]”结合，构成一个数组的定义，数组名为p1，int *修饰的是数组的内容，即数组的每个元素，

即p1是指针数组，其包含n个指向int 类型数据的指针。

2）“”的优先级比“[]”高，“*”号和p2 构成一个指针的定义，指针变量名为p2，int 修饰的是数组的内容，即数组的每个元素。数组在这里并没有名字，是个匿名数组。即p2是数组指针，它指向一个包含n 个int 类型数据的数组。

如要将二维数组赋给一指针，应这样赋值：

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][]

所以数组指针也称指向一维数组的指针，亦称行指针。

篇2：十六、数组和指针

指针和数组有着密切的关系,任何能由数组下标完成的操作也都可用指针来实现,但程序中使用指针可使代码更紧凑、更灵活，

一、指向数组元素的指针

我们定义一个整型数组和一个指向整型的指针变量:

int a[10], *p;

和前面介绍过的方法相同,可以使整型指针p指向数组中任何一个元素,假定给出赋值运算

p=&a[0];

此时,p指向数组中的第0号元素,即a[0],指针变量p中包含了数组元素a[0]的地址,由于数组元素在内存中是连续存放的,因此,我们就可以通过指针变量p及其有关运算间接访问数组中的任何一个元素。

Turbo C中,数组名是数组的第0号元素的地址,因此下面两个语句是等价的

p=&a[0];

p=a;

根据地址运算规则,a+1为a[1]的地址,a+i就为a[i]的地址。

下面我们用指针给出数组元素的地址和内容的几种表示形式：

(1). p+i和a+i均表示a[i]的地址, 或者讲,它们均指向数组第i号元素, 即指向a[i]。

(2). *(p+i)和*(a+i)都表示p+i和a+i所指对象的内容,即为a[i]。

(3). 指向数组元素的指针, 也可以表示成数组的形式,也就是说,它允许指针变量带下标, 如p[i]与*(p+i)等价。

假若: p=a+5;

则p[2]就相当于*(p+2), 由于p指向a[5], 所以p[2]就相当于a[7]。而p[-3]就相当于*(p-3), 它表示a[2]。

二、指向二维数组的指针

1.二维数组元素的地址

为了说明问题, 我们定义以下二维数组:

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

a为二维数组名,此数组有3行4列, 共12个元素。但也可这样来理解,数组a由三个元素组成:a[0],a[1],a[2]。而每个元素又是一个一维数组, 且都含有4个元素(相当于4列),例如,a[0]所代表的一维数组所包含的 4 个元素为a[0][0], a[0][1], a[0][2], a[0][3]。如图所示:

______ _______________

a---| a[0] | ____ | 0 | 1 | 2 | 3 |

|______| |___|___|___|___|

| a[1] | ____ | 4 | 5 | 6 | 7 |

|______| |___|___|___|___|

| a[2] | ____ | 8 | 9 | 10| 11|

|______| |___|___|___|___|

但从二维数组的角度来看,a代表二维数组的首地址,当然也可看成是二维数组第0行的首地址。a+1就代表第1行的首地址,a+2就代表第2行的首地址。如果此二维数组的首地址为1000,由于第0行有4个整型元素,所以a+1为1008,a+2也就为1016。如图所示

_______________

(1000) ____ | 0 | 1 | 2 | 3 |

|___|___|___|___|

(1008) ____ | 4 | 5 | 6 | 7 |

|___|___|___|___|

(1016) ____ | 8 | 9 | 10| 11|

|___|___|___|___|

既然我们把a[0],a[1],a[2]看成是一维数组名,可以认为它们分别代表它们所对应的数组的首地址,也就是讲,a[0]代表第 0 行中第 0 列元素的地址,即&a[0][0], a[1]是第1行中第0列元素的地址,即&a[1][0],根据地址运算规则,a[0]+1即代表第0行第1列元素的地址,即&a[0][1],一般而言,a[i]+j即代表第i行第j列元素的地址, 即&a[i][j]，

另外,在二维数组中,我们还可用指针的形式来表示各元素的地址。如前所述,a[0]与*(a+0)等价,a[1]与*(a+1)等价,因此a[i]+j就与*(a+i)+j等价,它表示数组元素a[i][j]的地址。

因此,二维数组元素a[i][j]可表示成*(a[i]+j)或*(*(a+i)+j),它们都与a[i][j]等价,或者还可写成(*(a+i))[j]。

另外, 要补充说明一下, 果你编写一个程序输出打印a和*a,你可发现它们的值是相同的,这是为什么呢? 我们可这样来理解:

首先,为了说明问题,我们把二维数组人为地看成由三个数组元素a[0],a[1],a[2]组成,将a[0],a[1],a[2]看成是数组名它们又分别是由4个元素组成的一维数组。因此,a表示数组第0行的地址, 而*a即为a[0], 它是数组名, 当然还是地址,它就是数组第0 行第0 列元素的地址。

2.指向一个由n个元素所组成的数组指针

在Turbo C中, 可定义如下的指针变量:

int (*p)[3];

指针p为指向一个由3个元素所组成的整型数组指针。在定义中,圆括号是不能少的, 否则它是指针数组, 这将在后面介绍。这种数组的指针不同于前面介绍的整型指针,当整型指针指向一个整型数组的元素时,进行指针(地址)加1运算,表示指向数组的下一个元素,此时地址值增加了2(因为放大因子为2),而如上所定义的指向一个由3个元素组成的数组指针,进行地址加1运算时,其地址值增加了6(放大因子为2x3=6),

这种数组指针在Turbo C中用得较少,但在处理二维数组时, 还是很方便的。例如:

int a[3][4], (*p)[4];

p=a;

开始时p指向二维数组第0行,当进行p+1运算时,根据地址运算规则,此时放大因子为4x2=8,所以此时正好指向二维数组的第1行。和二维数组元素地址计算的规则一样,*p+1指向a[0][1],*(p+i)+j则指向数组元素a[i][j]。

例：

int a[3][4]={

{1,3,5,7},

{9,11,13,15},

{17,19,21,23}

};

main

{

int i,(*b)[4];

b=a+1; /* b指向二维数组的第1行, 此时*b[0]是a[1][0] */

for(i=1;i<=4;b=b[0]+2,i++) /* 修改b的指向, 每次增加2 */

printf(%d\\t,*b[0]);

printf(\\n);

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

{

b=a+i; /* 修改b的指向,每次跳过二维数组的一行 */

printf(%d\\t,*(b[i]+1));

}

printf (\\n);

}

程序运行结果如下:

9 13 17 21

3 11 19

三、字符指针

我们已经知道,字符串常量是由双引号括起来的字符序列,例如:

a string

就是一个字符串常量,该字符串中因为字符a后面还有一个空格字符,所以它由8个字符序列组成。在程序中如出现字符串常量C编译程序就给字符串常量按排一存贮区域,这个区域是静态的,在整个程序运行的过程中始终占用,平时所讲的字符串常量的长度是指该字符串的字符个数, 但在按排存贮区域时, C 编译程序还自动给该字符串序列的末尾加上一个空字符'\\0',用来标志字符串的结束,因此一个字符串常量所占的存贮区域的字节数总比它的字符个数多一个字节。

Turbo C中操作一个字符串常量的方法有:

篇3：数组和指针再次来袭

1，数组和指针的定义于声明：

定义：只能出现一次，用来确定对象的类型和大小，并为其分配空间，

声明：可以出现多次，描述对象的类型，用于指定其他地方定义的对象，不为对象分配空间。

所以说extern char a[]与extern char a[10]等价，因为这是声明，不分配空间。

看一个关于数组指针的例子：

例1：

#includeint main(){ char a[5] = { 'A', 'B', 'C', 'D' }; char(*p3)[4] = &a;//这样的赋值不合理，数组a有5个元素，而p3是一个包含4个元素的数组指针。 char(*p4)[5] = a;//p4用来存放数组地址，a代表数组首元素的地址，所以类型不匹配 return 0;}

如果将&a强制类型转换为(char (*)[4])&a后就可以赋值给char (*p)[4]了，p4+1相当于加了4个字节，而不是5，因为p4的大小为4。

例2：

#include#includestruct Test{ int Num; char *pcName; short sDate; char cha[2]; short sBa[4];}*p;int main(){ struct Test test;//假设sizeof(struct Test)=20 p = &test; printf(“%x\\n”, p); printf(“%x\\n”, p + 0x1); printf(“%x\\n”, (unsigned long)p + 0x1); printf(“%x\\n”, (unsigned int*)p + 0x1); system(“pause”); return 0;}

结果分析：p的地址为1ef7f4，p里面存放的是结构体的地址，所以p+0x1就要加一个结构体的大小20，转换为16进制，结果就是1ef808，

将p转化为无符号长整型，加1就是直接加十进制1，结果就是1ef7f5。将p转换为整型指针，占四个字节，加1就相当于加1*sizeof(int *),结果就是1ef7f8。

例3：vs2013中小端存储：

int main(){ int a[4] = { 1, 2, 3, 4 }; int *ptr1 = (int *)(&a + 1); int *ptr2 = (int *)((int)a + 1); printf(“%x,%x”, ptr1[-1], *ptr2); system(“pause”); return 0;}

篇4：笔试题数组与指针

笔试题（数组与指针）

1.请说出const与#define 相比，有何优点？

答案：1） const 常量有数据类型，而宏常量没有数据类型，编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误。

2） 有些集成化的调试工具可以对const 常量进行调试，但是不能对宏常量进行调试。

2.简述数组与指针的区别？

数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。指针可以随时指向任意类型的内存块。

(1)修改内容上的差别

char a[] = “hello”;

a[0] = ‘X’;

char *p = “world”; // 注意p 指向常量字符串

p[0] = ‘X’; // 编译器不能发现该错误，运行时错误

(2) 用运算符sizeof 可以计算出数组的容量（字节数），

sizeof(p),p 为指针得到的是一个指针变量的`字节数，而不是p 所指的内存容量。C++/C 语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。

char a[] = “hello world”;

char *p = a;

cout<< sizeof(a) << endl; // 12 字节

cout<< sizeof(p) << endl; // 4 字节

计算数组和指针的内存容量

void Func(char a[100])

{

cout<< sizeof(a) << endl; // 4 字节而不是100 字节

}

篇5：数组指针与指针数组的关系与区别

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

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

//printf(“%3d”,a[i][j]);

//printf(“%3d”,*(*(a+i)+j));//输出a[i][j]

篇6：数组指针与指针数组的关系与区别

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

printf(“%3d”,*(*a+i));//输出数组中的第i个元素

int *c[4];//指针数组

//c=b;//不能这样用

//应当这样给指针数组赋值

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

c[i]=b[i];

//打印数组内容

篇7：数组指针与指针数组的关系与区别

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

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

//printf(“%3d”,*(*(c+i)+j));

//printf(“%3d”,c[i][j]);

篇8：数组指针与指针数组的关系与区别

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

printf(“%3d”,*(*a+i));//输出数组中的第i个元素

小结：

指针数组与数组指针的区别在于，数组指针可以直接赋值，而指针数组则不可以，

它们的相同之处在于，在使用时，都可以用指针或数组的形式。

数组与指针的区别（易出错地方）：

1.常量字符串的内容是不可以被修改的！

char a[]=“hello”;

a[0]='x';

printf(“%s”,a);//输出xello

char *p=“hello”;//p指向常量字符串

p[0]='x';

printf(“%s”,a);//报错，常量字符串的内容是不可以被修改的

2.内容赋值与比较

char a[]=“hello”;

char b[10];

//b=a;//错误

strcpy(b,a);//将字符串a拷贝给b，不能用b=a

if(strcmp(b,a)==0)

//比较a,b字符串是否相等，不能用if(a==b)

int len = strlen(a);

char *p = (char *) malloc (sizeof(char));

//p=a;//将a的首地址赋值给指针变量p

strcpy(p,a);//将a数组的内容赋值给指针变量p

if(strcmp(b,a)==0)//判断a,b内容是否相等

//if（p=a)//判断p和a的地址是否相同

篇9：c中指针指针、指针的指针、指针数组和数组指针

一、指针

如果在程序中定义一个变量，在对程序进行编译，系统会自动给这个变量分配内存单元，根据不同的类型，分配不同长度的空间，如int占用4个字节，char占用1个字节，内存单元中每个字节都有编号，这就是地址。由于可通过地址能够找到所需的变量单元，可以说地址指向该变量单元。打个比方，一个房间的门口挂了一个房间号301，这个301就是房间的地址，将该地址形象化为指针。对于一个内存单元来说，单元的地址（编号）即为指针，其中存放的数据才是该单元的内容。

严格地说，一个指针是一个地址，是一个常量，

而一个指针变量却可以被赋予不同的指针值，是变量。但常把指针变量简称为指针。为了避免混淆，约定：“指针”是指地址，是常量，“指针变量”是指取值为地址的变量。定义指针的目的是为了通过指针去访问内存单元。

例如：

int a=12;

int *p=&a;

二、指针的指针（二级指针）

简单来说，二级指针变量就是一级指针变量的地址。

例如：

int a=12;

int *p=&a;

int **=&p;

篇10：C++内存管理学习指针与数组

1.6指针与数组

C/C++中对数组和指针的掌握是程序员基本的技术功底,对于数组和指针的定义、操作、它们间的区别等内容，详见我另一篇文章《C/C++数组和指针详解》，

这里以学习《c++内存管理技术内幕》为主，对其中的疑点，不明白或者没有说明清楚的地方会在学习笔记中讲解说明，需要特殊讲解的会发单独的文章。

C++/C程序中，指针和数组在不少地方可以相互替换着用，让人产生一种错觉，以为两者是等价的。

数组要么在静态存储区被创建(如全局数组)，要么在栈上被创建。<-------这句话说的不恰当!当数组通过new或者malloc创建是，数组内容是在堆中，如果有指针指向这个数组，则这个指针是在栈中。其他情况可以说是要么在静态区创建，或者在栈上申请。

数组名对应着(而不是指向)一块内存，其地址与容量在生命期内保持不变，只有数组的内容可以改变。指针可以随时指向任意类型的内存块，它的特征是“可变”，所以我们常用指针来操作动态内存。指针远比数组灵活，但也更危险。

下面以字符串为例比较指针与数组的特性。

(1)修改内容的方式

下面示例中，字符数组a的容量是6个字符，其内容为hello。a的内容可以改变，如a[0]= ‘X’。指针p指向常量字符串“world”(位于静态存储区，内容为world)，常量字符串的内容是不可以被修改的。从语法上看，编译器并不觉得语句p[0]= ‘X’有什么不妥，但是该语句企图修改常量字符串的内容而导致运行错误。

1: char a[] = “hello”;

2: a[0] = 'X';

3: cout 《 a 《 endl;

4: char *p = “world”; // 注意p指向常量字符串

5: p[0] = 'X'; // 编译器不能发现该错误

6: cout 《 p 《 endl;

(2)复制内容以及内容比较的方式

不能对数组名进行直接复制与比较。若想把数组a的内容复制给数组b，不能用语句 b = a ，否则将产生编译错误。应该用标准库函数strcpy进行复制。同理，比较b和a的内容是否相同，不能用if(b==a) 来判断，应该用标准库函数strcmp进行比较。

语句p = a 并不能把a的内容复制指针p，而是把a的地址赋给了p。要想复制a的内容，可以先用库函数malloc为p申请一块容量为strlen(a)+1个字符的内存，再用strcpy进行字符串复制。同理，语句if(p==a) 比较的不是内容而是地址，应该用库函数strcmp来比较。

1: // 数组…

2: char a[] = “hello”;

3: char b[10];

4: strcpy（b, a）； // 不能用 b = a;

5: if（strcmp（b, a） == 0） // 不能用 if （b == a）

6: …

7:

8: // 指针…

9: int len = strlen（a）；

10: char *p = （char *）malloc（sizeof（char）*（len+1））；

11: strcpy（p,a）； // 不要用 p = a;

12: if（strcmp（p, a） == 0） // 不要用 if （p == a）

13: …

(3)计算内存容量

用运算符sizeof可以计算出数组的容量(字节数)。如下示例中，sizeof(a)的值是12(注意别忘了’’)。指针p指向a，但是sizeof(p)的值却是4。这是因为sizeof(p)得到的是一个指针变量的字节数，相当于sizeof(char*)，而不是p所指的内存容量。C++/C语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。

1: char a[] = “hello world”;

2: char *p = a;

3: cout《 sizeof（a） 《 endl; //12Bytes

4: cout《 sizeof（a） 《 endl; //4 Bytes

注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。如下示例中，不论数组a的容量是多少，sizeof(a)始终等于sizeof(char *)。

1: void Func（char a[100]）

2: {

3:  cout《 sizeof（a） 《 endl; // 4Bytes,not 100Bytes

4: }

1.7指针参数是如何传递内存?

如果函数的参数是一个指针，不要指望用该指针去申请动态内存。如下示例中，Test函数的语句GetMemory(str, 200)并没有使str获得期望的内存，str依旧是NULL，为什么?

1: void GetMemory（char *p, int num）

2: {

3:  p = （char *）malloc（sizeof（char） * num）；

4: }

5: void Test（void）

6: {

7:  char *str = NULL;

8: GetMemory（str, 100）； // str 仍然为 NULL

9: strcpy（str, “hello”）； // 运行错误

10: }

问题出在函数GetMemory中，

编译器总是要为函数的每个参数制作临时副本，指针参数p的副本是 _p，编译器使 _p = p。如果函数体内的程序修改了_p的内容，就导致参数p的内容作相应的修改。这就是指针可以用作输出参数的原因。在本例中，_p申请了新的内存，只是把_p所指的内存地址改变了，但是p丝毫未变。所以函数GetMemory并不能输出任何东西。事实上，每执行一次GetMemory就会泄露一块内存，因为没有用free释放内存。、

如果非得要用指针参数去申请内存，那么应该改用“指向指针的指针”，见示例：

1: void GetMemory2（char **p, int num）

2: {

3: *p = （char *）malloc（sizeof（char） * num）；

4: }

5: void Test2（void）

6: {

7: char *str = NULL;

8:  GetMemory2（&str, 100）； // 注意参数是 &str,而不是str

9:  strcpy（str, “hello”）；

10:  cout《 str 《 endl; 11:  free（str）； 12: }

由于“指向指针的指针”这个概念不容易理解，我们可以用函数返回值来传递动态内存。这种方法更加简单，见示例：

1: char *GetMemory3（int num）

2: {

3:  char *p = （char *）malloc（sizeof（char） * num）；

4: return p;

5: }

6:

7: void Test3（void）

8: {

9: char *str = NULL;

10:  str = GetMemory3（100）；

11:  strcpy（str, “hello”）；

12:  cout《 str 《 endl;

13:  free（str）；

14: }

用函数返回值来传递动态内存这种方法虽然好用，但是常常有人把return语句用错了。这里强调不要用return语句返回指向“栈内存”的指针，因为该内存在函数结束时自动消亡，见示例：

1: char *GetString（void）

2: {

3:  char p[] = “hello world”;

4:  return p; // 编译器将提出警告

5: }

6:

7: void Test4（void）

8: {

9:  char *str = NULL;

10:  str = GetString（）； // str 的内容是垃圾

11:  cout《 str 《 endl; 12: }

用调试器逐步跟踪Test4，发现执行str = GetString语句后str不再是NULL指针，但是str的内容不是“hello world”而是垃圾。

如果把上述示例改写成如下示例，会怎么样?

1: char *GetString2（void）

2: {

3:  char *p = “hello world”;

4:  return p;

5: }

6:

7: void Test5（void）

8: {

9:  char *str = NULL;

10:  str = GetString2（）；

11:  cout《 str 《 endl;

12: }

★ 笔试题数组与指针

★ 函数指针

★ 树状数组和线段树

★ 中数组课题工作计划

★ 六:指针（C语言）

★ 关于指针入门的最好的文章.net

★ 数据结构树状数组（二叉索引树）

★ win7电脑中如何变换鼠标指针的图案？

★ 再谈感情

★ 对于c/c++中的数组排序及计算平均值和得到最大最小值的思考

再谈指针数组与数组指针（精选10篇）

欢迎下载DOC格式的再谈指针数组与数组指针，但愿能给您带来参考作用！

推荐度：

点击下载文档 文档为doc格式