C语言学习笔记

gcc --version
g++ --version
gdb --version

numbers      → 等价于 &numbers[0]

#include <stdio.h>

int main() {
    int n = 123;
    float f = 3.14;
    
    printf("|%5d|\n", n);     // 宽度5，右对齐：|  123|
    printf("|%-5d|\n", n);    // 宽度5，左对齐：|123  |
    printf("|%8.2f|\n", f);   // 宽度8，2位小数：|    3.14|
    printf("|%-8.2f|\n", f);  // 宽度8，左对齐：|3.14    |
    
    return 0;
}

#include <stdio.h>
int main() {
    int width = 10;
    int precision = 3;
    float value = 3.14159;
    
    // 使用 * 指定动态宽度和精度
    printf("|%*.*f|\n", width, precision, value);  // |     3.142|
    
    // 也可以只动态指定一个
    printf("|%*.2f|\n", width, value);  // |      3.14|
    printf("|%10.*f|\n", precision, value);  // |     3.142|
    
    return 0;
}

int a =10;
int b = 4;
float c = a/b;  // c = 2.00000

#include <stdio.h>

int main()
{
    int a;
    char b;

    scanf("%d", &a);
    scanf("%c", &b);

    printf("%d -", a);
    printf("%c -", b);
}

// 输入
2
// 输出
2 -
 -

#include <stdio.h>

int main()
{
    char str[] = "ABCDEFG";

    // 取出1:3的字符BCD
    str[4] = '\0';                 // 直接在索引4处截断
    printf("结果: %s\n", str + 1); // 从索引1开始输出
    return 0;
}
// BCD

#include <stdio.h>

int main() {
    char c = '5';
    int digit = c - '0';  // '5' - '0' = 53 - 48 = 5
    
    printf("字符 '%c' 转换为整数值: %d\n", c, digit);
    // 输出：字符 '5' 转换为整数值: 5
    
    return 0;
}

#define BUFFER_SIZE 256      // 缓冲区大小

// 使用
uint8_t buffer[BUFFER_SIZE];

#define MAX(a, b) ((a) > (b) ? (a) : (b))

int main() {
    int x = MAX(3+1, 5*2); 
    // 预处理后：((3+1) > (5*2) ? (3+1) : (5*2))
    return 0;
}

#define func(x) x*x
int res = func(3+1); 
// 替换后：3+1*3+1 = 3+3+1=7（错误，预期是16）

//正确写法：#define func(x) ((x)*(x))

#define MAX (a,b)  // 错误！变成普通宏，不是函数宏
#define MAX(a,b)   // 正确

#include <stdio.h>
// 调试等级
#define DEBUG_LEVEL_INFO   3
#define DEBUG_LEVEL_WARN   2
#define DEBUG_LEVEL_ERROR  1
#define CURRENT_DEBUG_LEVEL DEBUG_LEVEL_INFO

#define DEBUG_PRINT(level, fmt, ...) do { \
    if (level <= CURRENT_DEBUG_LEVEL) { \
        printf("[%s] " fmt "\r\n", __FUNCTION__, ##__VA_ARGS__); \
    } \
} while(0)

// __FUNCTION__  C/C++编译器的预定义标识符，表示当前函数的名称
// __VA_ARGS__ 表示可变参数列表，## 是预处理连接符的特殊用法
// 使用
int main() {
    int adc_value = 5;
    int bus_id = 6;
    DEBUG_PRINT(DEBUG_LEVEL_INFO, "ADC value: %d", adc_value);
    DEBUG_PRINT(DEBUG_LEVEL_ERROR, "I2C timeout on bus %d", bus_id);

}

#include <stdio.h>

int main()
{
    const int a = 10;   
    const int *p  = &a;   // 指向常量的指针
    int b = 20;
    p = &b;   // 指针可以改变 *p = 20
    // *p = 20;   // 指针指向的值不能改
}


int main()
{
    int a = 10;
    int * const p = &a;   
    *p = 20;   // 
    // int b = 30;
    // p = &b;   // 指针不能改变
}

