从0到1掌握C语言指针的使用

指针常量与常量指针

指针常量

• 指针自身的值是一个常量，不可改变，始终指向同一地址

int a = 10,b = 20;
int * const p = &a; //不能对p进行修改
* p = 30;

常量指针

• 指针指向的内容不可改变

int a = 10,b = 20;
const int * p = &a;//a的值不能改变
p = &b;

指针数组与数组指针

指针数组：存放指针的数组

int a = 10,b = 20;
int * p[3];
p[0] = &a;
p[1] = &b;

数组指针：指向数组的指针

int a[3] = {1,2,3};
int(* p)[3];
p = &a; //数组指针p指向的是整个数组a，而非数组a的首元素

数组地址和数组首元素地址

int main(){
	int a[6] = {1,2,3,4,5,6};
	int * p[6] = &a;//等号两边类型不匹配
//p是指向int类型的指针，&a是数组a的地址，不是&a[0]
	cout<<p<<endl;
return 0;
}	

数组首元素地址&a[0]和数组地址&a，数值虽然相等，含义不同

//如果想获取数组的地址
int (* p)[6] = &a;
//如果想获取数组首元素的地址
int *p = a;
int *p = &a[0];

数组指针与二维数组

假设a的地址为0x100

int main(){
	int a[2][5] = {{1,2,3,4,5},{6,7,8,9,10}};
	int(* p)[5] = a;
	cout<<p<<endl;        //0x100 数组a首元素地址&a[0....]
	cout<<p + 1<<endl;    //0x114 数组a第二元素的地址&a[1]

	cout<<* p<<endl;      //0x100 数组a[0]首元素的地址&a[0][0]
	cout<<*(p + 1)<<endl; //0x114 数组a[1]首元素的地址&a[1][0]
	cout<<*p + 1<<endl;   //0x104 数组a[0]第二元素的地址&a[0][1]

	cout<<**p<<endl;      //1  数组a[0]首元素的值a[0][0]
	cout<<**(p + 1)<<endl;//6  数组a[1]首元素的值a[1][0]
	cout<<*(*p + 1)<<endl;//2  数组a[0]第二元素的值a[0][1]
	getchar();
return 0;
}

指向指针的指针（二级指针）

int a = 10,b = 20;
int * q = &a;
int ** p = &q; //也可写成 int *(* p) = &q;
** p = 50;

指向

指向

指针p

指针q

变量a

例子

int main(){
	char * str[4] = {"welcome","to","our","Beijing"};
	char ** p =str + 1;  //p指向str[1]

	str[0] = (*p ++) + 1;  
	str[1] = * (p + 1);
	str[2] = p[1] + 3;
	str[3] = p[0] + (str[2] - str[1]);
return 0;
}

输出结果：

str[0] :o
str[1] :Beijing
str[2] :jing
str[3] :g

解析

	str[0] = (*p ++) + 1; 

*p表示str[1],指向 “ to ” 的首字符 ‘ t ’；
*p +1指向 “to” 中的 ‘ o ’ ；
执行++，p指向str[2]；指针p的指向发生改变（整个程序仅这一次）

	str[1] = * (p + 1);

p + 1指向str[3];
*(p + 1)使str[3]与str[1]都指向 “Beijing”

	str[2] = p[1] + 3;

p[1]等价于*（p + 1），指向 “Beijing” 中的 ‘ B ’；
p[1] + 3，指向 “Beijing” 中的 ‘ j ’

	str[3] = p[0] + (str[2] - str[1]);

str[2] - str[1] = 3（字符差）；
p[0] 等价于*p，代表str[2]；
p[0] + (str[2] - str[1])等价于 *p + 3，指向 “Beijing” 中的 ‘ g ’

函数指针

int max(int a,int b){
	return a > b ? a : b;
}
int(*p)(int,int) = max;//函数名等价于函数的入口地址
int x =10,y =11;
int z = p(x,y);

通过函数指针实现四则运算

int add(int a,int b){return a + b;}
int minus(int a,int b){return a - b;}
int multi(int a,int b){return a * b;}
int divide(int a,int b){return a / b;}

int process(int a,int b,int(* func)(int,int)){
	return fun(a,b);
}

int main(){
	int a = 10,b = 20;
	int res1 = process(a,b,add);
	int res2 = process(a,b,minus);
	int res3 = process(a,b,multi);
	int res4 = process(a,b,divide);
	getchar();
return 0;
}

引用和指针

引用是变量的别名

int a = 10;
int &b = a; //b是a的别名，b的值改了，a也跟着改

指针	引用
变量的地址	变量的别名
可以不初始化	必须初始化
本身可以被修改	本身不能被修改
可以为NULL	不能为NULL
有二重指针	没有二重引用
需要先解引用	直接使用