C语言指针

指针

指针全称是指针变量，其实质是C语言的一种变量。这种变量比较特殊，通常它的值会被赋值为某个变量的地址值（p = &a），然后我们可以使用p这样的方式去间接访问p所指向的那个变量。*
1.1、为什么需要指针？
指针存在的目的就是间接访问。有了指针之后，我们访问变量a不必只通过a这个变量名来访问。而可以通过p = &a; *p = xxx;这样的方式来间接访问变量a。
1.2、两种重要运算符：

&：取地址符.将它加在某个变量前面，则组合后的符号代表这个变量的地址值。
例如： int a; int *p; p = &a; 则将变量a的地址值赋值给p。
就在上面的例子中，有以下一些符号：

    a		代表变量a本身
	p		代表指针变量p本身
	&a		代表变量a的地址值
	*p		代表指针变量p所指向的那个变量，也就是变量a
	&p		代表指针变量p本身的地址值。符号合法，但对题目无意义
	*a		把a看作一个指针，*a表示这个指针所指向的变量。该符号不合法

*：指针符号.指针符号在指针定义和指针操作的时候，解析方法是不同的。
int *p;		定义指针变量p，这里的*p含义不是代表指针变量p所指向的那个变量，在定义时
这里的*含义是告诉编译器p是一个指针。

int p;		// p是一个整形变量
int *p;		// p是一个指针变量，该指针指向一个整形数
使用指针的时候，*p则代表指针变量p所指向的那个变量。

练习题目：
规则：指针作用的演示

#include <stdio.h>


int main(void)
{
	int a = 23;
	int b = 0;
	int *p;					// 定义了一个int型的指针变量p	
	
	p = &a;					// 相当于p = (&a); p中存的是变量a的地址
	
	//*p = 111;				// 相当于a = 111; 
	b = *p;				
	
	printf("a = %d.\n", a);
	printf("b = %d.\n", b);
	printf("p = %p.\n", p);	// %p用于打印指针变量的值
	
	return 0;
}

1.3、指针的定义和初始化
指针既然是一种变量，那么肯定也可以定义，也可以初始化
第一种：先定义再赋值

    int *p;		// 定义指针变量p
	p = &a;		// 给p赋值			

第二种：定义的同时初始化

int *p = &a;	// 效果等同于上面的两句

练习题目：
规则：指针的定义赋值及初始化

#include <stdio.h>

int main(void)
{
	int a = 23;
	
	int *p = &a;	// 定义指针变量p的同时初始化。这里p前面的*理解跟定义时相同
					// 表示p是一个指针。实际上赋值效果等同于p = &a;

/*
	int a = 23;

	int *p;				
	
	p = &a;			// 正确。给指针变量p赋值。
	
	//*p = &a;		// 错误。因为*p这个符号，只在定义指针变量时
// 表示p是一个指针，在其他地方出现时，*p符号的含义都是p所指向的变量，所以错误
	*/

	printf("a = %d.\n", a);

	
	return 0;
}


***1.4、各种不同类型的指针***
指针变量本质上是一个变量，指针变量的类型属于指针类型。int *p;定义了一个指针类型的变量p，这个p所指向的那个变量是int型。

