指针相关

本文较为详细的分析了关于理解C++指针数组，数组指针，数组名，二维数组的一些技巧。是比较重要的概念，相信对于大家的C++程序设计有一定的帮助作用。

一、关于数组名

假设有数组：

?

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

1.数组名代表数组第一个元素的地址，注意，不是数组地址（虽然值相等），是数组第一个元素地址，a 等同于 &a[0];

a+1是第二个元素的地址。比第一个元素地址a（或者&a[0]）超出了一个整型指针的大小，在这里是4个字节（byte）

?

1	cout << a << endl;//会输出数组第一个元素地址。

2.取址符号&.

&a是数组的地址，注意是数组的地址，表示数组这个整体的地址。不是数组第一个元素的地址（虽然他们的值相同）

&a+1比数组的地址&a超出了一个数组的地址大小，在这里是3*4个字节

int * p = &a;这条语句是不成立的。左边指针变量p时指向整型的指针，而右边是数组（类型是数组）的地址，不是数组元素（类型是整型）的地址，所以不能赋值。
应该赋值给数组指针（下面会讲到）。

关于数组名，切记以上两点。

二、关于指针数组

1.定义

指针数组，就是存放指针的数组，数组里的元素是指针（对比于整型数组，整型数组就是存放整型的数组，数组里的元素是整型）

int *ptr[3];如何理解？按照运算符优先级，[]优先级较大，所以ptr先与[3]结合，表示ptr是一个数组，必然要明确数组的元素类型，所以数组里的元素类型是整型指针（int*），数组的大小不一定需要（定义数组时可以根据初始化的元素个数确定）

ptr[0]就是数组的第零个元素，它是一个整型指针。

示例如下：

?

1 2 3 4

int a[3] = {1, 2, 3}; int x = 5; ptr[0] = &x; ptr[1] = &a[2];

2.如何使用？

像一般指针一样使用。*ptr[0]就是第零个元素（一个指针）所指向元素的值，这里是 5。

三、关于数组指针

1.定义

数组指针，就是指向数组的指针，它是一个指针，指向一个数组（对比于整型指针，就是指向整型的指针，它是一个指针，指向一个整型）

int (*ptr)[3]; 如何理解？先看小括号里面，*ptr说明ptr是一个指针，然后跟[]结合表明这个指针指向一个数组，数组的元素是int

?

1 2	int a[3] = {1, 2, 3}; int(*ptr)[3] = a;//这条语句不成立。

右边a是数组名，还记得上面说的吗，数组名代表数组第一个元素的地址，就是&a[0]，数组名的类型相当于整型指针（不知道事实上是不是）int *，因为它指向了第一个元素，第一个元素是int

左边ptr的类型是int(*)[]，是数组指针，指向数组的指针，不是指向整型的指针，不能赋值。

?

1 2	int a[3] = {1, 2, 3}; int (*ptr)[3] = &a;//正确。

因为a是一个数组，&a就是数组的地址，还记得上面说的吗？

2.如何使用？

?

1 2 3 4 5

int a[3] = {1, 2, 3}; int (*ptr)[3] = &a;    cout << (*ptr)[0] << endl;  //输出1 cout << (*ptr)[1] << endl;  //输出2

这里有一点难以理解。不防对比一下一下代码。

?

1 2 3 4

int a[3] = {1, 2, 3}; int x = 5; int * p = &x; cout << *p << endl;  //输出5

p是一个指向整型的指针，*p就是所指向的变量（整型x）的值。同理ptr是指向数组的指针，*ptr就是所指向的变量（数组a）的值。（*ptr)[0]就是数组的第零个元素。

四、关于二维数组

1.二维数组是一个数组，它的元素是一维数组。谨记这一点，然后把上面的套进来就行了。

?

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

数组名

a是数组第一个（或者说第零个更好）元素的地址，第一个元素是一维数组，a[0] ------> {1, 2, 3}。a+1是第二个元素的地址，就是第二个一维数组的地址，超出了3*4个字节

&a是数组的地址，&a+1 就是超出了一个二维数组的大小，超出了3 * 4 * 3 个字节。

数组指针

?

1	int (*ptr)[3] = a; //正确。

