指针与数组

1. 指针与数组的关系
指针和迭代器非常像，我们可以说指针就是数组的迭代器。
数组具有较好的可读性，而指针具有更强的灵活性。一般，对某些多维数组中非连续的元素的随机访问用下标表示比较方便，当按递增（减）顺序访问数组时，使用指针快捷而且方便。
所以在某些情况下使用指针更好，与数组相比，它可以1. 节省空间（指针只占用4字节空间） 2. 省去了调用memset()的时间

[cpp]   view plain copy

1. #include<stdio.h>  
2.   
3. int val[100];  
4.   
5. int main(void)  
6. {  
7.     for (int i = 0; i < 100; ++i)  
8.         val[i] = i;  
9.     int *p = val;///近似理解为 int *p = &val[0];  
10.     ///这里发生了隐式指针转换：数组自动转换为指向第一个元素的指针  
11.     printf("%d\n", *p); ///指针p指向val的第一个元素，即val[0]  
12.       
13.     int t = 100;  
14.     while (t--)  
15.         ///可以直接对指针进行加减运算，就和迭代器一样  
16.         printf("%d\n", *(p++));///输出0~99  
17.           
18.     ///指针可以做差：  
19.     int *p2 = &val[10], *p3 = &val[20];  
20.     printf("%d\n", p3 - p2); //10  
21.     printf("%d\n", p2 - p3); //-10  
22.       
23.     ///还可以比比较大小：  
24.     printf("%d\n", p2 < p3 ? p3 - p2 : p2 - p3); //10  
25.     return 0;  
26. }  

PS：不将数组转换为指针的例外情况为有：&数组，sizeof(数组)，以及用数组对数组的引用进行初始化时。（后面会有更详细的解释）

2. 指向指针的指针与二维数组

[cpp]   view plain copy

1. #include<stdio.h>  
2.   
3. int main(void)  
4. {  
5.     int val = 7;  
6.     int *p = &val;  
7.     int **p2 = &p;///**声明一个指向指针的指针  
8.     printf("val的值为%d %d",*p,**p2);///**p2为两次解引用，可看做*(*p2)  
9.     return 0;  
10. }  

由于指针也要占用内存空间存放其值，所以我们也可以定义一个指向指针的指针。

多维数组举例：

[cpp]   view plain copy

1. #include<stdio.h>  
2.   
3. int val[100][100];  
4.   
5. int main(void)  
6. {  
7.     val[2][1] = 666;  
8.     ///如何用指针取出val[2][1]？  
9.     printf("%d", *(*(val + 2) + 1));  
10.     return 0;  
11. }  

3. 指针与字符串（char数组）
请看 这篇文章 中的“字符串赋值”部分。

4. 危险！探测数组外面的世界
“输出流？”

[cpp]   view plain copy

1. #include<stdio.h>  
2.   
3. int INCORRECT_getIntlen(int *num)  
4. {  
5.     int *p = num;  
6.     printf("%x %p\n", *p, p);  
7.     while (*p++)///不合理的判断条件  
8.         printf("%x %p\n", *p, p);  
9.     return (p - num);  
10. }  
11.   
12. int main(void)  
13. {  
14.     int num[20];  
15.     int *p[20];///不创建指针数组造成的最终结果也不同  
16.     for (int i = 0; i < 20; ++i)  
17.     {  
18.         num[i] = i + 1;  
19.         p[i] = &num[i];  
20.     }  
21.     for (int i = 0; i < 20; ++i)  
22.     {  
23.         //printf("%x\n", num[i]);  
24.         printf("%x\t%p\n", num[i], p[i]);  
25.     }///两个printf造成的最终结果不同  
26.     ///数组越界造成的后果是未知的  
27.     puts("");  
28.     printf("%d\n", INCORRECT_getIntlen(num));  
29.       
30.     ///推荐下面这种做法  
31.     printf("%d\n", sizeof(num) / sizeof(int));  
32.     return 0;  
33. }  

PS：指针的长度——在32位的编译环境中，sizeof(p)的结果都是4，也就是一个地址码的长度。

5. 关于“&数组名”

[cpp]   view plain copy

1. #include<stdio.h>  
2.   
3. int main(void)  
4. {  
5.     int a[4] = {1, 2, 3, 4};  
6.     printf("   a = %d\n", a);  
7.     printf("  &a = %d\n", &a);  
8.     printf(" a+1 = %d\n", a + 1);  
9.     printf("&a+1 = %d\n", &a + 1);  
10.     return 0;  
11. }  

PS：&(取地址)的优先级要高于+(二元加)

运行结果如下：

[cpp]   view plain copy

1.   a = 1245040  
2.  &a = 1245040  
3. a+1 = 1245044  
4. amp;a+1 = 1245056  

从打印出来的地址我们可以看出，&a的地址与a是一样的，a+1指向了数组的第二个元素，而&a+1却跳过了整个数组的所有元素个数，指向数组之后的位置。

解释：a是一个指向int变量的指针，在这里指向了a[0]，而&a是一个指向一个包含了4个int值的数组的指针。

所以这里a有隐式指针转换，而&a没有。

6. 数组作为函数参数传递
虽然很多时候数组名被调用时会被转换成指针，但是不可否认的是它的确是特殊类型，并且在若干地方某些操作并不会发生，如使用&，sizeof，以及初始化赋值给引用时。
在定义的时候：
int function(int *a);
int function(int *a[]);
int function(int *a[10]);
这三种定义，会被编译器解析成int function(int *a);也就是说从编译器开始，已经成为指针了，在函数体内部没有办法知道数组的长度。
这时C++中的vector就派上用场了。

[cpp]   view plain copy

1. #include<cstdio>  
2. #include<vector>  
3. using namespace std;  
4.   
5. int getVectorSize(vector<int> v)  
6. {  
7.     return v.size();  
8. }  
9.   
10. int main()  
11. {  
12.     vector<int> v;  
13.     v.push_back(1);  
14.     v.push_back(2);  
15.     printf("%d\n",getVectorSize(v));  
16.     return 0;  
17. }  

但若你不想用vector，有以下三种方法：
1. 仿照字符串，加一个结束标记符（比如null）
2. 传递指向数组的第一个元素的指针和最后一个元素的下一个位置的指针（就像我们在排序时调用的sort(a,a+n)一样）
3. 将第二个形参定义为数组的大小（size_t size），传递的值可以为：sizeof(a)/sizeof(*a)

****转载请注明：http://blog.csdn.net/synapse7/article/details/16115051****