C语言—深入理解指针(2)-CSDN博客

本文链接：https://blog.csdn.net/2401_84401225/article/details/147721593

1.const修饰指针

1.2.3 const*的左右两边均放上const

1.const修饰指针

1.1 const修饰变量

先看一段代码：

#include<stdio.h>
int main()
{
	int m = 0;
	m = 20;//m值可以改
	const int n = 0;  //n为常变量（变量具有常量属性），n的值无法改变
	n = 20; //改变n的值会报错

	return 0;
}

运行会报错：

结论：

• const的作用：对⼀个变量加上⼀些限制，不能被修改。

• n本质是变量，被const修饰后，在语法上加了限制，只要我们在代码中对n进行修改，就不符合语法规则，使得n不能被修改。

这里如果想要改变n的值，该如何操作呢？

我们绕过n，使用n的地址，去修改n就能做到了：

#include<stdio.h>
int main()
{
	const int n = 0;
	printf("%d\n", n);
	int* p = &n;  //指针 p 指向n的地址
	*p = 20;      
	printf("%d\n", n);
	return 0;
}

运行结果：

结论：const修饰的变量可以通过使用该变量的地址，去修改该变量的值。

1.2 const修饰指针变量

1.2.1 const放在*的左边

•限制指针变量指向的内容(*p)，*p无法改变，p可以改变。

如：

#include<stdio.h>
int main()
{
	const int n = 0;
	const int* p = &n; //指针p指向n的地址
	printf("%p\n", p);
	int m = 1000;
	p = &m;           //指针p指向m的地址
	printf("%p\n",p);
	return 0;
}

运行结果：

p中的内容由n的地址变为m的地址，说明p可以改变。

1.2.2 const放在*的右边

•限制指针变量(p)，p无法改变，*p可以改变。

如：

#include<stdio.h>
int main()
{
	const int n = 0;
	int* const p = &n; //指针*p为n的值
	printf("%d\n", *p);
	int m = 1000;
	*p = m;           //指针*p为m的值
	printf("%d\n",*p);
	return 0;
}

运行结果：

*p中的内容由n的值变为m的值，说明*p可以改变。

1.2.3 const*的左右两边均放上const

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

•同时限制指针变量(p)和限制指针变量指向的内容(*p)，p和*p都无法改变。

2. 野指针

2.1野指针成因

2.1.1 指针未初始化

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

运行会报错：

这里会将p里面产生的随机值当作地址，找到对应的内存空间，存下20，造成非法访问，p为野指针。

2.1.2 指针越界访问

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

运行会报错：

i = 10时：

