从使用指针的目的谈一级指针和二级指针

使用二级指针的最终目的：修改或引用指针指向的对象——址
使用一级指针的最终目的：修改或引用指针指向的对象——值

（1） 野指针、指针的地址（&ptr）、指针的指向（ptr）

 char *ptr1;
 char *ptr2=NULL;
 printf("ptr1=0x%x\r\n",ptr1);			// ptr1=0x7efde000;
 printf("&ptr1=0x%x\r\n",&ptr1);		// &ptr1=0x28ff3c;			
 printf("ptr2=0x%x\r\n",ptr2);			// ptr2=0x7efde000;
 printf("&ptr2=0x%x\r\n",&ptr2);		// &ptr2=0x28ff3c;

当定义一个指针时，最好使其指向NULL，避免出现“野指针”，所谓“野指针”是
指向一个不可预料的内存空间的指针，不小心引用或修改这个“野指针”会破坏内存
空间的值从而产生严重问题。最可怕的是问题隐蔽，难于发现
从这个例子中可知，对于一级指针：
string-------->表示指针指向的变量，打印这个会显示出这个变量保存的值—地址
&string------>表示指针本身的地址，
*string------->表示string指向的数据

（2） 数组与指针

int array[5] = {0};
printf("1.array = %p\n", array); 
printf("2.&array = %p\n", &array); 
printf("3.&array[0] = %p\n", &array[0]); 
printf("4.array + 1 = %p\n", array + 1);
printf("5.&array[0] + 1 = %p\n", &array[0] + 1);
printf("6.&array + 1 = %p\n", &array + 1);
printf("7.sizeof(array) = %lu\n", sizeof(array)); 

运行结果：

1.array = 0028FF28
2.&array = 0028FF28
3.&array[0] = 0028FF28
4.array + 1 = 0028FF2C
5.&array[0] + 1 = 0028FF2C
6.&array + 1 = 0028FF3C
7.sizeof(array) = 20

C语言规定数组名代表数组首元素[0]的地址，是一个指针常量。对array+1的操作是以数组元素为颗粒度进行加法运算，本例中是int型的数组，所以array+1其实是array的地址加4，所以array+1是元素[1]的地址。而&array表示整个数组的地址，是以整个数组为颗粒度的，所以&array+1，是将array的地址加20。
但有一个例外是：sizeof(array)算出的是整个数组的字节数，而非array这个指针常量的长度。
所以有：
array------------------> 数组首元素的地址，指针常量，array+1为下一个元素的地址
&array----------------> 整个数组的地址，&array+1为array数组后面存储单元的地址

（3） 关于参数的传递

void  fun(int  *p)
{
	int  b=100;
	p=&b;		//	将p指向b，改变的是局部变量的值，实参不受影响
}
void  fun2(int  *p)
{
	*p=100;		// 将p指向的变量赋值100，改变的是实参指针指向的值，实参会受到影响
}

main()
{
	int  a=10;
	int  *q;
	q=&a;
	printf("*q=%d\n",*q);		// *q=10
	printf("a=*d\n",a);			// a=10
	fun(q);
	printf("*q%d\n",*q);			// *q=10
	printf("a=*d\n",a);			// a=10
	fun2(q);
	printf("*q%d\n",*q);			// *q=100
	printf("a=*d\n",a);			// a=100
	return  0;
}

为什么？fun和fun2中的形参同为指针变量，并且在主函数中都给形参赋值为q，也就是a变量的地址。众所周知，形参在函数内存放在栈上，在执行p=&b之前，p依然指向a，执行p=&b之后，p指向了b，而b是栈上的一个变量，fun函数返回后，p就被释放了，对实参q没有任何影响。而在fun2中，直接改变了p指向的变量的值。
函数调用的时候，不管传递的是值还是址，在函数体内部是一份拷贝，是可以随意改变，但是这个改变是无法带出函数体外部的。

以上的例子应用到指针也是如此：

void  GetMem1(char  *s) 				// 想在函数中分配内存,再返回，徒劳无功
{
	 s = (char  *)  malloc(100);		// GetMem1被调用时相当于用实参初始化了s，s指向了实参，
										// 之后再执行malloc则会将申请到的内存地址再赋值给s
										// 显然对实参没有任何影响。
}

void  GetMem2(char  **s) 		
{
	 *s = (char  *)  malloc(100);		// s指向的是实参的地址,所以改变了实参指向的内容.
}

void  main()
{
	 char  *p=NULL;
	 GetMem1(p);
	 if(p)  free(p);					// p仍然指向NULL
	 GetMem2(&p);					
	 if(p)  free(p);					// p指向了新申请的内存地址
}

也可以使用返回指针值的函数申请内存，但要确保返回的指针值不是指向栈内存的。

char  *GetMemory3(int  num)
{
	char  *p  =  (char  *)malloc(sizeof(char)  *  num);	// Heap上的数据指针,可以返回
	return  p;
}

void  Test3(void)
{
	char  *str  =  NULL;
	str  =  GetMemory3(100);           
	strcpy(str,  "hello");
	printf("%s\n",str);
	free(str); 
}

下面程序就是将返回指针指向了栈内存

char  *GetString(void)
{
	char  p[ ]  =  "hello  world";
	return  p;						//  编译器将提出警告
}
void  Test4(void)
{
	char  *str  =  NULL;
	str  =  GetString();			//  str  的内容是垃圾
}

另外还要避免返回常量区的指针，因为常量放在静态区永远都不会变，没有实际意义：

char  *GetString2(void)
{
	char  *p  =  "hello  world";
	return  p;
}
void  Test5(void)
{
	char  *str  =  NULL;
	str  =  GetString2();
}

其实，使用指针的最终目的是引用或改变指针指向的内容，对于一级指针，引用或改变的是一个值，而二级指针是一个地址. 如上面的fun2使用一级指针，改变的是这个指针指向的值；在GetMem2中使用二级指针，改变的是这个指针指向的地址