int x = 0;
while (x == 0) {
    // do something
}

#include <stdio.h>
#include <stdbool.h>

volatile int flag = 0;

void set_flag() {
    flag = 1;  // 外部函数修改 flag
}

int main() {
    while(flag == 0) {
        pass
    }
    printf("Flag is set!\n");
    return 0;
}

// 方法1：先定义类型，后定义变量
enum uart_baudrate {
    BAUD_9600  = 9600,
    BAUD_19200 = 19200,
    BAUD_115200 = 115200
};
enum uart_baudrate uart_speed;

// 方法2：定义类型同时定义变量
enum i2c_speed {
    I2C_STANDARD = 100000,
    I2C_FAST     = 400000,
    I2C_HIGH     = 3400000
} i2c_bus_speed;

// 方法3：匿名枚举（常用）
enum {
    LED_OFF = 0,
    LED_ON  = 1
} led_state;

typedef enum {
    SYS_INIT,
    SYS_RUN,
    SYS_LOW_POWER,
    SYS_FAULT
} SysState;

SysState system_state;

void state_machine(void)
{
    switch(system_state) {
        case SYS_INIT:
            // 初始化硬件
            break;
        case SYS_RUN:
            // 正常运行
            break;
        case SYS_LOW_POWER:
            // 进入低功耗
            break;
        case SYS_FAULT:
            // 故障处理
            break;
    }
}

#include <stdio.h>
#include <stdlib.h>
int main(){
    int *arr = malloc(5 * sizeof(int));
    for (int i = 0; i<5; i++){
        arr[i] = i * i;
    }
    for (int i = 0; i<5; i++){
        printf("%d ", arr[i]);
    }
    free(arr);
}
// 0 1 4 9 16 

#include <stdio.h>
int main(){
    int arr[5] = {1, 2, 3, 4, 5};
    int *ptr = arr;

    //大小不同
    printf("sizeof(arr) = %zu bytes\n", sizeof(arr));
    printf("sizeof(*ptr) = %zu bytes\n", sizeof(*ptr));

    //地址不同
    printf("&arr = %p\n", (void*)&arr);
    printf("&ptr = %p\n", (void*)&ptr); // 这是ptr变量自己的地址

    //赋值行为不同
    int var = 10;
    ptr = &var;
    printf("*ptr = %d\n", *ptr); // ptr可以指向别处
    // arr = &var; //错误，arr 不能指向别处
}

// sizeof(arr) = 20 bytes
// sizeof(*ptr) = 4 bytes
// &arr = 00000000005FFE60
// &ptr = 00000000005FFE58
// *ptr = 10

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *p = malloc(sizeof(int) * 5);  // 动态分配20字节内存
    p = NULL;  // 丢失了原来的指针

    // 原来那块内存还在内存中，但我们再也访问不到了
    // 没有free，也不会有错误提示
    return 0;
}

// ❌ 有泄漏
#include <stdlib.h>

void test() {
    int *arr = malloc(10 * sizeof(int));
    // 使用完后直接返回
    return;
}

// ✅ 正确释放
#include <stdlib.h>

void test() {
    int *arr = malloc(10 * sizeof(int));
    // 使用arr...
    free(arr);   // 释放内存
    arr = NULL;  // 避免野指针
}

#include <stdio.h>
#include <stdlib.h>
int main(){
    int *arr = malloc(5 * sizeof(int));
    for (int i = 0; i<10; i++){
        arr[i] = i * i; 
    }
    for (int i = 0; i<10; i++){
        printf("%d ", arr[i]);
    }
    free(arr);
}
//0 1 4 9 16 25 36 49 64 81 

#include <stdio.h>
#include <stdlib.h>
int main(){ 
    int *arr  = calloc(5, sizeof(int));//分配5个int大小的内存，并初始化为0
    for (int i  = 0;i<5;i++){
        printf("%d ", arr[i]);
    }
    free(arr);
    return 0;
}
// 输出：0 0 0 0 0

