“dxcy365”通过精心收集，向本站投稿了7篇数组指针与指针数组的关系与区别，下面是小编为大家推荐的数组指针与指针数组的关系与区别，欢迎大家分享。
篇1：数组指针与指针数组的关系与区别
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]
篇2：数组指针与指针数组的关系与区别
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];
//打印数组内容
篇3：数组指针与指针数组的关系与区别
for(i=0;i<3;i++)
for(j=0;j<4;j++)
//printf(“%3d”,*(*(c+i)+j));
//printf(“%3d”,c[i][j]);
篇4：数组指针与指针数组的关系与区别
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的地址是否相同
篇5：再谈指针数组与数组指针
经常遇到这两个概念，很容易混淆，这里细细总结一下，
指针数组:是一个数组，数组的元素是指针。数组占多少个字节由数组本身决定。
数组指针：是一个指针，它指向一个数组。在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][]
所以数组指针也称指向一维数组的指针，亦称行指针。
篇6：笔试题数组与指针
笔试题（数组与指针）
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 字节
}
篇7：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: }
