C语言【指针篇】（二）-CSDN博客

本文链接：https://blog.csdn.net/2401_86940607/article/details/145838569

前言

这是指针的第二部分，主要包括const修饰指针、野指针、assert断言和指针的使用和传址调用，可以根据需要跳转

指针（二）

正文

1. const修饰指针

1.1 const修饰变量

变量通常是可修改的，若将变量地址交给指针变量，通过指针也能修改该变量。但有时希望对变量加以限制，使其不可修改，这便是const的作用。

#include <stdio.h>
int main()
{
    int m = 0;
    m = 20; // m是可以修改的
    const int n = 0;
    n = 20; // n是不能被修改的，修改会报错
    return 0;
}

上述代码中，n本质是变量，被const修饰后，语法上禁止对其修改。不过，绕过n，使用其地址仍能修改，尽管这种做法违反语法规则。

//const 修饰指针——常属性（不能修改）
#include <stdio.h>
int main()
{
    const int n = 0;
    printf("n = %d\n", n);
    int* p = &n;
    *p = 20;
    printf("n = %d\n", n);
    return 0;
}

1.2 const修饰指针变量

一般来讲，const修饰指针变量时，放在*的左边或右边意义不同。

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

通过以下代码分析具体情况：

#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; // error，不能通过指针修改指向的内容
    p = &m; // ok，指针变量本身的内容可变
}
// 代码3 - 测试const放在*的右边情况
void test3()
{
    int n = 10;
    int m = 20;
    int * const p = &n;
    *p = 20; // ok，指针指向的内容可通过指针改变
    p = &m; // error，指针变量本身的内容不能修改
}
// 代码4 - 测试*的左右两边都有const
void test4()
{
    int n = 10;
    int m = 20;
    int const * const p = &n;
    *p = 20; // error，不能通过指针修改指向的内容
    p = &m; // error，指针变量本身的内容不能修改
}
int main()
{
    test1();
    test2();
    test3(); 
    test4();
    return 0;
}

结论：

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

2. 野指针

2.1 野指针成因

指针未初始化

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

指针越界访问

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

指针指向的空间释放

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

2.2 如何规避野指针

指针初始化：如果明确知道指针指向哪里就直接赋值地址，如果不知道指针应该指向哪里，可以给指针赋值NULL。NULL是C语言中定义的一个标识符常量，值是0，0也是地址，读写该地址会报错。

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

小心指针越界：一个程序向内存申请了哪些空间，通过指针也就只能访问哪些空间，不能超出范围访问。
指针变量不再使用时，及时置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) // 判断
    {
        // 使用p
    }
    return 0;
}

避免返回局部变量的地址：不要返回局部变量的地址，如造成野指针的第3个例子。

3. assert断言

在上一部分，我们使用如下代码

 p = &arr[0];//重新让p获得地址
    if(p != NULL) // 判断
    {
        // 使用p
    }

但实际上，这个功能也可以用assert()函数来完成，assert.h头文件定义了宏assert()，用于在运行时确保程序符合指定条件，若不符合则报错终止运行，这个宏常被称为“断言”。

assert(p != NULL);

上述代码在程序运行到这一行时，验证变量p是否等于NULL。若不等于NULL，程序继续运行；否则终止运行并给出报错信息提示。

assert()宏接受一个表达式作为参数。如果该表达式为真（返回值非零），assert()不会产生任何作用；如果该表达式为假（返回值为零），assert()就会报错，在标准错误流stderr中写入一条错误信息，显示未通过的表达式，以及包含这个表达式的文件名和行号。

使用assert()的好处：能自动标识文件和出问题的行号，且有一种无需更改代码就能开启或关闭assert()的机制。若确认程序没问题，无需再做断言，在#include <assert.h>语句的前面，定义一个宏NDEBUG。

#define NDEBUG
#include <assert.h>

然后重新编译程序，编译器会禁用文件中所有的assert()语句。若程序又出现问题，移除这条#define NDEBUG指令（或注释掉），再次编译，就重新启用了assert()语句。

assert()的缺点是引入额外检查，增加程序运行时间。一般在Debug中使用，在Release版本中选择禁用assert，在VS这样的集成开发环境中，Release版本会直接优化掉assert。这样在debug版本有利于程序员排查问题，在Release版本不影响用户使用时程序的效率。

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

4.1 strlen的模拟实现

库函数strlen的功能是求字符串长度，统计的是字符串中\0之前的字符的个数。函数原型如下：

size_t strlen ( const char * str );

参数str接收一个字符串的起始地址，然后开始统计字符串中\0之前的字符个数，最终返回长度。模拟实现时，从起始地址开始向后逐个字符遍历，只要不是\0字符，计数器就+1，直到遇到\0停止。（基于上一篇文章的完善）

size_t my_strlen(const char* p)
{
	char* q = p;
	assert(p != NULL);
	while (*q != '\0')
	{
		q++;
	}
	return q - p;//指针 - 指针 
}
int main()
{
	char arr[] = "abcdef";

	size_t len = my_strlen(arr);
	printf("%zd", len);
	return 0;
}

4.2 传值调用和传址调用

学习指针的目的是使用指针解决问题。例如，写一个函数交换两个整型变量的值。

#include <stdio.h>
void Swap1(int x, int y)
{
    int tmp = x;
    x = y;
    y = tmp;
}
int main()
{
    int a = 0;
    int b = 0;
    scanf("%d %d", &a, &b);
    printf("交换前:a=%d b=%d\n", a, b);
    Swap1(a, b);
    printf("交换后:a=%d b=%d\n", a, b);
    return 0;
}

运行上述代码，发现未产生交换效果。调试可知，main函数中a和b的地址与Swap1函数中形参x和y的地址不同，x和y是独立空间，在Swap1函数内部交换x和y的值不会影响a和b。这种把变量本身直接传递给函数的调用方式叫传值调用。

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

若要实现交换功能，可以使用指针，在main函数中将a和b的地址传递给函数，函数通过地址间接操作main函数中的a和b。

#include <stdio.h>
void* Swap(int* x, int* y)
{
	int* temp = 0;
	temp = *x;
	*x = *y;
	*y = temp;
}

int main()
{
	int a = 10;
	int b = 20;
	//写一个函数用于a和b的值交换
	Swap(&a, &b);
	printf("交换后a = %d b = %d", a, b);
	return 0;
}