C 语言语法-优快云博客

本文链接：https://blog.youkuaiyun.com/IPAD2030/article/details/142873661

数组

内存结构图

计算数组长度

// 计算数组长度
int arr3[] = {1, 2, 3, 4};
int length = sizeof(arr3) / sizeof(int);
printf("%d\n", length); // 4

数组作为参数传递

#include <stdio.h>

void printArr(int arr[]) {
    printf("%zu\n", sizeof(arr)); // 8
}

int main() {
    int arr4[] = {1, 2, 3, 4, 5};
    printf("%zu\n", sizeof(arr4)); // 20
    
    printArr(arr4);

    return 0;
}

在 main() 函数中，arr4 是一个局部定义的数组，因此 sizeof(arr4) 返回的是整个数组的大小（即数组的总字节数）
在 printArr 函数中，当数组作为参数传递时，它会退化为一个指向数组首元素的指针。因此 sizeof(arr) 计算的是指针的大小，而不是数组的大小。指针的大小与指向的数据类型无关，而是取决于操作系统的位数和编译器。32 位 -> 4 字节；64 位 -> 8 字节

指针

基本语法

指针的数据类型要跟指向变量的类型保持一致
指针存储的是变量的首字节地址
指针占用的大小跟数据类型无关

作用

操作其他函数中的变量

int main() {
    int num1 = 1;
    int num2 = 2;
    printf("Before calling: %d, %d\n", num1, num2); // 1, 2
    swap(&num1, &num2);
    printf("After calling: %d, %d\n", num1, num2); // 2, 1

    return 0;
}

void swap(int* num1, int* num2) {
    int temp = *num1;
    *num1 = *num2;
    *num2 = temp;
}

函数结束后，变量随之销毁。

如果不想函数中的变量被回收销毁，可以在变量前加 static 关键字。

int main() {
    int* p = method(); // p 获取的是局部变量 a 的地址
    printf("%d\n", *p);

    return 0;
}

int* method() {
    static int a = 10; // static 变量在整个程序生命周期内存在
    return &a; // 返回局部变量的地址
}

使函数 “返回” 多个值

原理同操作其他函数中的变量，只不过这里是操作多个变量。从而达到间接 " 返回 " 多个值的效果。

这里的 " 返回 " 并不是指函数必须要使用 return

示例代码如下：

#include <stdio.h>

void calculate(int a, int b, int *sum, int *product) {
    *sum = a + b;
    *product = a * b;
}

int main() {
    int a = 5, b = 10;
    int sum, product;

    // 将 sum 和 product 的地址传递给 calculate 函数
    calculate(a, b, &sum, &product);

    printf("Sum:%d\n", sum); // 15
    printf("Product:%d\n", product); //50


    return 0;
}

sum 和 product 是在 main() 函数中定义的局部变量，它们的生命周期在 main() 函数的作用范围内有效。

当 calculate() 函数接收到它们的地址时，它只是修改这些变量指向的内存区域。不需要 static，因为局部变量 sum 和 product 在 main() 中的生命周期和作用范围已经足够满足需求。

函数的结果和计算状态分开

原理依旧同操作其他函数中的变量。

// 返回值表示计算的状态：0 -> 正常，1 -> 异常
int getRemainder(int divider, int divisor, int *res) {
    if (divisor == 0) {
        return 1;
    }
    *res = divider / divisor;
    return 0;
}


int main() {
    int d1 = 10, d2 = 2;
    int res;
    int status = getRemainder(d1, d2, &res);
    if (!status) {
        printf("Obtained remainder:%d\n", res);
    } else {
        printf("The divisor cannot be 0 !!!\n");
    }

    return 0;
}

指针运算

指针的数据类型决定了指针在进行指针运算（如 p++ 或 p + 1）时，指针应该跳过多少个字节。

例如，当对 int* 指针执行 p++ 操作时，指针会跳过 sizeof(int) 个字节（通常为 4 个字节）。而对于 char* 指针，p++ 会跳过 1 个字节。

#include <stdio.h>

int main() {
    /**
     * 指针运算：
     *     步长：指针每次加 1 或减 1 时，移动的内存字节数
     *     char: 1
     *     short: 2
     *     int: 4
     *     long: 4
     *     long long: 8
     *
     *     加法：指针往后移动了 n 步。 p + 1
     *     减法：指针往前移动了 n 步。 p - 1
     */
    int a = 10;
    int* p = &a;
    printf("%p\n", p);
    printf("%p\n", p + 1);
    printf("%p\n", p + 2);
    
    return 0;
}

指针运算有意义的操作：

指针与整数进行加减操作（指针偏移）
指针与指针进行减操作（指针差值运算）

前提条件：内存空间是连续的。

int main() {
    int arr[] = {33, 21, 12, 75, 64};

    int* p1 = &arr[0];
    printf("%d\n", *(p1 + 1)); // 21

    int* p3 = &arr[3];
    printf("%d\n", p3 - p1); // 3 -> 单位：元素。这里 1 元素 == 4 字节

    return 0;
}

野指针：指针指向的空间未分配
悬空指针：指针指向的空间已分配，但是被释放了

void 指针

特点：

void 指针可以接受任意类型变量的内存地址
没有类型的指针，也就没有步长的概念。
无法获取变量里面的数据，也不能进行加、减操作
可以通过强转更改 void 指针的类型

作用：增加函数的通用性

示例代码如下：

void printValue(void *p, char type) {
    if (type == 'i') {
        printf("Integer: %d\n", *(int *) p); // 把 void 指针强转为 int 指针
    } else if (type == 'f') {
        printf("Float: %.2f\n", *(float*) p);
    } else if (type == 'c') {
        printf("Character: %c", *(char*) p);
    }
}

int main() {
    int a = 5;
    float b = 4.5f;
    char c = 'A';

    printValue(&a, 'i');
    printValue(&b, 'f');
    printValue(&c, 'c');

    return 0;
}