1
内存模型:
2
  地址       内容
3
  0x1000 ┌────────┐
4
         │  42    │  ← int a = 42;
5
  0x1004 ├────────┤
6
         │ 0x1000 │  ← int *p = &a;  (p存的是a的地址)
7
  0x1008 ├────────┤
8
         │ 0x1004 │  ← int **pp = &p; (pp存的是p的地址)
9
         └────────┘
10

11
指针运算:
12
  int arr[5] = {10,20,30,40,50};
13
  int *p = arr;     // p → arr[0]
14
  *(p + 2) = 30;    // p+2 → 跳过2个int(8字节) → arr[2]
15
  p++;              // p 移动 sizeof(int) = 4 字节
10 collapsed lines
16

17
指针 vs 数组:
18
  ┌──────────┬──────────────────────┬─────────────────────────┐
19
  │          │ 数组 int a[5]        │ 指针 int *p             │
20
  ├──────────┼──────────────────────┼─────────────────────────┤
21
  │ sizeof   │ 20 (5×4)            │ 4/8 (机器字长)          │
22
  │ &取地址  │ &a = 整个数组地址    │ &p = 指针变量的地址     │
23
  │ 修改     │ a不可赋值(常量地址) │ p可以重新指向           │
24
  │ 初始化   │ 栈上分配固定大小    │ 可指向任意合法地址      │
25
  └──────────┴──────────────────────┴─────────────────────────┘

1
#include <stdint.h>
2
uint8_t  a;  // 确保 8 位无符号
3
int16_t  b;  // 确保 16 位有符号
4
uint32_t c;  // 确保 32 位无符号

1
unsigned int a = 1;
2
int b = -1;
3
if (a > b) {
4
    printf("a > b\n");  // 你可能以为会走这里
5
} else {
6
    printf("a <= b\n"); // 实际走这里！
7
}
8
// 原因：b 被隐式转换为 unsigned int
9
// -1 的补码 = 0xFFFFFFFF = 4294967295 (unsigned)
10
// 所以 1 < 4294967295，结果是 a <= b

1
char a = 0xFF;    // signed char = -1
2
unsigned char b = 0xFF;  // unsigned char = 255
3

4
printf("%d\n", a);   // -1 (符号扩展)
5
printf("%d\n", b);   // 255 (零扩展)
6

7
// 整型提升例子
8
char c = 127;
9
char d = c + 1;  // c 提升为 int, 127+1=128, 截断回 char = -128 (溢出)

1
int a = 10;
2
printf("%zu\n", sizeof(a));      // 4
3
printf("%zu\n", sizeof(int));    // 4
4
printf("%zu\n", sizeof(char));   // 1
5

6
// 数组与指针的区别
7
int arr[10];
8
printf("%zu\n", sizeof(arr));    // 40 (整个数组)
9
printf("%zu\n", sizeof(arr[0])); // 4 (一个元素)
10
printf("%zu\n", sizeof(arr)/sizeof(arr[0])); // 10 (元素个数)
11

12
// 数组退化为指针后
13
void func(int arr[]) {
14
    printf("%zu\n", sizeof(arr)); // 4 或 8 (指针大小！不是数组大小)
15
}

1
int x = 5;
2
printf("%zu\n", sizeof(x++)); // 输出 4，x 仍然是 5

1
volatile uint32_t *reg = (volatile uint32_t *)0x40021000;
2
// 每次读取都从硬件寄存器取值，不会被编译器缓存到寄存器中
3
uint32_t val = *reg;

1
// 中断中修改的变量
2
volatile int flag = 0;
3

4
void ISR_Handler(void) {  // 中断服务程序
5
    flag = 1;
6
}
7

8
int main(void) {
9
    while (!flag) {
10
        // 没有 volatile，编译器可能优化为死循环
11
        // 因为它认为 flag 在循环里不会变
12
    }
13
    // 有 volatile，每次都重新读取 flag 的值
14
}

1
// 1. 常量变量（只读）
2
const int MAX = 100;   // 不可修改
3

4
// 2. 指针与 const 的组合（高频考点！）
5
const int *p1;         // 指向const int的指针，*p1不可改，p1可改
6
int const *p2;         // 同上
7
int *const p3 = &a;    // const指针，p3不可改，*p3可改
8
const int *const p4 = &a; // 都不可改
9

