六、指 针

一、概述

二、定义和使用

（一）定义：

一般格式：
类型名 指针变量名
例如：int p；

	//指针定义 
	int* p;//类型：int *，变量名：p 
	printf("%d\n",p);//若未赋值则为随机值 
	
	//指针指向谁，就是谁把地址给这个指针
	int a = 10;
	int *n = &a;
	printf("n = %p &a = %p\n",n,&a); //指针n保存的是a的地址 
	
	//指针变量不指向地址则没有意义，若需要操作指针指向地址的内容，需要使用*p 
	printf("*p = %d a = %d\n",*n,a); 

（二）使用：

分析下列代码输出值为多少：
1.

	int a = 100;
	int b = 10;
	int* p;
	int* q;
	
	p = &a;
	q = &b;
	printf("a = %d b = %d\n",a,b);//a = 100 b = 10
	printf("*p = %d *q = %d\n",*p,*q);//*p = 100 *q = 10

2.

	int a = 10;
	int b = 20;
	int* p = &a;;
	*p = 100;
	printf("a = %d *p = %d\n",a,*p);//a = 100 *p = 100
	p = &b;
	*p = 200;
	printf("b = %d,*p = %d\n",b,*p);//b = 200 *p = 200

3.

	int a = 10;
	int* p = &a;
	int b = *p;// b = 10
	*p = 100;//b = 100 
	printf("a = %d b = %d",a,b);//a = 100 b = 10

（三）指针大小：

double* p;
	double*** q;//多级指针 
	
	int a = sizeof(int*);
	int b = sizeof(char*);
	int c = sizeof(p);
	int d = sizeof(q); 
	printf("a = %d b = %d c = %d d = %d\n",a,b,c,d);//a = 4 b = 4 c = 4 d = 4 

不管是否为多级指针，只要是指针，大小均为4（32位平台：4字节，4x8=32）
注：64位平台的指针大小为8字节（64位：8字节，8x8=64）

（四）各类指针：

1.野指针：

见任意数值赋值给指针变量

int a = 10;
int* p = a;//p = a的地址
p = 0x123;//将0x123给p，内存中可能已经有0x123的内存空间未被操作，p会指向它，但是我们无权调用，出现异常
*p = 1000;

注：地址由系统分配，不要自己分配，野指针指向的地址没有意义，操作野指针没有问题，但操作野指针指向的值就hi有问题

2.空指针：

指针指向位空，即默认值位NULL（0）
int* p = NULL;

3.万能指针：

由void* 定义的

	void* p = NULL;
	int a = 10;
	p = &a;
	printf("*p = %d\n",*p);//编译出错，int类似的地址赋给void类型的指针，无法确定字节大小 

修改：

	void* p = NULL;
	int a = 10;
	p = &a;
	printf("*p = %d\n",*(int*)p);//使用强制转换，说明需要的字节数 

注意：可以定义void*，其可以指向任意变量，在使用时替换为指向的类型（强制转换）

4.const修饰的指针：

	int* p1 = NULL;
	int a = 10;
	p1 = &a;
	*p1 = 20; 
	
	//const修饰类型 
	const int* p2 = &a;
	*p2 = 100;//此处报错，用const修饰指针指向的内存是只读的，即*p2只读 
	p2 = 100;//此处正确，const int* p2只对int*起作用，对p2不起作用 
	
	//const修饰指针变量
	int* const p3 = &a;
	*p3 = 100;//此处正确 
	p3 = NULL;// 此处错误，const使p3变为只读 

三、多级指针

考研不考，了解

四、指针与数组

（一）数组名：

数组名是首元素的地址，数组名是常量，不能修改

	int a[10]; 
	printf("数组名a：%p,a[0]的地址：%p",a,&a[0]);//记得给a[0]前加上& 

注：a = 1；是错误的

（二）通过指针操作数组元素：

1.指针输出数组元素：

int a[5] = {1,2,3,4,5}; 
int* p = NULL;

p = &a[0];//或p = a;//数组首地址即为数组名，a == a[0] 