#include <stdio.h>
#include <stdlib.h>
int main(){
    int *arr = malloc(3 * sizeof(int));
    for (int i = 0; i<3; i++)
        arr[i] = i * i; // 初始化为 0 1 4
    
    // 重新分配内存为5个int
    arr = realloc(arr, 5 * sizeof(int));
    arr[3] = 10;
    arr[4] = 20;
    for (int i = 0; i < 5; i++)
        printf("%d ", arr[i]); // 输出：0 1 4 10 20
    free(arr);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
int main(){
    int *p1 = NULL;      // 最常用的方式
    int *p2 = 0;         // 直接赋值为0
    int *p3 = (void *)0; // 显式类型转换

    printf("p1 = %p\n", (void *)p1);
    printf("p2 = %p\n", (void *)p2);
    printf("p3 = %p\n", (void *)p3);
}
// p1 = 0000000000000000 
// p2 = 0000000000000000 
// p3 = 0000000000000000

#include <stdio.h>
#include <stdlib.h>

int main()
{
    // ❌ 危险：未初始化的指针（野指针）
    // int *dangerous_ptr;

    // ✅ 安全：初始化为空指针
    int *safe_ptr = NULL;

    // 检查后再使用
    if (safe_ptr == NULL)
    {
        safe_ptr = (int *)malloc(sizeof(int));
        *safe_ptr = 100;
    }

    free(safe_ptr);
    safe_ptr = NULL; // 释放后重新置空

    return 0;
}

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int *ptr = (int*)malloc(100 * sizeof(int));

    if (ptr == NULL)
    {
        printf("Memory allocation failed.\n");
        return 1;
    }
    printf("Memory allocated successfully.\n");
    // ...
    free(ptr);
    ptr = NULL;

}

int *p = NULL;
// *p = 10;  // 错误！

// 返回了局部变量的地址，而栈是自动回收的，导致local这个局部变量的指针变成了野指针
int *create_dangling_pointer()
{
    int local = 42;
    return &local; // 返回后local的内存被回收，指针悬空
}