10
// 记忆技巧：const 在 * 左边 → 值不可改；const 在 * 右边 → 指针不可改
11

12
// 3. 函数参数保护
13
void send_data(const uint8_t *buf, int len) {
14
    // buf 指向的数据不可修改，防止意外篡改
15
    buf[0] = 0;  // 编译报错！
6 collapsed lines
16
}
17

18
// 4. 返回值 const
19
const char* get_name(void) {
20
    return "hello";  // 返回字符串常量
21
}

1
// 1. 静态局部变量 — 生命周期延长到程序结束
2
void counter(void) {
3
    static int count = 0;  // 只初始化一次
4
    count++;
5
    printf("count = %d\n", count);
6
}
7
// 第1次调用: count=1, 第2次: count=2, 第3次: count=3...
8

9
// 2. 静态全局变量 — 限制作用域为本文件
10
static int internal_var = 10;  // 其他 .c 文件看不到
11

12
// 3. 静态函数 — 限制作用域为本文件
13
static void helper(void) {
14
    // 只能在本文件内调用
15
}

1
// 1. 给类型起别名
2
typedef unsigned char uint8_t;
3
typedef unsigned int  uint32_t;
4

5
// 2. 简化结构体声明
6
typedef struct {
7
    int x, y;
8
} Point;
9
Point p = {1, 2};  // 不用写 struct Point
10

11
// 3. 函数指针类型
12
typedef void (*callback_t)(int);
13
callback_t my_func;
14

15
// 4. 嵌入式中常用：寄存器类型定义
2 collapsed lines
16
typedef volatile uint32_t reg32_t;
17
#define GPIOA_ODR  (*(reg32_t *)0x40020014)

1
#define PTR_INT int*
2
typedef int* ptr_int;
3

4
PTR_INT a, b;     // 等效于 int* a, b; → a是指针，b是int！
5
ptr_int c, d;     // c和d都是int*

1
// 枚举定义
2
typedef enum {
3
    LED_OFF = 0,
4
    LED_ON  = 1,
5
    LED_BLINK = 2
6
} led_state_t;
7

8
led_state_t state = LED_ON;
9

10
// 相比 #define 的优势：
11
// 1. 有类型检查
12
// 2. 调试时能看到符号名
13
// 3. 多个常量自动递增
14
// 4. 限定了取值范围
15

6 collapsed lines
16
typedef enum {
17
    SPI_MODE0,  // 0
18
    SPI_MODE1,  // 1
19
    SPI_MODE2,  // 2
20
    SPI_MODE3   // 3
21
} spi_mode_t;

1
int g = 10;           // 外部链接, .data段
2
static int s = 20;    // 内部链接, 仅本文件可见
3

4
void func(void) {
5
    int a = 1;            // auto, 栈上, 每次调用重新初始化
6
    static int cnt = 0;   // static局部, 只初始化一次
7
    cnt++;                 // 函数退出后cnt值保留
8
    register int i;        // 建议放寄存器(编译器可忽略)
9
}

1
int a = 10;    // a 是左值，10 是右值
2
int *p = &a;   // &a 合法（a 是左值）
3
// &10;        // 错误！10 是右值，不能取地址
4
// a + 1 = 5;  // 错误！a+1 是右值

1
register int i;
2
for (i = 0; i < 1000000; i++) {
3
    // 频繁访问的循环变量，放寄存器可加速
4
}
5
// &i;  // 错误！register 变量不能取地址

1
struct Example {
2
    char  a;    // 1字节 + 3字节填充
3
    int   b;    // 4字节
4
    char  c;    // 1字节 + 3字节填充
5
};
6
// sizeof = 12（不是 6！）
7

8
// 优化排列：
9
struct Optimized {
10
    int   b;    // 4字节
11
    char  a;    // 1字节
12
    char  c;    // 1字节 + 2字节填充
13
};
14
// sizeof = 8
15

9 collapsed lines
16
// 强制1字节对齐（嵌入式常用于协议解析）
17
#pragma pack(1)
18
struct Packed {
19
    char  a;    // 1字节
20
    int   b;    // 4字节
21
    char  c;    // 1字节
22
};
23
// sizeof = 6
24
#pragma pack()