*(p++）= i就等同于arr[10] = 10，数组此时越界访问，p为野指针。

2.1.3 指针指向的空间释放

#include<stdio.h>

int* test()
{
	int n = 1000;  //n为局部变量
	return &n;
}

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

n为局部变量，在test函数使用过后会收回n的内存空间，此时指针p指向的内存空间是已经被释放的内存空间，p为野指针。

2.2规避野指针

2.2.1 指针初始化

•知道指针指向哪里就直接赋值地址。

•不知道指针应该指向哪里，可以给指针赋值NULL。

NULL 是C语言中定义的一个标识符常量，值是0，0也是地址，这个地址是无法使用的，读写该地址会报错。

初始化如下：

#include<stdio.h>
int main()
{
	int num = 10;
	int* p1 = &num;
	int* p2 = NULL;
	return 0;
}

2.2.2 小心指针越界

指针只能访问申请过的内存空间，不能超出范围访问，超出了就是越界访问。

如：数组越界访问。

2.2.3 及时置NULL，检查有效性

•当指针变量指向⼀块区域的时候，我们可以通过指针访问该区域，后期不再使用这个指针访问空间的时候，我们可以把该指针置为NULL。

•使用指针之前可以判断指针是否为NULL，不去访问NULL指针。

int main()
{    
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    int *p = &arr[0];
    int i = 0;
    for(i=0; i<10; i++)
    {
        *(p++) = i;
    }
    //此时p已经越界了，可以把p置为NULL     
    p = NULL;
    //下次使⽤的时候，判断p不为NULL的时候再使⽤
     / /... 
    p = &arr[0];//重新让p获得地址
    if(p != NULL)//判断 
    { 
       //...
    }    
    return 0;
}

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

如：不要返回局部变量的地址。

3. assert断言

3.1 assert使用

•assert头⽂件:

#include<assert.h>

assert.h头文定义了宏assert()，用于在运行时确保程序符合指定条件，如果不符合，就报错终止运行·。这个宏常常被称为“断言”。

•assert断言指针p是否为空指针：

assert(p != NULL)

assert会验证变量p是否等于NULL：

如果确实不等于NULL，程序继续运行；

否则就会终止运行，并且给出报错信息提示。

如：

#include<stdio.h>
#include<assert.h>
int main()
{
	int* p = NULL;
	assert(p != NULL);
	return 0;
}

运行报错：

该表达式为假（返回值为零），assert()就会报错，在标准错误流stderr中写⼊⼀条错误信息，显示没有通过的表达式，以及包含这个表达式的文件名和行号。

3.2 assert()优点：

1）能自动标识文件和出问题的行号；

2）有⼀种无需更改代码就能开启或关闭assert()的机制：

在#include语句的前面，定义⼀个宏NDEBUG，重新编译程序，编译器就会禁用文件中所有的assert()语句：

#define NDEBUG
#include <assert.h>

注释掉宏NDEBUG，再次编译，这样就重新启用了assert()语句。

3.3assert()缺点：

引入了额外的检查，增加了程序的运行时间。

⼀般我们可以在Debug中使用，在Release版本中选择禁用。

在VS这样的集成开发环境中，在Release版本中，直接就是优化掉了。这样在debug版本写有利于程序员排查问题，在Release版本不影响用户使用时程序的效率。

4.指针的使用和传址调用

4.1 strlen的模拟实现

strlen功能:求字符串长度，统计的是字符串中'\0'之前的字符的个数。

函数原型：

size_t strlen ( const char * str );

参数str接收⼀个字符串的起始地址，然后开始统计字符串中'\0'之前的字符个数，最终返回长度。

模拟实现：

#include<stdio.h>
#include<assert.h>
//目标求字符串长度，不期望改变字符串内容(*p)的值 加const
size_t my_strlen(const char* p)  
{
	int count = 0;
	assert(p);    //断言指针p是否为空
	while( * p)
	{
		p++;
		count++;
	}
	return count;
}


int main()
{
	char arr[] = "abcdef";
	size_t n = my_strlen(arr); //strlen函数返回值为size_t类型（unsigned int ）
	printf("%zd", n); //打印size_t类型用 zd
	return 0;
}

模拟实现只要从起始地址开始向后逐个字符的遍历，只要不是\0字符，计数器就+1，这样直到\0就停止。

4.2传值调用和传址调用

写⼀个函数，交换两个整型变量的值：

我们可能写出这样的代码：

#include<stdio.h>

void swap(int x, int y)
{
	int z = 0;
	z = x;
	x = y;
	y = z;
}

int main()
{
	int a = 3;
	int b = 5;
	printf("交换前： ");
	printf("a = %d ", a);
	printf("b = %d\n", b);
	swap(a, b);
	printf("交换后： ");
	printf("a = %d ", a);
	printf("b = %d\n", b);
	return 0;
}

运行后却发现：

我们发现其实没产生交换的效果，这是为什么呢？

swap函数中的x,y为形参，会单独创建空间

swap(a, b);

这里的实参a,b仅仅将自己的值传给了形参，a,b的各自地址与形参地址是不同的，所以这里仅仅交换形参的值，并未交换实参的值。

结论：实参传递给形参的时候，形参会单独创建⼀份临时空间来接收实参，对形参的修改不影响实参。

这里调用swap函数的时候是将变量的值传递给了函数，这种函数调用方式叫：传值调用。

那怎么交换a,b的值呢？

这里就需要通过传址调用：

#include<stdio.h>

void swap(int* x, int* y)
{
	int z = 0;
	z = *x;   //交换x,y的值 用*x,*y
	*x = *y;
	*y = z;
}

int main()
{
	int a = 3;
	int b = 5;
	printf("交换前： ");
	printf("a = %d ", a);
	printf("b = %d\n", b);
	swap(&a, &b);  //实参与形参传递地址
	printf("交换后： ");
	printf("a = %d ", a);
	printf("b = %d\n", b);
	return 0;
}

运行结果：