C语言 | 由浅入深，详细解读指针（第一篇）【必收藏】

1.什么是指针

生活中，我们把门牌号称为地址；在计算机中，我们把内存单元的编号也叫做地址，在 C 语言中我们把这个地址称为：指针
因此，我们可以理解为：内存单元编号 == 地址 ==指针

2. 指针变量和地址

2.1 取地址操作符

int main()
{
	int a = 0;
	return 0;
}

上述代码中变量的创建，实际上就是向内存申请了 4 个字节的空间来存储整型变量 10 ，且每个字节都有地址，如图，每个字节的地址分别是：

0x0055F754
0x0055F755
0x0055F756
0x0055F757

那么如何的到 a 的地址呢？
这个时候我们就用到了 & 操作符。

int main()
{
	int a = 10;
	&a;
	printf("%p\n", &a);
	return 0;
}

按照上述示例，代码打印出来的结果就会是：0x0055F754

2.2 指针变量

通过取地址操作符可以得到变量的地址，为了方便使用，我们应该将地址存储起来，存储在哪里呢？答案就是存储在指针变量中。

int main()
{
	int a = 10;
	int* pa = &a;
	return 0;
}

由上述代码，我们可以知道 pa 的类型是 int* ，首先 * 是在说明 pa 是一个指针变量，int 说明了指针 pa 指向的是整型类型的对象。

2.3 解引用操作符（*）

通过解引用操作符（ * ）来解读出指针 pa 所指向的内容，*pa其实就是通过 pa 中存放的地址来找到 pa 所指向的内存空间，*pa 其实上就是 a 变量了，因此 *pa = 0 ； 也就将 a 改写成 0 了。

2.4 指针变量的大小

1. 在32位的机器中，指针变量的大小为4个字节；
2. 在64位的机器中，指针变量的大小为8个字节；
3. 指针变量的大小和类型是无关的，只要指针类型的变量，在相同的平台下，大小都是相同的。

2.5 指针变量的作用

指针类型的作用是指针解引用访问，使用的访问权限是多少

char* 指针的解引用只能访问 1 个字节，而 int* 指针的解引用可以访问 4 个字节

3.void*指针

void* 指针是指针中一种特殊类型，可以理解为是一个无具体类型的指针，这种类型的指针可以指向任意类型的地址，但是，void * 类型的指针不能直接进行指针的 + - 和解引用的运算。


由此可见，void * 类型的指针不能直接进行解引用的运算。

3.const 修饰指针变量

3.1 const 修饰变量

如图所示，在创建出变量 m 之后，我们可以将 m 修改，但此时我们想加一些限制，不能修改 m 的值，只修要在 m 前加上 const ，此时 m 就不能被修改了

3.2 const 修饰指针变量

const 修饰指针变量，可以放在 * 的左边，也可以放在 * 的右边，意义是不同的。

1. int* pa;
2. int const * pa;//const 在 * 的左边
3. int * const pa;//const 在 * 的右边

分析如下代码：

//代码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;
	int const * p = &n;
	*p = 20;// err
	p = &m; // ok
}

//代码3 - 测试const在 * 右边修饰的情况
void test3()
{
	int n = 10;
	int m = 20;
	int * const p = &n;
	*p = 20;// ok
	p = &m; // err
}

//代码4 - 测试const在 * 两边修饰的情况
void test4()
{
	int n = 10;
	int m = 20;
	int const * const p = &n;
	*p = 20;// err
	p = &m; // err
}

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

分析：
test1 函数中无const修饰，指针 p 所指向的内容和指针的指向都可以被修改；
test2 函数中 const 在 * 左边修饰，表示指针 p 所指向的内容不能被修改，但是指针变量本身的内容可变；

test3 函数中 const 在 * 右边修饰，表示指针变量的内容不能被修改，但是可以修改指针 p 所指向的内容；

test4 函数中 const 在 * 两边修饰，表示指针变量的内容不能被修改，指针 p 所指向的内容也不能被修改；

4. 指针运算

4.1 指针±整数

如图为一个整型数组，我们可以通过指针的方式来打印这个数组，令指针 p 指向数组首元素，即 a[0] ,因为 p 的类型为 int*，加 1 指针 p 会向后移动 4 个字节，也就是来到 a[1] 的位置，以此类推指针 p 会依次指向各个元素，再通过对指针 p 进行解引用操作，得到 p 指针所指向的内容，从而打印出整个数组，代码如下：

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int* p = &arr[0];
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p+i));//指针+-整数
	}
	return 0;
}

4.2 指针 - 指针

指针 - 指针的绝对值指的是两个指针之间元素的个数 (两个指针必须指向同一空间)
例如：&arr[9]-&arr[0]
下面举个例子实现my_strlen函数,代码如下：

int my_strlen(char arr[],int sz)
{
	char* p = &arr[0];
	char* s = &arr[0];
	while (*p != '\0')
	{
		p++;
	}
	return p - s;
}
int main()
{
	char arr[10] = "abc";
	int sz = sizeof(arr) / sizeof(arr[0]);
	printf("%d\n", my_strlen(arr,sz));
	return 0;
}

4.3 指针的关系运算

此部分内容非常简单，见如下代码：

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

5. 野指针

5.1 野指针的成因

1.指针未初始化

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

2.指针越界访问

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;
}

3.指针指向的空间释放

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

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

n 的地址只在 test 函数内有效，当把 n 的地址传给指针 p 时，因为出了 test 函数，变量 n 的空间地址释放，导致 p 变成了野指针。

5.2 如何规避野指针

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