1
// struct: 所有成员各占独立内存
2
struct S { int a; char b; float c; };  // sizeof = 12
3

4
// union: 所有成员共用一块内存，大小=最大成员
5
union U { int a; char b; float c; };   // sizeof = 4
6

7
// 经典应用：判断大小端
8
union {
9
    uint32_t word;
10
    uint8_t  bytes[4];
11
} test;
12
test.word = 0x01020304;
13
if (test.bytes[0] == 0x04)
14
    printf("小端 (Little Endian)\n");  // x86, ARM 默认
15
else
1 collapsed line
16
    printf("大端 (Big Endian)\n");     // 网络字节序

1
// 网络字节序转换
2
uint32_t htonl(uint32_t hostlong);   // 主机→网络
3
uint32_t ntohl(uint32_t netlong);    // 网络→主机

1
// 通用大小端转换宏(适用于协议解析)
2
#define SWAP16(x) ((((x)&0xFF)<<8) | (((x)>>8)&0xFF))
3
#define SWAP32(x) ((SWAP16((x)&0xFFFF)<<16) | SWAP16(((x)>>16)&0xFFFF))
4

5
// 网络协议收到大端数据,本机小端时:
6
uint16_t value = SWAP16(*(uint16_t*)&recv_buf[offset]);

1
// 位域常用于嵌入式寄存器映射
2
typedef struct {
3
    uint32_t enable    : 1;  // 1 位
4
    uint32_t mode      : 2;  // 2 位
5
    uint32_t speed     : 3;  // 3 位
6
    uint32_t reserved  : 26; // 26 位
7
} GPIO_Config_t;
8

9
GPIO_Config_t cfg;
10
cfg.enable = 1;
11
cfg.mode = 2;
12
cfg.speed = 5;

1
void fast_copy(int *restrict dst, const int *restrict src, int n) {
2
    for (int i = 0; i < n; i++)
3
        dst[i] = src[i];
4
    // 编译器知道 dst 和 src 不重叠，可以做更激进的优化
5
}

1
int a = 42;
2
int *p = &a;  // p 存储 a 的地址
3

4
// 在 32 位系统中，任何指针都是 4 字节
5
// 在 64 位系统中，任何指针都是 8 字节
6

7
printf("a 的值: %d\n", a);       // 42
8
printf("a 的地址: %p\n", &a);    // 0x7ffd1234
9
printf("p 的值: %p\n", p);       // 0x7ffd1234（和 &a 相同）
10
printf("p 指向的值: %d\n", *p);  // 42（解引用）

1
int arr[5] = {10, 20, 30, 40, 50};
2
int *p = arr;  // 数组名 = 首元素地址
3

4
// 等价的访问方式：
5
arr[2]    ↔ *(arr + 2) ↔ *(p + 2) ↔ p[2]  // 都是 30
6

7
// 但数组名 ≠ 指针！
8
sizeof(arr)  // 20（整个数组大小）
9
sizeof(p)    // 4 或 8（指针大小）
10

11
// 数组名不可赋值
12
arr = p;     // 错误！数组名是常量
13
p = arr;     // OK

1
int arr[5] = {10, 20, 30, 40, 50};
2
int *p = arr;
3

4
p + 1;   // 地址 + 1×sizeof(int) = 地址 + 4
5
p + 3;   // 地址 + 3×sizeof(int) = 地址 + 12
6

7
// 不同类型指针步长不同
8
char *cp = (char *)arr;
9
cp + 1;  // 地址 + 1×sizeof(char) = 地址 + 1
10

11
// 两个指针相减 = 元素个数
12
int *p1 = &arr[1], *p2 = &arr[4];
13
printf("%ld\n", p2 - p1);  // 3（不是 12）

1
int *p1[5];    // 指针数组: 5 个 int* 指针组成的数组
2
int (*p2)[5];  // 数组指针: 指向 int[5] 数组的指针
3

4
// 记忆法: [] 优先级高于 *
5
// p1[5] 先结合 → p1 是数组，元素是 int*
6
// (*p2) 先结合 → p2 是指针，指向 int[5]
7

8
// 指针数组的应用：
9
const char *names[] = {"Alice", "Bob", "Charlie"};
10

