聊聊 C 中没注意的一些特性

// 1. 数组名作为参数传递时会退化为指针
//在 C 语言中，当数组名作为函数参数传递时，它会退化为指向数组首元素的指针。这意味着函数内部接收的是一个指针，而不是整个数组。

#include <stdio.h>

void print_string(char s[]) {
    printf("%s\n", s);
}

int main() {
    char s[12] = "hello world";
    print_string(s); // 数组名 s 退化为指针
    return 0;
}

/*
2. 在 C 语言中，所有函数参数都是值传递的，包括指针。这意味着传递给函数的是指针的副本，而不是指针本身。
*/
#include <stdio.h>

void modify_pointer(char *s) {
    s++; // 修改指针的副本
    printf("Inside function: %s\n", s);
}

int main() {
    char s[12] = "hello world";
    modify_pointer(s); // 传递指针的副本
    printf("Outside function: %s\n", s);
    return 0;
}

/*
3. 在函数内部，s 是指针的副本，可以对其进行操作（如 s++）。这种操作只会影响函数内部的副本，不会影响外部的指针。
*/

#include <stdio.h>

void print_string(char *s) {
    while (*s != '\0') {
        printf("%c", *s);
        s++; // 合法，修改指针的副本
    }
    printf("\n");
}

int main() {
    char s[12] = "hello world";
    print_string(s);
    return 0;
}

/*
4.在函数外，数组名是一个指向数组首元素的常量指针，不能被修改。因此，s++ 或 ++s 在函数外是非法的
*/
#include <stdio.h>

int main() {
    char s[12] = "hello world";
    // s++; // 非法，数组名是常量指针
    // ++s; // 非法，数组名是常量指针
    char *p = s; // 合法，将数组名赋值给指针变量
    p++; // 合法，修改指针变量
    printf("%s\n", p);
    return 0;
}

/*
5. 如果需要在函数内部修改外部的指针，可以传递指针的指针。
*/
#include <stdio.h>

void modify_pointer(char ​**s) {
    (*s)++; // 修改外部的指针
}

int main() {
    char s[12] = "hello world";
    char *p = s;
    modify_pointer(&p); // 传递指针的指针
    printf("%s\n", p);
    return 0;
}

    struct test {
        int x;
    }y,z,g;

== 

    struct test {
        int x;
    };

    struct test y, z, g;

struct {
    int x;
    int y;
} point;

typedef struct test {
    int x;
} y;

struct test var1;  // 传统方式
y var2;            // 使用 typedef 别名


// 更简便的一种写法
typedef struct {
    int x;
    int y;
} Point;  // 直接使用 Point 代替 struct {...}

struct Example {
    int a : 5;   // 5 位宽，最多能存储 32 的整数
    int b : 3;   // 3 位宽，最多能存储 8 的整数
    int c : 10;  // 10 位宽，最多能存储 1024 的整数
};



//在这个结构体中，a、b 和 c 只占用 1 位，但它们是 unsigned int 类型的位字段。为了满足对齐要求，编译器会为它们分配 4 字节内存，并插入填充字节。
struct Example {
    unsigned int a : 1;   // 1 位
    unsigned int b : 1;   // 1 位
    unsigned int c : 1;   // 1 位
};


// 哪还有什么意义 ？

位字段的意义不在于节省内存，而是在于：

提供精确的控制，特别是用于表示硬件寄存器的标志位；
压缩数据，使得多个小范围的值能够合并在一个数据单元中；
映射固定格式的二进制数据，如网络协议；
提升代码可读性，使得复杂的数据结构更加简洁明了。

// 1. 初始化静态或全局变量时不能调用函数

// 2. 对于静态变量，可以通过在单独的语句中使用 malloc 分配内存来解决问题。这是因为静态变量的生命周期是程序运行期间，可以在函数中对其进行赋值。
static int *pi;          // 声明静态变量
pi = malloc(sizeof(int)); // 在函数中分配内存

// 3. 全局变量与静态变量不同，它们是在函数外部声明的，因此不能直接在全局作用域中使用赋值语句（如 pi = malloc(sizeof(int));）。赋值语句必须出现在函数中。

// 3.1 全局变量可以在声明时进行初始化，但不能使用赋值语句。这是因为赋值语句是执行时的操作，而全局变量的初始化必须在编译时完成。
int global_var = 42; // 正确：声明时初始化
---
int global_var;
global_var = 42; // 错误：不能在全局作用域中使用赋值语句

// 3.2 动态内存分配（如 malloc）是运行时的操作，因此不能在全局作用域中直接调用。
int *pi = malloc(sizeof(int)); // 错误：不能在全局作用域中调用函数
-----
int *pi;
pi = malloc(sizeof(int));      // 错误：不能在全局作用域中使用赋值语句

// 3.3 正确方法 ， 在函数中动态分配
int *pi; // 声明全局变量

void init_global() {
    pi = malloc(sizeof(int)); // 在函数中分配内存
}

// 3.4 静态变量（包括全局静态变量和函数内部的静态变量）的初始化规则与全局变量类似。
static int static_global_var = 42; // 正确：声明时初始化
-----
void func() {
    static int static_local_var = 42; // 正确：声明时初始化
}
------
static int static_global_var;
static_global_var = 42; // 错误：不能在全局作用域中使用赋值语句