指针的运算
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通常用在函数形参中，用来限定函数的形参，这样该函数就不会修改实参指针所指的数据。