11
// 数组指针的应用：
12
int matrix[3][4];
13
int (*row_ptr)[4] = matrix;  // 指向一行（4个int）
14
row_ptr++;  // 跳过一整行

1
// 定义函数指针
2
int add(int a, int b) { return a + b; }
3
int sub(int a, int b) { return a - b; }
4

5
// 声明函数指针变量
6
int (*func_ptr)(int, int);
7
func_ptr = add;
8
printf("%d\n", func_ptr(3, 4));  // 7
9
func_ptr = sub;
10
printf("%d\n", func_ptr(3, 4));  // -1
11

12
// 嵌入式经典应用：回调函数
13
typedef void (*irq_handler_t)(void);
14
irq_handler_t handlers[16];  // 中断向量表
15

8 collapsed lines
16
void timer_isr(void) { /* ... */ }
17
handlers[0] = timer_isr;
18
handlers[0]();  // 调用中断处理函数
19

20
// 函数指针数组（状态机实现）
21
typedef void (*state_func_t)(void);
22
state_func_t state_table[] = {state_idle, state_run, state_stop};
23
state_table[current_state]();  // 根据状态调用对应函数

1
void *p;  // 通用指针，可以指向任何类型
2

3
int a = 10;
4
float b = 3.14;
5
void *vp;
6

7
vp = &a;  // OK
8
vp = &b;  // OK
9

10
// 使用时必须强制转换
11
printf("%d\n", *(int *)vp);    // 需要转回具体类型
12
printf("%f\n", *(float *)vp);
13

14
// 不能直接解引用
15
// *vp;      // 错误！编译器不知道大小
8 collapsed lines
16
// vp + 1;   // 标准C中未定义（gcc扩展允许，按1字节步进）
17

18
// 典型应用：malloc 返回 void*
19
int *arr = (int *)malloc(10 * sizeof(int));
20

21
// 典型应用：通用排序/比较函数
22
void qsort(void *base, size_t nmemb, size_t size,
23
           int (*compar)(const void *, const void *));

1
// 空指针：明确指向"无效地址"（通常是 0）
2
int *p1 = NULL;  // 安全的初始化
3
if (p1 != NULL) {
4
    *p1 = 10;  // 不会执行
5
}
6

7
// 野指针：指向被释放或未知的内存
8
int *p2;          // 未初始化，值是随机的！→ 野指针
9
int *p3 = malloc(4);
10
free(p3);         // 释放内存
11
// p3 现在是悬空指针（dangling pointer）
12
*p3 = 10;         // 未定义行为！可能 crash
13

14
// 防御编程：
15
free(p3);
1 collapsed line
16
p3 = NULL;  // 释放后立即置 NULL

1
int a = 42;
2
int *p = &a;
3
int **pp = &p;
4

5
printf("%d\n", a);     // 42
6
printf("%d\n", *p);    // 42
7
printf("%d\n", **pp);  // 42
8

9
// 经典应用：在函数中修改指针的值
10
void alloc_memory(int **ptr) {
11
    *ptr = (int *)malloc(sizeof(int));
12
    **ptr = 100;
13
}
14

15
int *p = NULL;
2 collapsed lines
16
alloc_memory(&p);  // 传入 &p（二级指针）
17
printf("%d\n", *p);  // 100

1
int a = 10, b = 20;
2

3
// 方式1: 指向const的指针（底层const）
4
const int *p1 = &a;
5
// *p1 = 30;  // 错误！不能通过p1修改值
6
p1 = &b;      // OK，可以改指向
7

8
// 方式2: const指针（顶层const）
9
int *const p2 = &a;
10
*p2 = 30;      // OK，可以改值
11
// p2 = &b;   // 错误！不能改指向
12

13
// 方式3: 双const
14
const int *const p3 = &a;
15
// *p3 = 30;  // 错误
5 collapsed lines
16
// p3 = &b;   // 错误
17

18
// 口诀: const 靠近谁谁不变
19
// const 在 * 左 → 值不变
20
// const 在 * 右 → 指针不变

1
char str1[] = "hello";       // 字符数组，栈上分配，可修改
2
char *str2 = "hello";        // 字符串指针，指向常量区，不可修改
3