int *create_valid_pointer() {
    int *dynamic = (int*)malloc(sizeof(int));
    *dynamic = 42;
    return dynamic; // 调用者需要负责释放

void shared_memory_danger()
{
    int *ptr1 = (int *)malloc(sizeof(int));
    int *ptr2 = ptr1; // 两个指针指向同一内存

    *ptr1 = 100;
    free(ptr1);  // 释放内存
    ptr1 = NULL; // ptr1安全了, 但ptr2现在变成了野指针！
    // printf("%d\n", *ptr2); // 未定义行为
}

#include <stdio.h>

int main()
{
    int int_value = 42;
    float float_value = 3.14f;
    char char_value = 'A';
    char str[] = "Hello";

    void *void_ptr; // 声明void指针
    void_ptr = &int_value; // 指向整型
    // printf("void_ptr = %d\n", *void_ptr); // 错误！不能直接解引用void指针
    printf("void_ptr = %d\n", *(int *)void_ptr); // 正确：需要类型转换

    void_ptr = &float_value;             // 指向浮点型
    void_ptr = &char_value; // 指向字符型
    void_ptr = str; // 指向数组
    return 0;
}

#include <stdio.h>
int main()
{
    int arr[3] = {10, 20, 30};
    void *void_ptr = arr;

    // void_ptr++;  // 错误！void指针不能进行算术运算

    // 正确：转换为具体类型后再运算
    int *int_ptr = (int *)void_ptr;
    int_ptr++;
    printf("%d\n", *int_ptr); // 输出: 20

    return 0;
}

#include <pthread.h>
#include <stdio.h>

void *worker(void *arg) {
    int *num = (int *)arg;   // 将 void* 强转回原类型
    printf("Thread received: %d\n", *num);
    return NULL;
}

int main() {
    pthread_t tid;
    int value = 42;

    pthread_create(&tid, NULL, worker, &value);  // 传入任意类型指针
    pthread_join(tid, NULL);

    return 0;
}

int main()
{
    int value = 10;         // 普通整型变量
    int *ptr1 = &value;     // 指针，指向整型变量
    int **ptr2 = &ptr1;     // 指向指针的指针，指向指针ptr1
    printf("value值为：%d\n", value);
    printf("value内存地址为：%p\n", ptr1);
    printf("ptr1地址为：%p\n", ptr2);
    printf("ptr2存储的值为%p", *ptr2);
}
// value值为：10
// value内存地址为：00000000005FFE74
// ptr1地址为：00000000005FFE68
// ptr2存储的值为00000000005FFE74

#include <stdlib.h>
int main(){
    int rows = 3, cols = 4;

    // 创建二维动态数组
    int **array = (int **)malloc(rows * sizeof(int *));
    for(int i = 0; i < rows; i++){
        array[i] = (int *)malloc(cols * sizeof(int));
    }

    // 使用数组
    array[1][2] = 99; // 

    // 释放内存
    for(int i=0; i < rows; i++){
        free(array[i]);
    }
    free(array);
}

[ array 指向 ]
+------+------+------+   <- 存放 3 个 int*（每个元素是一个指针，指向每行的首地址）
| p0   | p1   | p2   |
+------+------+------+

array -> [ p0 | p1 | p2 ]
           |    |    |
           v    v    v
         [4 ints][4 ints][4 ints]

#include <stdlib.h>
void changePointer(int **pp)
{
    static int newValue = 100;
    *pp = &newValue; // 修改指针指向的内容
}

int main()
{
    int num = 50;
    int *ptr = &num;

    printf("修改前: %d\n", *ptr); // 50
    changePointer(&ptr);          // 传递指针的地址
    printf("修改后: %d\n", *ptr); // 100
    return 0;
}

#include <stdio.h>

// 这个函数承诺不会修改传入的数组
void printArray(const int *arr, int size)
{
    for (int i = 0; i < size; i++)
    {
        printf("%d ", arr[i]);
        // arr[i] = 0;  // ❌ 编译错误！安全保护
    }
    printf("\n");
}
int main()
{
    int numbers[] = {1, 2, 3, 4, 5};
    printArray(numbers, 5);
    return 0;
}

// 只读的硬件寄存器
const volatile int *readonly_register = (const int*)0x1000;

int readHardwareValue() {
    return *readonly_register;  // 只能读取，不能写入
    // *readonly_register = 1;  // ❌ 硬件保护
}

// 例如，在嵌入式系统中，指向一个固定的、只读的硬件寄存器或ROM中的配置数据
const ConfigTable *const system_config = &default_config;

// 函数内部使用全局静态对象时，避免指针被误改
static int buffer[128];
int * const p = buffer;   // p 永远指向这个 buffer

// 假设寄存器布局如下：
typedef struct {
    volatile uint32_t MODER;   // 模式寄存器
    volatile uint32_t ODR;     // 输出数据
    volatile uint32_t BSRR;    // 置位/复位
} GPIO_Regs;

// 指针不能修改 → 防止破坏寄存器映射
// 指向的内容（寄存器）可以读写 → 正常访问硬件

// 此时用 指向固定地址的指针常量 映射：
#define GPIOA_BASE 0x40021000UL
GPIO_Regs * const GPIOA = (GPIO_Regs *)GPIOA_BASE;

// 这样一来，GPIOA = xxx 会报错；但 GPIOA->MODER = ... 可正常修改寄存器内容

// 例如，系统全局配置表，既不能修改表内容，也不能让指针指向其他表
const ConfigTable * const system_config = &default_config;

// 下面的操作都是非法的：
// system_config = &backup_config;   // 错误：指针本身是常量
// system_config->baudrate = 9600;    // 错误：指向的内容是常量

// 处理固定列数的二维数组（矩阵）
void process_matrix(int rows, int (*matrix)[4]) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < 4; j++) {
            matrix[i][j] *= 2;   // 像普通二维数组一样使用
        }
    }
}

// 调用示例
int grid[3][4] = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};
process_matrix(3, grid);  // 数组名自动退化为指向首行的指针；grid数组最终所有元素乘2