```00
int *pInt;				// pInt是指针变量，指向的变量是int类型
char *pChar;			// pChar是指针类型，指向的变量是char类型
float *pFloat;
double *pDouble;
各种指针类型和它们所指向的变量类型必须匹配，否则结果不可预知。

1.5、指针定义的两种理解方法：

int *p;

第一种：首先看到p，这个是变量名；其次，p前面有个*，说明这个变量p是一个指针变量；最后，*p前面有一个int，说明这个指针变量p所指向的是一个int型数据。

第二种：首先看到p，这个是变量名；其次，看到p前面的int *，把int *作为一个整体来理解，int *是一种类型（复合类型），该类型表示一种指向int型数据的指针。

总结：第二种方法便于理解，但是不够本质；建议用第一种方法来理解，因为这种思维过程可以帮我们理解更复杂的表达式。

1.6、指针与数组的初步结合

数组名：做右值时，数组名表示数组的首元素首地址，因此可以直接赋值给指针。
如果有 int a[5];
则 a和&a[0]都表示数组首元素a[0]的首地址。
而&a则表示数组的首地址。

注意：数组首元素的首地址和数组的首地址是不同的。前者是数组元素的地址，而后者是数组整体的地址。两个东西的含义不同，但是数值上是相同的。

根据以上，我们知道可以用一个指针指向数组的第一个元素，这样就可以用间接访问的方式去逐个访问数组中各个元素。这样访问数组就有了两种方式。
有 int a[5]; int *p; p = a;
数组的方式依次访问：a[0] a[1] a[2] a[3] a[4]
指针的方式依次访问：*p *(p+1) *(p+2) *(p+3) *(p+4)
练习题目：
规则：用指针访问数组

#include <stdio.h>

int main(void)
{
	int a[5] = {555, 444, 333, 222, 111};
	int *p;
	
	//p = &a;			// 编译报警告，但是执行结果是对的，打印555		
	//p = &a[0];		// 相当于 p = &(a[0]); 编译没错没警告，执行也没错，打印555
	p = a;				// 编译没错误没警告，执行也没错，打印555
	
	//a = p;				// 编译报错，因为数组名是个常量，所以不能赋值，所以
							// 数组名不能做左值。
						
	
	printf("*p = %d.\n", *p);	// 555

/*	// 指针+1，表示指向下一格
	p += 1;
	printf("*p = %d.\n", *p);	// 444 a[1]
*/

	//printf("*p++ = %d.\n", *p++);		// 555，++后置，先运算后+1
	//printf("*++p = %d.\n", *++p);		// 444，++前置，指针先加1，然后再*p取值
	//printf("(*p)++ = %d.\n", (*p)++);	// 555，先*p取值，然后给值后置++
	printf("++(*p) = %d.\n", ++(*p));	// 556
	
	return 0;
}

1.7、指针与++ --符号进行运算
指针本身也是一种变量，因此也可以进行运算。但是因为指针变量本身存的是某个其他变量的地址值，因此该值进行* / %等运算是无意义的。两个指针变量相加本身也无意义，相减有意义。指针变量+1，-1是有意义的。+1就代表指针所指向的格子向后挪一格，-1代表指针所指向的格子向前挪一格。

p++就相当于(p++)，p先与++结合，然后p++整体再与结合。
p++解析：++先跟p结合，但是因为++后置的时候，本身含义就是先运算后增加1（运算指的是p++整体与前面的进行运算；增加1指的是p+1），所以实际上p++符号整体对外表现的值是p的值，运算完成后p再加1.
所以p++等同于：*p; p += 1;

*++p等同于 p += 1; *p;

(p)++，使用()强制将与p结合，只能先计算p，然后对p整体的值++。

++(p)，先p取值，再前置++，该值+1后作为整个表达式的值。

总结：++符号和指针结合，总共有以上4种情况。–与++的情况很类似。

1.8、函数传参中使用指针
int add(int a, int b) 函数传参使用了int型数，本身是数值类型。实际调用该函数时，实参将自己拷贝一份，并将拷贝传递给形参进行运算。实参自己实际是不参与的。所以，在函数中，是没法改变实参本身的。
练习题目：
规则：使用指针在子函数中交换2个数的值

#include <stdio.h>

int main(void)
{
	int x, y;
	
	x = 5;
	y = 3;
	
	printf("before swap: x = %d, y = %d.\n", x, y);
	
	//swap(x, y);
	swap_pointer(&x, &y);
	
	printf("after  swap: x = %d, y = %d.\n", x, y);
}

// 要完成的功能：在函数内部，交换a和b的值
// 测试结果：交换成功。
// 原因：C语言函数调用时，一直都是传值调用。也就是说实际传递的一直都是实参的拷贝
// 但是本函数中的形参和实参都并不是x和y，而是x和y的地址值。这样，让我们在函数中
// 通过间接访问*p的方式，在函数内访问到了函数外面调用时的实参。
int swap_pointer(int *p1, int *p2)
{
	int temp;
	
	temp = *p1;		// 实际调用时，p1得到的实参是x的地址&x， *p1代表的就是x
	*p1 = *p2;
	*p2 = temp;
	
	return 0;
}




// 要完成的功能：在函数内部，交换a和b的值
// 实际测试结果：失败，并没有交换。
// 原因：C语言中，函数调用时，实参传递给形参实际是传值调用。也就是说，实参x和y将
// 自己的值拷贝一份传给形参a和b，在子函数swap中实际得到交换的是a和b，而不是实参x
// 和y，因此函数执行完后，x和y的值依然，并没有被交换。
int swap(int a, int b)
{
	int temp;
	
	temp = a;		// a是swap内的形参，实际调用时得到的是实参x的一份拷贝，只是和
	a = b;			// x的值相等而已，其他并无任何关联，因此在这里不能访问到x
	b = temp;

	return 0;
}