4
str1[0] = 'H';  // OK
5
// str2[0] = 'H';  // 未定义行为！可能 crash
6

7
sizeof(str1);  // 6（含'\0'）
8
sizeof(str2);  // 4 或 8（指针大小）
9

10
strlen(str1);  // 5（不含'\0'）
11
strlen(str2);  // 5

1
void reverse_str(char *str) {
2
    char *start = str;                    // 头指针
3
    char *end = str + strlen(str) - 1;    // 尾指针
4
    while (start < end) {                 // 双指针向中间靠拢
5
        char tmp = *start;
6
        *start = *end;
7
        *end = tmp;
8
        start++;
9
        end--;
10
    }
11
}

1
/* 用指针实现 strlen - 示例实现 */
2
size_t my_strlen(const char *s) {
3
    const char *p = s;
4
    while (*p) p++;
5
    return p - s;
6
}

1
/* 用指针实现 strlen - 示例实现 */
2
size_t my_strlen(const char *s) {
3
    const char *p = s;
4
    while (*p) p++;
5
    return p - s;
6
}

1
char *my_strcpy(char *dst, const char *src) {
2
    char *ret = dst;
3
    while ((*dst++ = *src++) != '\0');
4
    return ret;  // 返回目标串首地址(支持链式调用)
5
}

1
/* 用指针实现 strcpy - 示例实现 */
2
char *my_strcpy(char *dst, const char *src) {
3
    char *ret = dst;
4
    while ((*dst++ = *src++) != '\0');
5
    return ret;
6
}

1
void *my_memcpy(void *dst, const void *src, size_t n) {
2
    char *d = (char *)dst;
3
    const char *s = (const char *)src;
4
    while (n--) *d++ = *s++;
5
    return dst;
6
}
7
// 注意：当 src 和 dst 重叠时应使用 memmove

1
void *my_memmove(void *dst, const void *src, size_t n) {
2
    char *d = (char *)dst;
3
    const char *s = (const char *)src;
4
    if (d < s) {
5
        while (n--) *d++ = *s++;     // 前向拷贝
6
    } else {
7
        d += n; s += n;
8
        while (n--) *(--d) = *(--s); // 后向拷贝
9
    }
10
    return dst;
11
}

1
// 回调函数：把函数通过指针传递给另一个函数，让它在适当时机调用
2

3
// 定义回调类型
4
typedef void (*button_callback_t)(int pin);
5

6
// 注册回调
7
static button_callback_t btn_cb = NULL;
8
void button_register_callback(button_callback_t cb) {
9
    btn_cb = cb;
10
}
11

12
// 按钮中断中调用回调
13
void EXTI_IRQHandler(void) {
14
    if (btn_cb) btn_cb(GPIO_PIN_0);
15
}
10 collapsed lines
16

17
// 用户注册自己的处理函数
18
void my_button_handler(int pin) {
19
    printf("按钮 %d 被按下\n", pin);
20
}
21

22
int main() {
23
    button_register_callback(my_button_handler);
24
    // ...
25
}

1
void swap(int *a, int *b) {
2
    int tmp = *a; *a = *b; *b = tmp;
3
}
4
int x = 1, y = 2;
5
swap(&x, &y);  // x=2, y=1

1
int **create_2d(int rows, int cols) {
2
    // 第一步: 分配行指针数组
3
    int **arr = (int **)malloc(rows * sizeof(int *));
4
    // 第二步: 为每行分配列空间
5
    for (int i = 0; i < rows; i++)
6
        arr[i] = (int *)malloc(cols * sizeof(int));
7
    return arr;  // 释放时要逆序: 先free每行, 再free行指针数组
8
}
9
void free_2d(int **arr, int rows) {
10
    for (int i = 0; i < rows; i++)
11
        free(arr[i]);
12
    free(arr);
13
}

1
int add(int a, int b) { return a + b; }
2
int sub(int a, int b) { return a - b; }
3
int mul(int a, int b) { return a * b; }
4
int divi(int a, int b) { return b ? a / b : 0; }
5

6
int (*ops[])(int, int) = {add, sub, mul, divi};
7
// ops[0](3,4) = 7, ops[1](3,4) = -1, ops[2](3,4) = 12

