初阶C语言|指针

一、指针是什么？

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

理解内存，在之前的篇章也提过：

指针变量

int main()
{
    
    
	int a = 10;//在内存中开辟一块空间
	int* p = &a;//取出变量a的地址
	//a变量占4个字节的空间，这里是将a的第一个字节的地址存放在p变量中，p就是一个指针变量
	return 0;
}

总结：
指针变量，用来存放地址的变量。（存放的指针中的值都被当成地址处理）
一个小的单元到底是多大？（1个字节）
如何编址？
对于32位的机器，有32根地址线，地址就有2的32次方个，每个地址标识一个字节，那我们就可以给（2^32Byte ==2 ^32/1024KB = = 2 ^32/1024/1024MB= =2 ^32/1024/1024/1024GB= =4GB)4G的空间进行编址

可以得出：

• 在32位机器上，地址是32个0或者1组成二进制序列，那地址就是得用4个字节的空间来存储，所以一个指针变量的大小就应该是4个字节。
• 在64位机器上，有64根地址线，那一个指针变量的大小就是8个字节，才能存放一个地址

二、指针和指针类型

char* pc=NULL
int* pi=NULL;
short* ps=NULL;
long* pl=NULL;
double* pd=NULL;

char*类型的指针是为了存放char类型的地址，*说明该变量是一个指针变量，char说明该指针变量指向的变量是一个char类型

2.1指针类型的意义？

int main()
{
    
    
	int n = 10;
	char* pc = (char*) & n;//强行将整形转换为char型
	int* pi = &n;
	printf("%p\n", &n);
	printf("%p\n", pc);
	printf("%p\n", pc + 1);

	printf("%p\n", pi);
	printf("%p\n", pi + 1);
	return 0;
}

通过结果可以发现定义指针：type* p;当指针+/- n个距离，实际跳过的字节大小为n*sizeof(type)
总结：指针的类型决定了指针向前或者向后走一步有多大距离。

2.2指针的解引用

int main()
{
    
    
	int n = 0x11223344;
	char* pc = (char*)&n;
	int* pi = &n;
	*pc = 0;
	*pi = 0;
	return 0;
}

进行调试，n中的值如图：

执行*pc=0;后如图：

执行pi=0;后如图：

对比以上调试可以发现：指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）
比如：char指针解引用就只能访问一个字节，而int*的指针的解引用就能访问四个字节。

三、野指针

概念：野指针就是指针指向的位置是不可知的

3.1野指针成因

1.指针未初始化

int main()
{
    
    
	int* p;//局部变量指针未初始化，默认为随机值，编译时会报警告
	*p = 20;
	return 0;
}

2.指针越界访问

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

3.指针指向的空间释放

int* test()
{
    
    
	int a = 110;
	return &a;//返回局部变量的地址，而局部变量出函数还给操作系统了
}
int main()
{
    
    
	int* p = test();
	printf("%d", *p);

	return 0;
}

3.2如何规避野指针

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

int main()
{
    
    
	int* p = NULL;
	int a = 10;
	p = &a;
	if (p != NULL)
	{
    
    
		*p = 20;
	}
	return 0;
}

四、指针运算

• 指针±整数
• 指针-指针
• 指针的运算

4.1指针±整数

#include <stdio.h>
#define VALUES 5
int main()
{
    
    
	int arr[VALUES] = {
    
     1,2,3,4,5 };
	int* p = arr;
	for (p = &arr[0]; p < &arr[VALUES];)
	{
    
    
		*p++ = 0;//先执行*p=0;还是p++;？
	}
	return 0;
}

需要注意的是，由于C语言标准中没有规定一元运算符的执行顺序，因此表达式*p++的具体行为可能因编译器和计算机环境而异。在不同的编译器和计算机环境中，p可能会先递增再解引用，也可能会先解引用再递增。所以要表达什么意思最好加个括号

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

通过结果可以发现*(p+i)==arr[i]= =(arr+i)= =(i+arr)= =i[arr]，i[arr]说明了[ ]在这里只是作为一个操作符

4.2指针-指针

#include <stdio.h>
int my_strlen(char* s)
{
    
    
	char* p = s;
	while (*p != '\0')
	{
    
    
		p++;
	}
	return p - s;//
}
int main()
{
    
    
	char arr[6] = "abcde";
	int a=my_strlen(arr);
	printf("%d", a);
	return 0;
}

通过结果分析，指针减去指针得到的是元素的个数，需要注意的是，相减前提是两个指针指向的是同一个空间。

4.3指针的关系运算

#include <stdio.h>
#define VALUES 5
int main()
{
    
    
	int arr[VALUES] = {
    
     0,1,3,4,5 };
	int* p = arr;
	int i = 0;
	for (p=&arr[VALUES]; p> arr[0];  )
	{
    
    
		*--p = 0;
	}
	return 0;
}

将上面代码修改如下：

int main()
{
    
    
	int arr[VALUES] = {
    
     0,1,3,4,5 };
	int* p = arr;
	int i = 0;
	for (p=&arr[VALUES-1]; p>= arr[0];p--  )
	{
    
    
		*p = 0;
	}
	return 0;
}

第二段代码，p最终会与指向第一个元素之前的那个内存位置，并且与第一个元素的内存位置比较
虽然实际在绝大部分编译器上可以顺利完成任务，然而我们还是应该避免这样写，因为标准并不保证他可行
标准规定：
允许指向元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许指向第一个元素之前的那个内存位置的指针进行比较。

五、指针和数组

#include <stdio.h>
#define VALUES 5
int main()
{
    
    
	int arr[10] = {
    
     1,2,3,4,5,6,7,8,9,0 };
	printf("%p\n", arr);
	printf("%p\n", &arr[0]);
	int* p = arr;
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < sz; i++)
	{
    
    
		printf("&arr[%d]=%p===p+%d=%p\n", i, &arr[i], i, p + i);
	}
	return 0;
}

通过结果知道数组名就是数组首元素地址，数组名当成地址存放在一个指针中，可以使用指针来访问数组

#include <stdio.h>
#define VALUES 5
int main()
{
    
    
	int arr[10] = {
    
     1,2,3,4,5,6,7,8,9,0 };
	int* p = arr;
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < sz; i++)
	{
    
    
		printf("%d ", *(p + i));
	}
	return 0;
}

六、二级指针

指针变量也是变量，是变量就有地址，指针变量的地址就可以用二级指针来接收

#include <stdio.h>
int main()
{
    
    
	int a=10;
	int* p = &a;
	int** pa = p;
	return 0;
}

上图的地址都是随机的。对于二级指针的解引用和一级指针的解引用差不多，二级指针解引用得到一级指针的值，一级指针解引用得到变量的值。

#include <stdio.h>
int main()
{
    
    
	int a=10;
	int* p = &a;
	int** pa = p;
	printf("%p\n", *pa);
	printf("%d\n", *p);
	return 0;
}

结果：

七、指针数组

指针数组还是数组，用来存放指针的一个数组，就跟好孩子一样，还是一个孩子只是加了一个修饰词，同理还有字符数组，整形数组,他们存放类型如下：

#include <stdio.h>
int main()
{
    
    
	char ch[7] = "abcdef";
	printf("%s", ch);
	return 0;
}

打印字符串只要给出起始位置即可访问后面内容直到遇到’\0’为止，只有字符串才可以这样访问。

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

这里可以得出p[0]==arr, p[1]= =arr1, p[2]= =arr2
p[0] [i]= =arr[i]= =(p[0]+i);
p[1] [i]= =arr1[i]= =(p[1]+i);
p[2][i]= =arr2[i]= =*(p[2]+i);
end~