我们来继续上一节的内容

指针数组

在数组一讲中我们知道数组在内存中相当于一串紧密排列的变量，实际上，数组名表示的就是这一块内存的首地址

对于一个int型数组来说，其地址类型为int*，可以理解为数组名本身的类型为int，可以用一个指针类型变量来存储数组的首地址

#include<stdio.h>
int main()
{
	int arr[4];
	printf("%p\n", arr);
	int *p = arr;
	int *p1 = &arr[0];
	printf("%p %p", p, p1);
	return 0;
}

都是相同的地址，也印证了我们上文所述。

指针与数组的转换：

p指向arr的任意一个元素：

1. p = arr+3; //指向arr[3]
2. p = &arr[3];

给数组元素赋值：

1. arr[3] =10;
2. *(arr+3) = 10;
3. int *p = arr+3;
   *p = 10;

数组的遍历：
数组的方法，我们就不再赘述了，下面我们用指针来看

#include<stdio.h>
int main()
{
	int arr[4] = { 0,1,2,3 };
	for (int *p = arr; p < arr + 4; p++)
	{
		printf("%d ", *p);
	}
	return 0;
}

指针和函数

指针可以作为函数的参数，在函数中，我们可以使用这个指针，来访问目标内存的值

#include<stdio.h>
void test01(int *p)
{
	*p = 0;
}
int main()
{
	int a = 1;
	test01(&a);//将a的地址传入test01中
	printf("%d", a);
	return 0;
}

我们将a传入test01中，在test01中又将a地址的值进行改变，最后在main中输出a，为0

下面我们来说在函数中，留下的问题，swap交换

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

根据地址值的交换来完成了俩个值在函数中交换，从而才能实现main函数中的俩个数的交换

数组作为函数的参数

由于我们上面说数组名就是地址，所以只要把数组的地址和长度传递给函数，就可以把数组内容传递给函数

我们来设计一个函数求一个数组中元素的和

#include<stdio.h>
int sum(int *p, int len)
{
	int sum = 0;
	for (int i = 0; i < len; i++)
	{
		sum += p[i];
	}
	return sum;
}
int main()
{
	int arr[5] = { 0,1,2,3,4 };
	int s = sum(arr, 5);
	//数组的名字就是数组的地址
	printf("%d", s);
	return 0;
}

还有一种等价写法，

int sum(int p[],int len)

函数的返回值为指针

数据类型 *函数名(参数列表){
	函数体
}
//例如：
int s;
int *sum(int x, int y){
	s = x + y;
	return &s;
}

多级指针

作为初学者，我们可以只了解一下二级指针足以

//定义普通变量和指针变量
int *pi, i = 10;
//定义二级指针变量
int **ppi;

//给指针变量赋初值
pi = &i;

//给二级指针变量赋初值
ppi = π

//我们可以直接用二级指针做普通指针的操作
//获取 i 的内容
printf("i = %d", **ppi);
//获取 i 的地址
printf("i 的地址为%d", *ppi);

在初始化二级指针 ppi 时，不能直接 ppi = &&i，因为&i 获取的是一个具体的数值，而具体数字是没有指针的。

const指针

在普通指针前面加const就得到一个新的类型称之为const指针，相应的变量称之为const指针变量

int a = 0;
const int *p = &a; 

const在前面讲变量那讲我们说过是常量的意思，一旦确定不能修改，下面我们来看指针中的const

不加const

int a = 10;
int *p = &a;
*p = 11;//内存写
int b = *p;//内存可读

加const

int a = 10;
const int *p = &a;
*p = 10;//内存不可以写
int b = *p;//内存可以读

简单的来说const就是封存住了指针星号操作里面的写内存功能