1
/* 用指针遍历结构体数组？ - 示例实现 */
2
typedef struct { int id; char name[20]; } Student;
3
Student arr[3] = {{1,"Alice"}, {2,"Bob"}, {3,"Charlie"}};
4
Student *p = arr;
5
for (int i = 0; i < 3; i++, p++)
6
    printf("%d: %s\n", p->id, p->name);

1
int a[3][4];
2
int (*p)[4] = a;     // p 指向 int[4] 数组
3
p[1][2] = 10;        // 等价于 a[1][2] = 10
4
*(*(p+1)+2) = 10;    // 同上

1
/* 字符串指针数组排序？ - 示例实现 */
2
void sort_strings(char *arr[], int n) {
3
    for (int i = 0; i < n-1; i++)
4
        for (int j = 0; j < n-1-i; j++)
5
            if (strcmp(arr[j], arr[j+1]) > 0) {
6
                char *tmp = arr[j];
7
                arr[j] = arr[j+1];
8
                arr[j+1] = tmp;
9
            }
10
}

1
struct Node;  // 前向声明: 此时Node是不完整类型
2

3
// ✅ 可以声明指针(指针大小固定,不需要知道结构体大小)
4
struct Node *ptr;
5

6
// ❌ 不能定义变量(编译器不知道分配多少内存)
7
// struct Node n;  // 错误!
8

9
// ❌ 不能访问成员
10
// ptr->data;     // 错误!
11

12
// 在.c文件中完整定义后就可以正常使用
13
struct Node {
14
    int data;
15
    struct Node *next;
1 collapsed line
16
};

1
const int a = 10;
2
int *p = (int *)&a;  // 强制转换去掉 const
3
*p = 20;             // 未定义行为！编译器可能把 a 优化为常量

1
// 寄存器操作
2
#define GPIOA_BASE 0x40020000
3
volatile uint32_t *gpioa_moder = (volatile uint32_t *)(GPIOA_BASE + 0x00);
4
*gpioa_moder |= (1 << 10);  // 设置第5引脚为输出模式

1
const int *p1;      /* 指向的值不可改 */
2
int *const p2 = &x;  /* 指针本身不可改 */
3
const int *const p3 = &x; /* 都不可改 */

1
// 无 restrict: 编译器假设 a 和 b 可能重叠
2
void add_arr(int *a, int *b, int n) {
3
    for (int i = 0; i < n; i++) a[i] += b[i];
4
}
5
// 有 restrict: 编译器知道不重叠，可以展开循环/SIMD
6
void add_arr_fast(int *restrict a, const int *restrict b, int n) {
7
    for (int i = 0; i < n; i++) a[i] += b[i];
8
}

1
int *arr[5];     /* 指针数组: 5个int指针 */
2
int (*p)[5];     /* 数组指针: 指向int[5]的指针 */
3
int (*fp)(int);  /* 函数指针 */

1
嵌入式内存布局:
2
  高地址 ┌──────────┐
3
         │   栈 ↓   │ (SP寄存器指向栈顶)
4
         │          │
5
         │  ↑ 堆    │ (malloc从这里分配)
6
         ├──────────┤
7
         │  .bss    │ (未初始化全局/静态, 清零)
8
         │  .data   │ (已初始化全局/静态)
9
         │  .text   │ (代码段, Flash中)
10
  低地址 └──────────┘

1
// malloc: 分配 n 字节，不初始化（内容随机）
2
int *p1 = (int *)malloc(10 * sizeof(int));
3

4
// calloc: 分配 n 个元素，初始化为 0
5
int *p2 = (int *)calloc(10, sizeof(int));
6

7
// realloc: 重新分配大小（可能移动内存块）
8
int *p3 = (int *)realloc(p1, 20 * sizeof(int));
9
// 注意：realloc 返回 NULL 时，原 p1 仍然有效
10

11
// free: 释放内存
12
free(p1);  // 如果 p3 != p1，p1 已被 realloc 释放
13
free(p2);
14
free(p3);
15

7 collapsed lines
16
// 必须检查返回值！
17
int *p = (int *)malloc(1000);
18
if (p == NULL) {
19
    // 分配失败处理
20
    printf("内存不足！\n");
21
    return -1;
22
}