转换

• 总是可以把一个非const的值转换成const的

void f(const int * x);
int a=15;
f(&a);//OK
const int b=a;
f(&b);//OK
b=a+1;//ERROR

输入一个指针，在函数内部不改变指针所指的值。
用途：当要传递的参数的类型比地址大的时候（比如说结构体），这是常用的手段：既能用较少的字节数传递值给参数，又能避免函数对外面的变量的修改。跟数组类似，数组在传递的时候，是传递的指针。

const数组

• const int a[]={1,2,3,4,5,6,};
• 数组变量已经是const的指针了，这里的const表明数组的每个单元都是const int ,不能改变。
• 所以必须通过初始化进行赋值，否则不能赋值了

保护数组值

• 因为把数组传入函数时传递的是地址，所以那个函数内部可以修改数组的值
• 为了保护数组不被函数破坏，可以设置参数为const
  • int sum(const int a[],int length);
    习题：
    对于：int a[] = {5, 15, 34, 54, 14, 2, 52, 72}; int *p = &a[5];则：p[-2]的值是？
    值应该是54，p是指向a[5]的，也就是说p[0]的内容就是a[5] 。那么p[1]的内容是a[6]， p[-2]内容就是a[5]往前两个，也就是a[3]了。

指针运算

#include <stdio.h>

int main(void) {
	char ac[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9,};
	char *p = ac;
	printf("p=%p", p);
	printf("p+1=%p", p + 1);
	return 0;
}

输出结果：p=000000000061FE0E p+1=000000000061FE0F
p+1在p的地址上前进了一位。

#include <stdio.h>

int main(void) {
	char ac[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9,};
	char *p = ac;
	printf("p=%p", p);
	printf("p+1=%p", p + 1);

	int ai[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9,};
	int *q = ai;
	printf("q=%p", q);
	printf("q+1=%p", q + 1);
	return 0;
}

输出结果：p=000000000061FE06 p+1=000000000061FE07 q=000000000061FDD0 q+1=000000000061FDD4
原因：char是一位，int是4位，所以往后移动的长度不同，指针加1是加了一个sizeof。

*p->ac[0]
*(p+1)->ac[1]

指针运算小结

• ac->&ac[0]

1. 给指针加1表示要让指针指向下一个变量

• int a[10];
• int *p=a;
• *(p+1)->a[1]
• 如果指针不是指向一片连续分配的空间，如数组，则这种运算没有意义
• *(p+n)->ac[n]

2. 这些运算可以对指针做

• 给指针加、减一个整数（+，+=，-，-=）
• 加是往后挪，减是往前挪
• 递增递减（++/–）

两个指针相减

#include <stdio.h>

int main(void) {
	char ac[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9,};
	char *p = ac;
	char *p1 = &ac[5];
	printf("p=%p\n", p);
	printf("p+1=%p\n", p + 1);
	printf("p1-p=%d\n", p1 - p);

	int ai[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9,};
	int *q = ai;
	int *q1 = &ai[6];
	printf("\nq=%p\n", q);
	printf("q+1=%p\n", q + 1);
	printf("q1-q=%d\n\n", q1 - q);
	return 0;
}

结果：p=000000000061FDF6
p+1=000000000061FDF7
p1-p=5

q=000000000061FDC0
q1=000000000061FDD8
q1-q=6
c0:192
D8:216
差值24。
24/4=6
指针的减法：地址差/sizeof(数据类型)