[C语言]第十三节 指针一基础知识到高级技巧的全景探索

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

#include <stdio.h>
int main()
{
    int a = 10;
    &a;//取出a的地址
    printf("%p\n", &a);
    return 0;
}

按照上述的图,会打印处理：006FFD70 &a取出的是a所占4个字节中地址较⼩的字节的地 址。 变量在内存中的存储 虽然整型变量占⽤4个字节，我们只要知道了第⼀个字节地址，顺藤摸⽠访问到4个字节的数据也是可 ⾏的。

#include <stdio.h>
int main()
{
    int a = 10;
    int* pa = &a;//取出a的地址并存储到指针变量pa中

    return 0;
}

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

int a = 10;
int * pa = &a;

char ch = 'w';
pc = &ch;

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

   上⾯代码中第7⾏就使⽤了解引⽤操作符， *pa 的意思就是通过pa中存放的地址，找到指向的空间， *pa其实就是a变量了；所以*pa = 0，这个操作符是把a改成了0. 

#include <stdio.h>
//指针变量的⼤⼩取决于地址的⼤⼩
//32位平台下地址是32个bit位（即4个字节）
//64位平台下地址是64个bit位（即8个字节）
int main()
{
    printf("%zd\n", sizeof(char *));
    printf("%zd\n", sizeof(short *));
    printf("%zd\n", sizeof(int *));
    printf("%zd\n", sizeof(double *));
    return 0;
}

X86环境输出结果                                                    X64环境输出结果

//代码1
#include <stdio.h>
int main()
{
    int n = 0x11223344;
    int *pi = &n;
    *pi = 0;
    return 0;
}

//代码2
#include <stdio.h>
int main()
{
    int n = 0x11223344;
    char *pc = (char *)&n;
    *pc = 0;
    return 0;
}

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

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

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

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

#include <stdio.h>

// 代码1
void test1()
{
    int n = 10;
    int m = 20;
    int* p = &n;
    printf("Before: n = %d\n", n);  // 打印 n 的初始值
    *p = 20;  // 修改 n 的值
    printf("After *p = 20: n = %d\n", n);  // 打印修改后的 n
    p = &m;   // p 指向 m，但不影响 n
    printf("After p = &m: n = %d\n", n);  // n 不受影响
}

// 代码2
void test2()
{
    int n = 10;
    int m = 20;
    const int* p = &n;
    printf("Before: n = %d\n", n);  // 打印 n 的初始值
    // *p = 20;  // 错误，不能修改 *p 指向的内容
    p = &m;   // p 指向 m，但不影响 n
    printf("After p = &m: n = %d\n", n);  // n 不受影响
}

// 代码3
void test3()
{
    int n = 10;
    int m = 20;
    int* const p = &n;
    printf("Before: n = %d\n", n);  // 打印 n 的初始值
    *p = 20;  // 修改 n 的值
    printf("After *p = 20: n = %d\n", n);  // 打印修改后的 n
    // p = &m;   // 错误，p 是常量指针，不能重新赋值
    printf("After p = &m (not executed): n = %d\n", n);  // n 不受影响
}

// 代码4
void test4()
{
    int n = 10;
    int m = 20;
    int const* const p = &n;
    printf("Before: n = %d\n", n);  // 打印 n 的初始值
    // *p = 20;  // 错误，p 指向的内容是常量，不能修改
    // p = &m;   // 错误，p 是常量指针，不能重新赋值
    printf("After (no operations on n): n = %d\n", n);  // n 不受影响
}

int main()
{
    // 测试无 const 修饰的情况
    printf("Test 1:\n");
    test1();
    
    // 测试 const 放在 * 的左边情况
    printf("\nTest 2:\n");
    test2();
    
    // 测试 const 放在 * 的右边情况
    printf("\nTest 3:\n");
    test3();
    
    // 测试 * 的左右两边都有 const
    printf("\nTest 4:\n");
    test4();

    return 0;
}

代码1

代码2

代码3

代码4

• test2()：由于 p 是 const int*，不能修改 *p 指向的值。p 可以重新指向 m，但 n 的值不变。
• test3()：由于 p 是常量指针，不能重新指向 m。但是，*p = 20 会修改 n 的值为 20。
• test4()：由于 p 是常量指针且指向常量数据，既不能修改 p 指向的内容，也不能修改指针本身。n 保持不变。

因为数组在内存中是连续存放的，只要知道第⼀个元素的地址，顺藤摸⽠就能找到后⾯的所有元素。

int arr[10] = {1,2,3,4,5,6,7,8,9,10};