因为a表示第一个元素的地址，第一个元素是一个一维数组，所以a表示一个一维数组的地址，一个数组的地址赋值给数组指针，成立。

五、总结：

1.数组名表示数组的第一个元素的地址。

2.&a（a是一个数组）是数组的地址。

3.指针数组是一个数组，它的元素是指针。

4.数组指针是一个指针，它指向一个数组。

5.二维数组的元素是一维数组。

 

 

二维数组和指向指针的指针

一道面试题引发的问题，首先要知道[]的优先级高于*，题目：

char **p,a[6][8]; 问p=a是否会导致程序在以后出现问题？为什么？

直接用程序说明：

#include<stdio.h>

void main()
{
    char **p,a[6][8];
    p = a;
    printf（"\n"）;
}

编译，然后就会发现通不过，报错：错误 1 error C2440: “=”: 无法从“char [6][8]”转换为“char **” 

于是乎，我看了下《C专家编程》里10.5节—使用指针向函数传递一个多维数组。

方法一，函数是 void fun(int arr[2][3]); 这种方法只能处理2行3列的int型数组。

方法二，可以省略第一维的长度。函数是 void fun(int arr[][3]);这种方式虽然限制宽松了一些，但是还是只能处理每行是3个整数长度的数组。

　　　　或者写成这种形式 void fun(int (*arr)[3]);这是一个数组指针或者叫行指针，arr和*先结合使得arr成为一个指针，这个指针指向具有3个

　　　　int类型数据的数组。

方法三，创建一个一维数组，数组中的元素是指向其他东西的指针，也即二级指针。函数是 int fun(int **arr);这种方法可以动态处理各行各列不一样长度的数据。

注意：只有把二维数组改成一个指向向量的指针数组的前提下才可以这么做！比如下面的程序可以正常输出abc：

#include <iostream> 
using namespace std; 
void test(char **ptr) 
{ 
    cout << *ptr << endl; 
} 
 
int main() 
{ 
    char *p[3] = {"abc", "def", "ghi"}; 
    test(p); 
    return 0; 
}

在《C专家编程》10.3节的小启发里讲的很透彻：（以下这段文字及对比一定要认真分析！）

数组和指针参数是如何被编译器修改的？

“数组名被改写成一个指针参数”规则并不是递归定义的。数组的数组会被改写成“数组的指针”，而不是“指针的指针”：

实参                                                      所匹配的形参

数组的数组          char c[8][10];                 char (*)[10];          数组指针

指针数组             char *c[10];                   char **c;               指针的指针

数组指针(行指针)  char (*c)[10];                 char (*c)[10];        不改变

指针的指针           char **c;                       char **c;               不改变

下面再看一个网友的一段分析相当给力的代码：

#include "stdafx.h" 
#include <iostream> 
using namespace std; 
 
int _tmain(int argc, _TCHAR* argv[]) 
{ 
    int arr1[3]; 
    int arr2[3]; 
    int arr3[3]; 
    int * ptr; 
    // ptr1是一个指向 int [3] 的指针，即ptr的类型和&arr1的类型是一样的，注意：arr1指向的内存区域定长 
    int ptr1[3][3]={{1,2,3},{1,2,3},{1,2,3}}; 
    // ptr2是一个指向 int * 的指针，即ptr2的类型和&ptr是一样的，注意：ptr指向的内存区域不定长 
    int * ptr2[3]={arr1,arr2,arr3}; 
    // ptr3是一个指向 int [3] 的指针，即ptr3的类型和&arr1的类型是一样的，注意：arr1指向的内存区域定长 
    int(* ptr3)[3]=&arr1; 
    ptr3=ptr1; // 没错，他们的类型相同 
 // ptr3=ptr2;//error 无法从“int *[3]”转换为“int (*)[3] 
 // ptr4是一个指向 int * 的指针，即ptr4的类型和&ptr是一样的，注意：ptr指向的内存区域不定长 
    int ** ptr4; 
    //ptr4=&arr1; //error 无法从“int (*)[3]”转换为“int ** 
    ptr4=ptr2; // 没错，他们的类型相同 
 //ptr4=ptr3; // error 无法从“int (*)[3]”转换为“int ** 
    return 0; 
}