int main()  
{
    // 利用数组指针的步长特性，快速跳转到指定行
    int scores[4][3] = {
        {90, 85, 88},
        {78, 92, 86},
        {95, 89, 91},
        {82, 88, 84}};

    int (*row)[3] = scores;    // 指向第0行
    row++;                     // 跳转到第1行（步长 = 12字节，3个int）
    printf("%d\n", (*row)[1]); // 输出第1行第2列：92

    row += 2;                  // 跳转到第3行
    printf("%d\n", (*row)[0]); // 输出第3行第1列：82
}

// 利用函数指针决定做什么运算
int calculate(int a, int b, int (*op)(int, int))
{
    return op(a, b);
}

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

int sub(int x, int y)
{
    return x - y;
}
int main()
{
    printf("%d\n", calculate(10, 5, add)); // 函数名自动转换为函数指针,等价于&add
    printf("%d\n", calculate(10, 5, sub));  
    return 0;
}
// 15
// 5

// 中断向量表的本质：一个函数指针数组
void (*isr[3])(void);  // 3个中断的处理函数

// 中断0的处理函数
void handler_for_irq0(void) {
    printf("中断0发生了\n");
}

// 中断1的处理函数
void handler_for_irq1(void) {
    printf("中断1发生了\n");
}

int main() {
    // 注册：告诉系统，当中断0发生时，调用handler_for_irq0
    isr[0] = handler_for_irq0;
    isr[1] = handler_for_irq1;
    
    // 模拟硬件：当中断0发生时
    isr[0]();  // 自动调用 handler_for_irq0
    // 输出：中断0发生了
}

// 定义GPIO寄存器的结构体（映射到真实硬件地址）
typedef struct {
    volatile unsigned int MODER;    // 模式寄存器
    volatile unsigned int ODR;      // 输出数据寄存器
    volatile unsigned int IDR;      // 输入数据寄存器
} GPIO_TypeDef;

// 定义指针指向真实的硬件地址（比如0x40020000）
#define GPIOA_BASE  0x40020000
GPIO_TypeDef *GPIOA = (GPIO_TypeDef *)GPIOA_BASE;

// 通过结构体指针操作寄存器
int main() {
    GPIOA->MODER = 0x01;    // 设置GPIO为输出模式
    GPIOA->ODR = 0x01;      // 输出高电平
    
    unsigned int value = GPIOA->IDR;  // 读取输入值
}

//如使用STM32单片机
#include "stm32f1xx_hal.h"  // STM32的库
extern UART_HandleTypeDef huart2;  // 串口2的句柄

// 指向字符串常量的指针（字符串存在ROM/Flash中，不可修改）
const char *welcome_msg = "System Ready\r\n";
const char *error_msg = "Error: Sensor failed\r\n";

// 串口发送函数
void uart_send_byte(uint8_t data) {
    HAL_UART_Transmit(&huart2, &data, 1, 100);  // 发送1个字节
}

// 发送字符串
void uart_send_string(const char *str) {
    while (*str != '\0') {
        uart_send_byte(*str);  // 发送字符
        str++;
    }
}

const char *welcome_msg = "System Ready\r\n";

int main() {
    uart_send_string(welcome_msg);  // 输出：System Ready
    uart_send_string(error_msg);      // 输出：Error: Sensor failed
}

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main() {
	FILE* fp;
	char buffer[100];

	// 打开文件
	fp = fopen("config.txt", "r");
	if (fp != NULL) {
		fgets(buffer, 100, fp);
		printf("%s\n", buffer);

		fclose(fp);

		return 0;
	}
}

#include <stdio.h>

void write_log(const char *message) {
    FILE *fp = fopen("log.txt", "a");  
    
    if (fp != NULL) {
        fprintf(fp, "%s\n", message);  // 写入内容
        fclose(fp);
    }
}

int main() {
    write_log("系统启动");
    write_log("温度：25°C");
    write_log("系统关闭");
    return 0;
}