C语言指针详解（2）

指针的运算
1、类型对指针加一的影响
整型int指针变量加1

#define N 5
int main()
{
	int arr[N] = {1,2,3,4,5};
	int *ip = &arr[0];//&arr
	for(int i = 0;i < N;i++)
	{
		printf("%p => %d \n",ip,*ip);
		ip = ip + 1;
	}
	return 0;
}

double类型指针加1

#define N 5
int main()
{
	double arr[N] = {1.2,2.1,3.2,4.3,5.4};
	double *ip = &arr[0];
	for(int i = 0;i < N;i++)
	{
		printf("%p => %f \n",ip,*ip);
		ip = ip + 1;
	}
}

type *p
指针的类型不同加1的能力也不同，p = p + 1 => p = p + sizeof(type) * 1

int main()
{
	int arr[5] = {12,23,34,45,56};
	int *p = arr;
	int x = 0;
	int y = 0;
	x = *p++;//*p=12  p++ =>23//12  
	y = *p;//23
	printf("%d %d\n",x,y);//12,23
	x = ++*p;//*p=23 23+1=24
	y = *p;//24
	printf("%d %d\n",x,y);//24,24
	x = *++p;//++p=>34 *p=34
	y = *p;//34
	printf("%d %d\n",x,y);//34,34
	return 0;

}

类型对指针解引用的影响

int main()
{
	int a = 0x12345678;
	int *ip = &a;
	char *cp = (char*)&a;
	*ip = 0x87654321;
	*cp = 0x7f;
	return 0;

}

因此指针的类型决定了指针加1和解析的能力。char类型解析1字节，int类型解析4字节。
关于*和&的谜题

int main()
{
	int a = 10,b = 20;
	int *p = &a;
	*&a;
	*&p;
	&*p;
}

p = &a; p =>a;由此推出：
p=&a,也就是说&a是取a的地址，（&a）就是去这个地址上的数据，也就是a本身。
*&p: &p取p的地址，*p也就是p本身。
&*p: p =&a;*p = a;&*p=>&a 但是它不等价与p本身，因为&a是不能修改的。
const与指针变量的关系
const关键字修饰变量和数组，成为常变量或常数组，const也可以修饰指针变量。
两种作用：
1、限制指针变量本身

int *const p;

指针变量p本身的值不能修改，指向可以改变，因此const修饰的指针变量只能在定义的时候初始化，不能定义之后赋值。

int *const p;//error
int a = 10;
int b = 20;
int *const p = &a;//ok
*p = 100;//ok
p = &b;//error

2、限制指针变量指向的数据。

const int *p;
int const *p;

指针可以指向不同的变量，指针本身的值可以修改，但是不能修改指针所指向的数据的值。

int main()
{
	int a = 10,b = 20;
	int const *p = NULL;
	p = &a;//ok
	p = &b;//ok;
	*p = 100;//error
}

也可以同时限制指针变量和指针变量所指向的数据值的值。

const int * const p;

int main()
{
	int a = 10,b = 20;
	const int * const p;//error
	const int * const p = &a;//ok
	//第一个修饰指向，第二个修饰指针变量本身
	*p = 100;//error
	p = &b;//error
}

普通变量和常变量的区别

int main()
{
	int a = 10;
	const int b = 20;
	int *ip = &a;//ok
	const int *ip2 = &a;//大权限-》小权限ok
	int *ipb = &b;//error 小-》大
	const int *ipb2 = &b;
	int *ipb3 = (int*)&b;//ok
	return 0;
}

const和函数形参
const通常用在函数形参中，用来限定函数的形参，这样该函数就不会修改实参指针所指的数据。