c++(指针)

每天进步一点，进步一点！！感谢自己


文章目录

• 指针
• • 一 指针是啥
  • 二 野指针
  • • • 瑱瑱野指针成因
  • 甆甆三 指针运算
  • • 窱窱 指针+-整数
  • 四 指针-指针
  • ⚽⚽五 指针和数组
  • 六 二级指针
  • ⚾⚾七 指针数组——存放指针的数组
  • 刺刺八 数组指针
  • •  数组指针的定义
    • &数组名vs数组
    • 数组指针的使用
    • 論論二维数组传参
    • • 判断
  • 二级指针传参
  • • 函数指针——指向函数的指针- 存放函数地址的一个指针

指针 一 指针是啥

• ⚽⚽指针是编程语言中的一个对象，利用地址，它的值直接指向存在电脑储存器中另一个地方的值。由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元，因此，将指针形象化称“为指针”。
• ⚽⚽总结：指针就是变量，用来存放地址的变量（存放的指针的值都被当成地址来处理）。
• ⚽⚽存储大小：（与地址线根数有关）
  32位机器，四字节
  64位机器，八字节
• ⚽⚽指针和指针类型
  指针类型决定了指针进行解引用操作的时候，能够访问的空间大小。

指针类型	访问权限大小	指针的步长
int* p	4字节	4字节
char*	p1字节	1字节
double*p	8字节	8字节

二 野指针

野指针：指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）

瑱瑱野指针成因

• 1. 指针未初始化

#include
int  main()
{
	int *p;//局部变量指针未初始化，默认为随机值
	*p=20;
	return 0;
}

• 2. 指针越界访问

#include
int main()
{
	int arr[10]={};
	int *p=arr;
	for(int i=0;i<11;i++)
	{
		*(p++)=i;//当指针指向的范围超出数组的范围时，p就是野指针
	}
	return 0;
}

• 3. 指针只想的空间释放

甆甆三 指针运算 窱窱 指针±整数

#include
#define N_VALUES 5
float values[N_VALUES];
float *vp;
//指针加减整数：指针的运算关系
int main()
{
	for(vp=&values[0];vp<&values[N_VALUES])
	*vp++=0;
}

四 指针-指针

#include

int my_strlen(char* str)
{
	char* start=str;
	char* end=str;
	while(*end !="")
	{
		end++;
	}
	return end-start;
}

int main()
{
	char arr[]="bit";
	int len=my_strlen(arr);
	printf("%dn",len);
	return 0;
}

#define N_VALUES 5
float values[N_VALUES];
float *vp;
for(vp=&values[N_VALUES];vp>&values[0])
{
	*--vp=0;
}

标准规定：
允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那块内存位置的指针进行比较。

⚽⚽五 指针和数组

printf("%pn",arr);//地址——首元素的地址
printf("%pn",&arr);//取出的是整个数组的地址

int main()
{
	int arr[10]={0};
	int *p=arr;
	int i=0;
	for(i=0;i<10;i++)
	{
		printf("%p ==== %pn",p+i,&arr[i]);
	}
	return 0;
}

int main()
{
	int arr[10]={0};
	int* p=arr;
	int i=0;
	for(i=0;i<10;i++)
	{
		*(p+i)=i;
	}
	for(i=0;i<10;i++)
	{
		printf("%d",*(p+i));
	}
	return 0;
}

六 二级指针

int main()
{
	int a=10;
	int* pa=&a;
	int** ppa=&pa;//ppa就是二级指针
	** ppa=20;
	printf("%dn",**ppa);
	prinf("%dn",a);
}

⚾⚾七 指针数组——存放指针的数组

int main()
{
	int a=10;
	int b=20;
	int c=30;
	int* arr[3]={&a,&b,&c};
	for(int i=0;i<3;i++)
	{
		printf("%dn",*(arr[i]));
	}
	return 0;
}

刺刺八 数组指针  数组指针的定义

int (p)[10];
解释：p先和结合，说明p是一个指针，然后指向的是一个大小为10个整形的数组。然后p是一个指针，指向一个数组，叫数组指针。

&数组名vs数组

&arr表示的是数组的地址，而不是数组首元素的地址。
数组的地址+1，跳过整个数组的大小。

数组指针的使用

一个数组指针的使用

//参数是数组的形式
void print1(int arr[3][5],int x,int y)
{
	int i=0,j=0;
	for(i=0;i
		for(j=0;j
			printf("%d",arr[i][j]);
		}
		printf("n");
	}
}
//参数是指针的形式
void print2(int(*p)[5],int x,int y)
{
	int i=0;
	for(i=0;i
		for(int j=0;j
			//printf("%d",*(*(p+i)+j));
			printf("%d",(*(p+i))[j]);
		}
		printf("n");	
	}
}

int main()
{
	int arr[3][5]={{1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7}};
	print1(arr,3,5);
	print2(arr,3,5);
	return 0;
}

>int arr[5]; //arr是一个5个元素的整型数组
>int *parr1[10]; //parr1是一个数组，数组有10个元素，每个元素的类型是int *,parr1是指针数组
>int(*parr2)[10]; //parr2是一个指针，该指针指向一个数组，数组有10个元素，每个元素的类型是int parr2是一个数组指针
>int(* parr3[10])[5]; //parr3是一个数组，该数组有10个元素，每个元素是一个数组指针
>					 //该数组指针指向的数组有5个元素，每个元素是int 

論論二维数组传参

二维数组传参，函数形参的设计只能省略第一个【】的数字。
因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。

void test(int arr[][5]);

判断

void test(int *arr);//错误 
void test(int *arr[5]);//错误  
void test(int (*arr)[5]);//正确
void test(int **arr);//错误 应该用一级指针来接收
int main()
{
	int arr[3][5]={0};
	test(arr);	
}

#include
void print(int *p,int sz)
{
	int i=0;
	for(i=0;i
		printf("%dn",*(P+i));
	}
}

int main()
{
	int arr[10]={1,2,3,4,5,6,7,8,9};
	int *p=arr;
	int sz=sizeof(arr)/sizeof(arr[0]);
	print(p,sz);//一级指针p，传给函数
	return 0;
}

void test01(int* p)
{
	
}
int main()
{
	int a=10;
	int *p1=&a;
	test01(&a);
	test01(p1);
	return 0;
}

二级指针传参

#include
void test(int ** ptr)
{
	printf("num=%dn",**ptr);
}
int main()
{
	int n=10;
	int *p=&n;
	int **pp=&p;
	test(pp);
	test(&p);
	int *arr[10];
	test(arr);//指针数组也可以
	return 0;
}

函数指针——指向函数的指针- 存放函数地址的一个指针

int Add(int x,int y)
{
	int z=0;
	z=x+y;
	return z;
}
int main()
{
	int a=10;
	int b=20;
	int arr[10]={0};
	printf("%Pn",&Add);
	printf("%pn",Add);
	return 0;
}

void print(char *str)
{
	printf("%sn",str);
}
int main()
{
	void (*p)(char*)=print;
	(*p)("hello bit");
	return 0;
}