C语言指针-初阶

1. 指针是什么

指针理解的2个要点：

1. 指针是内存中一个最小单元的编号，也就是地址
2. 平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量

指针变量
我们可以通过&（取地址操作符）取出变量的内存起始地址，把地址可以存放到一个变量中，这个变量就是指针变量

#include <stdio.h>
int main()
{
 int a = 10;//在内存中开辟一块空间
 int *p = &a;//这里我们对变量a，取出它的地址，可以使用&操作符。
    //a变量占用4个字节的空间，这里是将a的4个字节的**第一个字节的地址**存放在p变量
中，p就是一个之指针变量。
 return 0;
}

关于指针类型的大小：

int main(){//Win32平台下
printf("%d %d %d %d %d\n", sizeof(short*), sizeof(int*), sizeof(char*), sizeof(long*), sizeof(double*));
return 0;
}//4 4 4 4 4
//指针大小为8个字节（在64位处理器中），32位处理器中为4个字节

总结：

指针变量，用来存放地址的变量。（存放在指针中的值都被当成地址处理）。
指针的大小在32位平台是4个字节，在64位平台是8个字节。

2. 指针和指针类型

指针的定义方式是： type + *
其实：
char* 类型的指针是为了存放 char 类型变量的地址。
short* 类型的指针是为了存放 short 类型变量的地址。
int* 类型的指针是为了存放 int 类型变量的地址。
那指针类型的意义是什么？

2.1 指针±整数

2.1.1指针类型决定了指针走一步走多远（指针步长）

指针类型决定了指针走一步走多远（指针步长）,比如
int* p;p+1–>4字节
char* p;p+1–>1字节
double* p;p+1->8字节

#include <stdio.h>
//演示实例
int main()
{
	int a = 0x11223344;
    int* pa = &a;
	char* pc = (char*) & a;
	printf("%p\n%p\n", pa,pa+1);
	printf("%p\n%p\n", pc,pc+1);
 return  0;
}

显然，int类型指针访问4字节空间，char 访问1字节
这里的 1 我们可以理解为指针类型的1个步长

2.1.2指针类型决定了指针进行解引操作时能访问的空间大小

指针类型决定了指针进行解引操作时能访问的空间大小,比如
int *p *p能访问4个字节
char *p *p能访问1个字节
double *p *p能访问8个字节

示例：

	int arr[10] = { 0 };
	char *p = (char*)arr;
	int i = 0;

	for (i = 0; i < 10; i++) {
		*(p + i) = 1;
		printf("%x\n", *(p + i));
	}
//* 调试-逐语句-快速监视输入地址arr地址观察,F11走

arr数组元素初始化为0，char类型指针解引用(p + i)每次循环访问赋值1个字节数据。每个数组元素为4个字节，循环结束访问修改前10个字节元素为1

char类型指针每次循环只能访问一个字节空间，循环10次后只能改变arr数组元素前十个字节数据，int类型数组共有10个元素，每个元素有4字节空间，最终只能改变数组中前两个半元素的值

显然，内存中arr数组元素共占用40字节空间，循环结束只有10字节空间修改为1

3. 野指针

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

3.1 野指针成因

1. 指针未初始化

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

2.2. 指针越界访问

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

3. 指针指向的空间释放–这里放在动态内存开辟中具体讲解
   我们来看一段代码：

int* test() {
	int a = 1024;
	return &a;//返回局部或临时变量a的地址1
}//局部变量a出函数后销毁，将地址1指向空间还给操作系统

int main() {
	int* p = test();//返回临时变量（a已销毁）地址1，但无法访问
	printf("%d", *p);//非法访问该程序未申请空间的地址，仍能得到a的值,多次运行发现存储a值的地址不断变化 如008ffd60 003ef888...
	 
	int* p=NULL;//若*p指向的空间已被还给系统，要想让其合法存在，可以将*p赋空值
	*p = 10;//代码异常---不可访问或修改空指针
	if (p != NULL) {
		*p = 20;
	}printf("%d\n%p", *p,p);
	return 0;
}

3.2 如何规避野指针

1. 指针初始化
2. 小心指针越界
3. 指针指向空间释放，及时置NULL
4. 避免返回局部变量的地址
5. 指针使用之前检查有效性

#include <stdio.h>
int main()
{
    int *p = NULL;
    //....
    int a = 10;
    p = &a;
    if(p != NULL)
   {
        *p = 20;
   }
    return 0;
}

4. 指针运算

指针± 整数
指针-指针
指针的关系运算

4.1指针± 整数

#define N_VALUES 5
float values[N_VALUES];
float *vp;
//指针+-整数；指针的关系运算
for (vp = &values[0]; vp < &values[N_VALUES];)
{
     *vp++ = 0;
}

4.2指针-指针

   int main() {
   	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
   	char arr1[5] = { 1,2,3,4,5 };
   	printf("%d", &arr[9] - &arr[0]);//指针-指针 得到的是中间元素的个数（两个指针必须指向同一个空间）
   	//&arr[9]-&arr1[0]//error
	return 0;
   }

4.3 指针的关系运算

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

实际在绝大部分的编译器上是可以顺利完成任务的，然而我们还是应该避免这样写，因为标准并不保证
它可行。

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

模拟strlen的实现：

   int my_strlen(char drt[]) {
   	char* start = drt;
   	char* end = drt;
   	while (*end != '\0') {
   		end++;
   	}//循环结束后char类型指针end记录数组最后一个字符存储的地址
   	return end - start;

   }
   int main() {
   	char str[] = "bit";
   	//strlen函数测量字符数组长度与字符个数
   	printf("%d", my_strlen(str));
   		return 0;
   }

补充：

5. 指针和数组

数组名表示的是数组首元素的地址。（2种情况除外）
既然可以把数组名当成地址存放到一个指针中，我们使用指针来访问一个就成为可能。

所以 p+i 其实计算的是数组 arr 下标为i的地址
那我们就可以直接通过指针来访问数组。
如下：

int main()
{
 int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
 int *p = arr; //指针存放数组首元素的地址
 int sz = sizeof(arr) / sizeof(arr[0]);
 int i = 0;
 for (i = 0; i<sz; i++)
 {
 printf("%d ", *(p + i));
 }
 return 0;
}

6. 二级指针

7. 指针数组

指针数组是数组。是存放指针的数组。

int main() {
	int a = 1, b = 2, c = 3;
	int* pa = &a, * pb = &b, * pc = &c;
	int* arr[3] = { pa,pb,pc };
	for (int i = 0; i < 3; i++) {
		printf("%p<=====>%d\n", arr[i], *arr[i]);
	}
}arr是一个包含3个整形指针作为数组元素的指针数组