//数组方式输出 
for(int i = 0;i < 5;i ++){
	printf("%d ",a[i]);
} 
printf("\n------------------------------\n"); 
//指针方式输出 
for(int i = 0;i < 5;i ++){
	printf("%d ",*(p + i));//从p开始（a[o]）,依次输出 
} 
printf("\n------------------------------\n"); 
//指针作为数组输出 
for(int i = 0;i < 5;i ++){
	printf("%d ",p[i]);
} 

2.指针加法（指针依次向下一个元素移动）：

int a[5] = {1,2,3,4,5}; 
int* p = NULL;

p = &a[0];//或p = a;//数组首地址即为数组名，a == a[0] 

//数组方式输出 
for(int i = 0;i < 5;i ++){
	printf("%d ",*p);
	p ++;//循环一次，指针向下一个移动 
} 

3.指针数组：

本身是数组，数组元素为指针

int a[] = {0,1,2}; 
int* p[3];//指针数组 
for(int i = 0;i < 3;i ++){
	p[i] = &a[i];//注意a[i]有取地址符 
	printf("%d ",*p[i]);
} 

五、指针与函数

注：
值传递：swap(a,b); 地址传递(&a,&b);

（一）通过地址传递交换两个数的值：

int swap(int *a,int *b);
int main(){
	int a = 10;
	int b = 20;
	swap(&a,&b);
	printf("a = %d b = %d\n",a,b);
	return 0;
}

int swap(int *a,int *b){
	int t;
	t = *a;
	*a = *b;
	*b = t;
}

（二）用函数打印数组元素：

int printArray(int a[]);
int main(){
	int a[] = {1,2,3,4,5,6,7,8,9,10};
	printArray(a);
	return 0;
}

int printArray(int a[]){
	int n = sizeof(a) / sizeof(a[0]);
	for(int i = 0;i < n;i ++){
		printf("%d ",a[i]);
	}
}

以上内容只打印了1，为什么？
解答：
形参中的数组并不是数组，而是指针变量：void printArray(int a[])与void printArray(int a)等价，都是void printArray(int a)**

*在32位机中，int a为4字节，则int n = sizeof(a) / sizeof(a[0]);的结果为1

解决办法：
在main中提前求出n：

int printArray(int a[],int n);
int main(){
	int a[] = {1,2,3,4,5,6,7,8,9,10};
	int n = sizeof(a) / sizeof(a[0]);
	printArray(a,n);
	return 0;
}

int printArray(int a[],int n){
	for(int i = 0;i < n;i ++){
		printf("%d ",a[i]);
	}
}

六、指针与字符串：

（一）字符指针：

char* 变量名；

char str[] = "hello";
char* p = NULL;

p = str;
printf("%d\n",p);
p = &str[0];
printf("%d\n",p);
//元素名==元素首地址 

*p = 'a';
p ++;
*p = 'b';
printf("%s\n",str);//abllo 

（二）字符串拷贝：

方法一：调用库函数：

	char src[] = "hello word!";
	char* p;
	strcpy(p,src);
	printf("%s",p);

方法二：自定义函数：

void my_strcpy(char* dst,char* src);
int main(){
	char src[] = "hello word!";
	char dst[100];
	my_strcpy(dst,src);
	printf("%s \n",dst);
	return 0;
}

void my_strcpy(char* dst,char* src){
	int i = 0;
	while(*(src + i) != '\0'){
		*(dst + i) = *(src + i);
		i++;
	}
	*(dst + i) = '\0';//提示编译器循环拷贝已结束，没有这句出现乱码 
}

（三）const修饰：

	char str[] = "hello";
	char* p = str;
	*p = 'a';
	printf("%s \n",str);//aello
	
	//使用const修饰指针*
	const char * p1 = str;
	*p1 = 'b';
	p1 = NULL; //正常 
	printf("%s \n",str);//报错，指针指向的内容只读，不能修改 
	
	//使用const修饰指针变量
	char * const p2 = str;
	 *p2 = 'c';//正常 
	 p2 = NULL;//报错，指针变量本身只读，不可以修改 
	 printf("%s \n",str);