指针最基础知识点合集1（基础入门到深入理解）-CSDN博客

本文链接：https://blog.csdn.net/XSTIT/article/details/138277780

知识特点（学习方向）

内容多，本篇只是介绍了指针最最基本的一些概念，深入理解未来会连更5篇，如果需要可以先关注。

每一个知识点都讲的很细节，适合小白没基础和一些学着指针学着指针迷着了的同学复习学习

本篇知识点虽然简单，但也是未来几篇的基础，概念一定要掌握清楚，不能有半点含糊，全部都要理解掌握

1.指针是什么

类比：宾馆每个房间都有编号，计算机中每个数据也都有地址

C语⾔中给地址起了新的名字叫：指针

（内存单元的编号==地址==指针）

2.指针变量和地址

2.1取地址操作符（&）

例如：&a取出的是a所占4个字节中地址较⼩的字节的地址，再顺藤找出后面的。

2.2指针变量和解引⽤操作符（*）

2.2.1指针变量

通过取地址操作符(&)拿到的地址,把这样的地址值存放在 指针变量中.

指针变量也是⼀种变量，这种变量就是⽤来存放地址的，存放在指针变量中的值都会理解为地址

(!!!!指针变量中的值都会理解为地址)

举例子：

#include <stdio.h>

int main()
{
 int a = 10;
 int * pa = &a;//取出a的地址并存储到指针变量pa中 
 return 0;
}

（怎么去理解看指针类型呢？？？）

2.2.2解引⽤操作符（怎么使用(*)）

*pa 的意思就是通过pa中存放的地址，找到指向的空间， *pa其实就是a变量了

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

2.3指针变量的⼤⼩

（其实就是看地址需要多大空间）

如果指针变量是⽤来存放地址的，那么指针变的⼤⼩就得是4个字节的空间才可以

结论（vs环境下）：
• 32位平台下地址是32个bit位，指针变量⼤⼩是4个字节

• 64位平台下地址是64个bit位，指针变量⼤⼩是8个字节

• 注意指针变量的⼤⼩和类型是⽆关的，只要指针类型的变量，在相同的平台下，⼤⼩都是相同的

3.指针相关运算

3.1指针+-整数

#include <stdio.h>

int main()
{
 int n = 10;
 char *pc = (char*)&n;
 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;
}

char* 类型的指针变量+1跳过1个字节， int* 类型的指针变量+1跳过了4个字节。这就是指针变量的类型差异带来的变化。指针+1，其实跳过1个指针指向的元素。指针可以+1，那也可以-1

总结：（指针的类型决定了指针向前或者向后⾛⼀步有多⼤距离）

3.2指针-指针

#include <stdio.h>

int my_strlen(char* s)
{
	char* p = s;
	while (*p != '\0')
	{
		p++;
	}
	return p - s;
}

int main()

{
	char arr[] = "abc";
	printf("%d\n", my_strlen("abc"));
	return 0;
}

3.3.指针的关系运算

#include <stdio.h>

int main()
{
 int arr[10] = {1,2,3,4,5,6,7,8,9,10};
 int *p = &arr[0];
 int i = 0;
 int sz = sizeof(arr)/sizeof(arr[0]);
 while(p<arr+sz) //指针的⼤⼩⽐较 
 {
 printf("%d ", *p);
 p++;
 }
 return 0;
}

4.void*指针（⽆具体类型的指针）

1.⽆具体类型的指针

2.⽤来接受任意类型地址

3.不能直接进⾏指针的+-整数和解引⽤的运算

5.野指针

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

5.1野指针成因

5.1.1. 指针未初始化

#include <stdio.h>

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

5.1.2指针越界访问

#include <stdio.h>

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

5.1.3指针指向的空间释放

#include <stdio.h>

int* test()
{
 int n = 100;
 return &n;
}

int main()
{
 int*p = test();
 printf("%d\n", *p);
 return 0;}

6.如何规避野指针

6.1指针初始化

知道指针指哪⾥——直接赋值地址

不知道指针指哪⾥——赋值NULL

6.2⼩⼼指针越界

6.3指针变量不再使⽤时，及时置NULL，指针使⽤之前检查有效性

6.4避免返回局部变量的地址

同野指针例3

7.const修饰指针变量

int * p;//没const修饰 

int const * p;//const 放在*的左边做修饰 

int * const p;//const 放在*的右边做修

const如果放在*的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。但是指针变量本⾝的内容可变。

• const如果放在*的右边，修饰的是指针变量本⾝，保证了指针变量的内容不能修改，但是指针指向的内容，可以通过指针改变

//int main()
//{
//	const int n = 10;
//	int m = 100;
//	const int* p = &n;
//	//*p = 20;//如果还改变*p的话，vs编译器会直接报错
//
//	p = &m;//但是p的指向可以改变，因为将m的地址给了p因此现在p指向m
//
//	printf("%d\n", *p);
//	printf("%d\n", n);
//	return 0;
//}

#include <stdio.h>

//代码1 - 测试⽆const修饰的情况 

void test1()
{
 int n = 10;
 int m = 20;
 int *p = &n;
 *p = 20;//ok?

 p = &m; //ok?

//代码2 - 测试const放在*的左边情况 

void test2()
{
 int n = 10;
 int m = 20;
 const int* p = &n;
 *p = 20;//ok?

 p = &m; //ok?

}

//代码3 - 测试const放在*的右边情况 

void test3()
{
 int n = 10;
 int m = 20;
 int * const p = &n;
 *p = 20; //ok?

 p = &m; //ok?

}

//代码4 - 测试*的左右两边都有const 

void test4()
{
 int n = 10;
 int m = 20;
 int const * const p = &n;
 *p = 20; //ok?

 p = &m; //ok?

}

int main()
{
 //测试⽆const修饰的情况 
 test1();
 //测试const放在*的左边情况 
 test2();
 //测试const放在*的右边情况 
 test3();
 //测试*的左右两边都有const 
 test4();
 return 0;
}

完—

（祝大家工作顺利，学业有成！！！）