​​​​​​​int arr[10] = {1,2,3,4,5,6,7,8,9,10};
数组元素和下标
#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]);
    for(i=0; i<sz; i++)
    {
        printf("%d ", *(p+i));//p+i 这⾥就是指针+整数
    }
    return 0;
}

#include <stdio.h>

// 自定义字符串长度计算函数
int my_strlen(char *s)
{
    char *p = s;      // 声明一个指针 p，并初始化为指向字符串 s 的起始位置
    while (*p != '\0') // 遍历字符串，直到遇到字符串结束符 '\0'
        p++;           // p 向后移动，指向下一个字符
    return p - s;      // 返回指针 p 和指针 s 之间的差值，即字符串的长度
}

int main()
{
    printf("%d\n", my_strlen("abc"));  // 输出 "abc" 的长度
    return 0;
}

my_strlen("abc") 会返回 3，因为 "abc" 是由 3 个字符组成的字符串。

#include <stdio.h>

int main()
{
    // 定义一个包含 10 个整数的数组，并初始化
    int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    
    // 定义一个指针 p，指向数组 arr 的第一个元素
    int *p = &arr[0];
    
    // 计算数组元素的个数
    int sz = sizeof(arr) / sizeof(arr[0]);
    
    // 使用指针遍历数组，直到 p 超过数组的有效范围
    while (p < arr + sz) // 比较指针 p 和数组的结束位置 arr + sz
    {
        // 输出当前指针 p 所指向的数组元素
        printf("%d ", *p);
        
        // 移动指针 p，指向下一个数组元素
        p++;
    }
    
    // 输出一个换行符以便于美观
    printf("\n");
    
    return 0;
}

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

#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif

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

    return 0;
}

assert(p != NULL);

这行代码的意思是在程序运行到这儿时，检查指针 p 是否为 NULL。如果 p 不为 NULL，程序会继续执行。如果 p 为 NULL，程序会报错并停止执行，同时打印错误信息，告诉你哪里出错了，在哪个文件和哪一行。

断言的工作原理：

• assert() 宏接受一个表达式作为参数。如果表达式为真（即非零），assert() 不做任何事情，程序继续执行。
• 如果表达式为假（即为零），assert() 会报错。错误信息会输出到标准错误流 stderr，并且显示出错误的表达式、文件名和行号。

使用 assert() 的好处：

• 自动定位错误：它不仅会输出错误信息，还会显示出错的文件和行号，方便你快速定位问题。
• 灵活启用或禁用：你可以轻松地控制是否使用断言。例如，在调试时开启断言，而在正式发布版本时禁用它，避免影响程序性能。

如何禁用 assert()：

如果你确定程序没有问题，不想让断言继续运行，可以通过定义一个宏 NDEBUG 来禁用断言：

#define NDEBUG

#include <assert.h>

这样，编译器就会忽略掉所有的 assert() 语句，程序继续正常运行。如果之后需要调试，发现问题，可以把 #define NDEBUG 注释掉，重新编译，断言功能就会重新启用。

assert() 的缺点：

• 增加运行时间：因为引入了额外的检查，assert() 会使程序的运行时间稍微增加。
• 调试阶段使用：一般情况下，我们在调试阶段使用 assert() 来帮助找出潜在的问题，而在发布版本中禁用它，以避免影响性能。在集成开发环境（IDE）如 Visual Studio 中，发布版本（Release）默认会优化掉这些断言。

size_t strlen ( const char * str );

int my_strlen(const char * str)
{
    int count = 0;
    assert(str);
    while(*str)
     {
         count++;
         str++;
     }
     return count;
}
int main()
{
    int len = my_strlen("abcdef");
    printf("%d\n", len);
    return 0;
}

#include <stdio.h>

void Swap1(int x, int y) {
    int tmp = x;
    x = y;
    y = tmp;
}

int main() {
    int a = 0, 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;
}

#include <stdio.h>

void Swap2(int* px, int* py) {
    int tmp = 0;
    tmp = *px;  // 解引用px，获取a的值
    *px = *py;  // 将b的值赋给a
    *py = tmp;  // 将a的原值赋给b
}

int main() {
    int a = 0, b = 0;
    scanf("%d %d", &a, &b);
    printf("交换前：a=%d b=%d\n", a, b);
    Swap2(&a, &b);  // 传递a和b的地址
    printf("交换后：a=%d b=%d\n", a, b);
    return 0;
}

#include <stdio.h>
int main()
{
     int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
     printf("&arr[0] = %p\n", &arr[0]);
     printf("arr = %p\n", arr);
     return 0;
}

