指针的运算和普通的算术运算是不同的，支持的运算符也很少，有时候你把两个指针相减得到的结果可能会不如你所想。今天来稍微总结一下：
1. 指针的有限算术运算：自增(++), 自减(--), 加上一个整数(+, +=), 减去一个整数(-, -=), 以及减去另一个指针
2. 指针加上或减去一个整数时，并非简单地加上或减去该整数值，而是加上该整数与指针引用的对象的大小的乘积。对象的大小（字节数）取决于对象的数据类型。
3. 对于x=p1-p2，是把从p2到p1的数组元素的个数赋给x。因为除了数组元素外，我们不能认为两个相同类型的变量是在内存中连续存储的，所以指针算术运算除了用于数组外没有什么意义。两个指针相减的结果的类型是ptrdiff_t,它是一种有符号整数类型。
4. 常见的程序设计错误有：
（1）对不指向数组的指针进行算术运算。
（2）把不指向同一数组的两个指针相减或比较。（C和指针P100 讲的比较形象）
（3）指针算术运算的结果超出了数组的范围。
5. 指针类型转换问题：如果两个指针类型相同，那么可以把一个指针赋给另一个指针，否则必须用强制类型转换，把赋值运算符右边的指针的类型转换为赋值运算符左边指针的类型。指向void *类型的指针是例外。任何类型的指针都可以赋给指向void类型的指针，指向void类型的指针也可以赋给任何类型的指针（注：这种情况对于C++就是不对的，参见think in C++，也就是说void* 不能直接赋值给其他类型的指针必须进行强制类型转换）。这两种情况都不需要使用强制类型转换。
先来看一个例子：
#include <stdio.h> #include <stdlib.h> struct A { int a; int b; }; #define offsetof(TYPE,MEMBER) ((size_t)&((TYPE *)0)->MEMBER) #define container_of(ptr,type,member) ( {\ const typeof( ((type*)0)->member ) *__mptr=(ptr);\ (type*)( (char*)__mptr - offsetof(type,member) );} )
int main() { struct A *p = (struct A *)malloc(sizeof(struct A)); p->a = 1; p->b = 2; int *p1 = NULL; p1 = &p->b; //这里的目的是通过算术运算，从p1的地址（p->b的地址）去算出 p->a的地址 printf("p1-4: %x %d\n",((int )p1-sizeof(int)),*(int *)((int )p1-sizeof(int))); //先将指针进行强制类型转换之后，进行算术运算，将得出的结果再转换成指针 printf("P: %x \n",p); printf("P1: %x\n",p1); p1--; printf("p1 suanshu: %x %d\n",p1,*p1); //指针支持的算术运算‘--’ 和 '++' p1++; printf("Container_of p = %x %d\n",container_of(p1,struct A,b),*container_of(p1,struct A,b)); //通过container_of得出整个结构体的指针。 return 0; }
说明：p1-4 打印的地址是：&p->a 也就是 struct *p 的起始地址 （从前两行打印可以看出来）；p1的地址是&p->b：440f68；对p1进行‘--’运算使其指向p->a; 通过container_of得出整个结构体的指针。
注：（2012年6月16日20:21:33）：以上程序我是在MinGW编译器下运行的，今天发现在微软的编译器下container_of这个宏得不到正确的解析。
在来看一个使用二级指针分配空间的示例程序：
#include <iostream> #include <iterator> #include <algorithm> #include <iomanip> using namespace std; #define out cout<<setw(4) int main() { //int **p = (int **)new int [10]; //这里和下面的方式都可以 int **p = new int *[10]; int aa = 0; for(int i = 0; i < 10 ;i++) p[i] = new int[10]; //由于每次这样分配，每个一维数组的地址内部是连续的，外部不是连续的，所以不能一次memset那么多 //只有每次使用memset设置一个数组，且memset的特性要注意 int bb = 0; int cc = 0xff; int temp = cc; int count = 0; for(int i = 0; i < 10 ;i++) for(int j = 0; j < 10 ; j++) p[i][j] = count++; /*while(aa < 10) { memset(p[aa++],temp,sizeof(int) * 10);//不要乱用，memset每次将一个byte设置为temp值 }*/ cout << "Array internal Address : "<<endl; cout << &p[0][8]<<" "<< p[0][8]<<endl; cout << &p[0][9]<<" "<< p[0][9]<<endl; cout << &p[0][10]<<" "<< p[0][10]<<endl; cout << &p[0][11]<<" "<< p[0][11]<<endl; cout << &p[0][12]<<" "<< p[0][12]<<endl; cout<<"Array external Address: "<<endl; cout << &p[0][0]<<" "<< p[0][0]<<endl; cout << &p[1][0]<<" "<< p[1][0]<<endl; cout << &p[2][0]<<" "<< p[2][0]<<endl; cout<<"For loop: "<<endl; /* //注意和二维数组的区分！ for(int i = 1; i <= 100; i++) //这样来打印全部是不行的！ { cout<< p[0][i-1] << " "; if(i % 10 == 0 && i != 0) cout << endl; } */ for(int i = 0; i < 10; i++) { for(int j = 0; j < 10 ; j++) { cout<<setw(4) << p[i][j] << " "; } cout << endl; } cout<<"STL Copy: "<<endl; int a = 0; while(a < 10) { copy(*p,*p+10,ostream_iterator<int>(cout," ")); //这里必须使用*p，我开始一直写错，可以参见copy的实现 cout << endl; a++; p++; //这里就注意的每次‘++’就会跳到下一个“数组”的头, '++'直接是跳转到了下一个“对象”引用的位置 } return 0; }
注意：这里虽然使用二级指针分配了一个类似二维数组的空间，请注意和二维数组进行区别。
memset的用法：
void * memset ( void * ptr, int value, size_t num );
Fill block of memory
Sets the first num bytes of the block of memory pointed by ptr to the specified value (interpreted as an unsigned char).
上面程序中我试图使用memset对分配出来的空间进行初始化，但是请注意memset初始化是按字节来的，如果初始化的结果不是0，结果将会非常意外，比如初始化的结果为10，则最后每个元素的值为：0x0a0a0a0a, %d打印的结果为：168430090。而且上面使用二级指针分配的空间并非连续，想要使用memset初始化的话，必须进行多次，也就说按内纯分配的次数来初始化。
附：（copy的实现）
template<class InputIterator, class OutputIterator>
OutputIterator copy ( InputIterator first, InputIterator last, OutputIterator result )
{
while (first!=last) *result++ = *first++;
return result;
}
复杂函数指针：
Think in C++中介绍了一种复杂函数指针的分析方法：
右左法则：首先从最里面的圆括号看起，然后往右看，再往左看。每当遇到圆括号时，就应该掉转阅读方向。一旦解析完圆括号里面所有的东西，就跳出圆括号。重复这个过程直到整个声明解析完毕。
To define a pointer to a function that has no arguments and no
return value, you say:
void (*funcPtr)();
funcPtr是一个函数指针，该指针指向的函数没有参数，没有返回值。
复杂函数申明：
void * (*(*fp1)(int))[10];
解释：
“fp1 is a pointer to a function that takes an integer argument and returns a pointer to an array of 10 void pointers.”
fp1是一个指向函数的指针，该函数拥有一个int型的参数，返回值是一个指向拥有10元素的指针数组，数组中每个元素都是void * 类型。
float (*(*fp2)(int,int,float))(int);
解释：
fp2 is a pointer to a function that takes three arguments (int, int, and float) and returns a pointer to a function that takes an integer argument and returns a float
fp2是一个指向函数的指针，该函数拥有三个参数，分别是int，int和float类型，返回一个指向函数的指针，该函数拥有一个int型的参数，返回值是float类型。
typedef double (*(*(*fp3)())[10])();
fp3 a;
解释：
fp3 is a pointer to a function that takes no arguments and returns a pointer to an array of 10 pointers to functions that take no arguments and return doubles.
fp3 是一个指向函数的指针，该函数没有参数，返回一个指向拥有十个元素的数组，数组的每个元素是一个函数，这10个函数都没有参数，返回值是double类型。
int (*(*f4())[10])();
解释：
f4 is a function that returns a pointer to an array of 10 pointers to functions that return integers.
f4是一个函数，返回值是一个指向拥有10个元素的数组，每个数组元素是一个函数指针，这些指针指向的函数返回值为int类型。
函数如何返回一个数组？ (C编程专家P230)
有了上面的分析可以简单构造为：
int (*func())[20]
func是一个函数，它的返回值是一个指向20个int元素的数组的指针。
函数里面可以定义一个指向20 int 元素的数组的指针：
int (*p)[20];
然后动态分配内存之后，在函数结尾就可以返回了。
注意和这个区别：int *p[20] ： p是一个拥有20个元素的数组，数组中的每个元素是一个指向int型的指针。