sizeof(数组名)，sizeof中单独放数组名，这⾥的数组名表⽰整个数组，计算的是整个数组的⼤⼩， 单位是字节

&数组名，这⾥的数组名表⽰整个数组，取出的是整个数组的地址（整个数组的地址和数组⾸元素 的地址是有区别的）

除此之外，任何地⽅使⽤数组名，数组名都表⽰⾸元素的地址。

void test(int arr[])//参数写成数组形式，本质上还是指针
{

     printf("%d\n", sizeof(arr));
}
void test(int* arr)//参数写成指针形式
{
     printf("%d\n", sizeof(arr));//计算⼀个指针变量的⼤⼩
}
int main()
{
     int arr[10] = {1,2,3,4,5,6,7,8,9,10};
     test(arr);
     return 0;
}

int main() {
    char ch = 'w';
    char *pc = &ch;  // pc 存储了 ch 的地址
    *pc = 'w';  // 通过 pc 修改 ch 的值
    return 0;
}

int main() {
    const char* pstr = "hello bit.";  // pstr 存储的是字符串的首字符地址
    printf("%s\n", pstr);  // 输出 "hello bit."
    return 0;
}

int *p1[ 10 ];

int (*p2)[ 10 ];

int (*p) [ 10 ] = &arr;

|      |      |

|      |      |

|       |     p 指向数组的元素个数

|       p 是数组指针变量名

p 指向的数组的元素类型

#include <stdio.h>
void test()
{
    printf("hehe\n");
}
int main()
{
    printf("test: %p\n", test);
    printf("&test: %p\n", &test);
    return 0;
}

void test()
{
     printf("hehe\n");
}
void (*pf1)() = &test;
void (*pf2)()= test;
int Add(int x, int y)
{
     return x+y;
}
int(*pf3)(int, int) = Add;
int(*pf3)(int x, int y) = &Add;//x和y写上或者省略都是可以的

13.19.1 函数指针变量的使⽤

#include <stdio.h>

int Add(int x, int y) {
    return x + y;
}

int main() {
    int (*pf3)(int, int) = Add;
    
    printf("%d\n", (*pf3)(2, 3));  // 使用函数指针调用函数
    printf("%d\n", pf3(3, 5));     // 直接使用函数指针调用函数
    return 0;
}

#include <stdio.h>

int add(int a, int b) {
    return a + b;
}

int sub(int a, int b) {
    return a - b;
}

int mul(int a, int b) {
    return a * b;
}

int div(int a, int b) {
    return a / b;
}

int main() {
    int x, y, input, ret;
    int (*operations[4])(int, int) = {add, sub, mul, div};

    do {
        printf("*************************\n");
        printf(" 1:add 2:sub \n");
        printf(" 3:mul 4:div \n");
        printf(" 0:exit \n");
        printf("*************************\n");
        printf("请选择：");
        scanf("%d", &input);

        if (input > 0 && input < 5) {
            printf("输入操作数：");
            scanf("%d %d", &x, &y);
            ret = operations[input - 1](x, y);  // 调用相应的函数
            printf("ret = %d\n", ret);
        } else if (input == 0) {
            printf("退出程序\n");
        } else {
            printf("选择错误\n");
        }
    } while (input);
    
    return 0;
}

#include <stdio.h>

int add(int a, int b)
{
    return a + b;
}

int sub(int a, int b)
{
    return a - b;
}

int mul(int a, int b)
{
    return a * b;
}

int div(int a, int b)
{
    return a / b;
}

int main()
{
    int x, y;
    int input = 1;
    int ret = 0;

    do {
        printf("******************\n");
        printf(" 1:add \n");
        printf(" 2:sub \n");
        printf(" 3:mul \n");
        printf(" 4:div \n");
        printf("******************\n");
        printf("请选择：");
        scanf("%d", &input);

        switch (input) {
            case 1:
                printf("输入操作数：");
                scanf("%d %d", &x, &y);
                ret = add(x, y);
                printf("ret = %d\n", ret);
                break;
            case 2:
                printf("输入操作数：");
                scanf("%d %d", &x, &y);
                ret = sub(x, y);
                printf("ret = %d\n", ret);
                break;
            case 3:
                printf("输入操作数：");
                scanf("%d %d", &x, &y);
                ret = mul(x, y);
                printf("ret = %d\n", ret);
                break;
            case 4:
                printf("输入操作数：");
                scanf("%d %d", &x, &y);
                ret = div(x, y);
                printf("ret = %d\n", ret);
                break;
            case 0:
                printf("退出程序\n");
                break;
            default:
                printf("选择错误\n");
                break;
        }
    } while (input);

    return 0;
}