aliases:
一、C语言的数据类型
1、基本数据类型的本质
int a = 10;
char b = 10;
float c = 10.0f;虽然 a, b, c 三个变量都是 “10”,但各自在内存中的存储形式不同。
属性 | 作用 | 举例 |
|---|---|---|
存储方式 | 数据如何编码 | 整数和浮点数编码形式不同 |
存储大小 | 需要多少字节 | STM32 上的 int 通常为 4 字节 |
取值范围 | 可以表达哪些数值 | uint8_t 为 0 - 255 |
运算规则 | 处理数据方式 | 整数除法与浮点数除法不同 |
类型转换 | 不同类型转换的方式 | int 转 float |
int a = 5;
int b = 2;
float c = a / b;
printf("%f", c);实际输出为:2.0000000,而非2.5000000,这是 int 相除导致的。 可以说,变量的类型不仅影响存储,还影响表达式的运算方式。
2、整数在内存中的存储方式
以 8 位 uint8_t 为例: uint8_t a = 5;

类型 | 位数 | 最小值 | 最大值 |
|---|---|---|---|
int8_t | 8 | -128 | 127 |
uint8_t | 8 | 0 | 255 |
二者有所不同。
**在常见的二进制补码表示中,有符号整数的最高位具有负权重,而无符号整数的全部位都具有正权重。**int8_t 中最高位为 1 时,表示该数为负;最高位为 0 时,表示该数为正。
3、int 的大小不是固定
sizeof(int)在 STM32 上通常返回 4。 但 C 语言标准并没有要求 int 必须占 4 字节。 不同环境下,编译器对整型宽度的实现可能不同。

因此在嵌入式开发中,如果硬件寄存器规定为 32 位,我们通常使用: uint32_t register_value; 而不是单纯依赖: unsigned int register_value; 因为前者表达的数据宽度更明确。
二、整数提升与隐式类型转换
1、整数提升(Integer Promotion)
#include <stdint.h>
uint8_t a = 200;
uint8_t b = 100;
int result = a + b;a、b 都是 8 位无符号整数,最大只能表示 255,但结果并不会溢出。 因为 C 语言规定,小于 int 等级的整数类型在参与许多算术运算前,会进行整数提升。

整数提升的基本规则: 对于 char、short 等低等级整数类型:
条件 | 提升后的类型 |
|---|---|
| int |
| unsigned int |
最小位宽:int 必须至少为 16 位(即 2 个字节,前提是 char 为 8 位) 在常见的 32 位 STM32 环境中,int 可以完整表示 uint8_t、int8_t、uint16_t、int16_t 的所有值,因此它们参与普通算术运算时通常会提升为 int。 注意:整数提升不会修改变量本身的类型,只是表达式求值时发生转换。
2、整数提升发生在赋值前
uint8_t a = 200;
uint8_t b = 100;
uint8_t result = a + b;结果:result == 44;
第 1 步:a、b 整数提升为 int
第 2 步:200 + 100 = 300
第 3 步:将 300 转换为 uint8_t
第 4 步:300 % 256 = 44
这说明 uint8_t result = a + b; 得到 44,并不是因为 a + b 在 8 位运算中溢出了,而是因为运算得到 300 后,转换为 uint8_t 时发生模 256 转换。
3、signed 与 unsigned 混合运算
考虑:
int a = -1;
unsigned int b = 1;
if (a < b)
{
printf("a < b\n");
}
else
{
printf("a >= b\n");
}实际输出为:a >= b 因为 int 与 unsigned int 具有相同的转换等级(rank),混合运算时,int 被转换成 unsigned int。 对于 32 位无符号整数:-1 → 2^{32} - 1
(1)为什么不是unsigned int转变为int ? 答:因为 C 的整数转换规则不是简单看“等级高低”,而是看转换后能否保留原值。对于 int 和 unsigned int,虽然二者转换等级相同,但 int 通常不能表示 unsigned int 的全部值,所以不能把 unsigned int 安全地转成 int。
(2)是不是只要出现 unsigned,所有运算都会转成 unsigned? 答:不是。这取决于参与运算类型的等级以及能否表示另一种类型的全部取值。
uint8_t a = 1;
int b = -1;
if (b < a)
{
printf("true\n");
}在常见 32 位 STM32 上,a 会提升为 int,所以实际比较:-1 < 1,结果为真。
三、C 语言的类型转换
C 语言的类型转换主要分为两类:
转换类型 | 含义 | 示例 |
|---|---|---|
隐式类型转换 | 编译器按照语言规则自动转换 | float a = 10; |
显式类型转换 | 程序员使用强制类型转换运算符 | float a = (float)10; |
1. 隐式类型转换
int a = 10;
float b = a;由于 a 是 int,b 是 float,赋值时需要把整数转换成浮点数。 结果为 b = 10.0f; 隐式转换不一定能保留原始数值,存在精度损失。
2、显式类型转换
(目标类型)表达式
int a = 7;
int b = 2;
float result = (float)a / b;result = 3.5f
3、不同整数类型之间的转换
转换情况 | 行为 |
|---|---|
目标整数类型可以表示原值 | 保持数值不变 |
转换为无符号整数类型 | 按目标类型的取值范围取模 |
转换为有符号整数类型,且数值超出范围 | 结果依赖 C 语言版本与实现,不能简单套用无符号取模规则 |
4、浮点数转换为整数
float a = 3.9f;
int b = (int)a;最终==🟡b == 3== C 语言的浮点转整数规则是:舍弃小数部分,向零截断。
5、具体应用实例
考虑一个 12 位 ADC 采样数据:
uint16_t adc_value = 2048;
float voltage = adc_value / 4095 * 3.3f;将 ADC 数值转换为电压:

但实际结果却是:voltage == 0.0f; 因为 adc_value / 4095 首先执行整数除法。 正确写法: float voltage = adc_value / 4095.0f * 3.3f;
四、变量的声明、定义与初始化
1、变量的声明与定义
声明(Declaration) 告诉编译器这个标识符叫什么名字、具有什么类型等属性。 例如: extern int count; 这告诉编译器:有一个名为 count 的整型变量,它的定义可能位于其他文件。 这条语句本身不定义该变量,因此不会为它创建独立的存储对象。 定义(Definition) 定义使变量成为程序中的一个实际对象。 例如: int count = 10; 这既是声明,也是定义。
每个变量定义同时也是声明,但声明不一定是定义。
2、变量的初始化
初始化是指在对象创建时,为其提供初始值。
int a = 10; // 初始化
a = 20; // 赋值操作 | 示例 | 含义 |
|---|---|---|
声明与初始化 | int a = 10; | 创建变量时提供初始值 |
赋值 | a = 20; | 修改已有变量的值 |
未显示初始化 | int a; | 初始状态取决于存储器 |
(1)局部变量未初始化
void test(void)
{
int a;
printf("%d", a);
}这里不能认为 a 默认等于 0。
对于这样的未初始化自动存储期局部变量,其初始值不确定;读取它可能导致未定义行为,不能依赖打印出的结果。
(2)全局变量未初始化
int count;
int main(void)
{
printf("%d", count);
return 0;
}此时 count 为 0。
因为全局变量具有静态存储期,没有显式初始化时会进行零初始化。
(3)static 局部变量未初始化
void test(void)
{
static int count;
printf("%d", count);
}这里的 count 同样会被初始化为 0。
变量 | 未显示初始化时 | 典型存储期 |
|---|---|---|
普通局部变量 | 值不确定 | 自动存储期 |
全局变量 | 零初始化 | 静态存储器 |
static 局部变量 | 零初始化 | 静态存储器 |
static 全局变量 | 零初始化 | 静态存储器 |
4、变量的作用域(Scope)
作用域:程序源码中,哪些位置可以通过某个名字访问对应的变量。
#include <stdio.h>
int g_count = 10;
void test(void)
{
int a = 20;
if (a > 0)
{
int b = 30;
printf("%d", b);
}
printf("%d", a);
}
int main(void)
{
test();
printf("%d", g_count);
return 0;
}变量 | 声明位置 | 作用域 |
|---|---|---|
g_count | 函数外 | 文件作用域 |
a | test() 函数内 | 所在的代码块,从声明处开始 |
b | if 代码块内 | if 代码块,从声明处开始 |
注意:g_count 具有文件作用域,并不意味着它只能被当前文件访问。是否能通过外部链接被其他源文件引用,还取决于变量的链接属性(linkage)。
(1)同名变量的名称遮蔽
int a = 10;
void test(void)
{
int a = 20;
printf("%d\n", a);
}输出: 20 函数内部的局部变量 a 遮蔽了外部的全局变量 a。这称为名称遮蔽(Shadowing)。 (2)作用域与生命周期不同 作用域:在源代码中,哪里能使用这个变量名? 存储期:变量对应的对象何时存在?
🟠作用域决定名字在哪里可见;存储期决定对象存在多久;链接属性决定不同作用域中的声明能否指向同一个变量。
5、实际开发问题:
声明与定义
// main.c 中
extern int a;
int main(void)
{
a = 10;
return 0;
}如果整个工程没有任何地方定义 a,会发生链接错误,不会发生编译错误。 编译器发现extern int a;,认为外部文件有定义变量 a,因此PASS; 但链接器在寻找变量 a 定义处的时候,失败,因此发生链接错误。
五、变量的存储期与链接属性
1、变量的存储器
存储器 | 对象存在的时间 | 常见示例 |
|---|---|---|
自动存储期 | 进入对应代码块或函数调用期间 | 普通局部变量 |
静态存储期 | 整个程序执行期间 | 全局变量、static 变量 |
线程存储期 | 对应线程执行期间 | _Thread_local 变量 |
分配存储期 | 从动态分配成功到释放 | malloc() 分配的对象 |
2、链接属性(Linkage)
链接属性 | 含义 | 典型例子 |
|---|---|---|
外部链接 External | 不同源文件中的声明可以指向同一个变量 | 普通全局变量 |
内部链接 External | 名字只在当前翻译单元内链接 | 文件作用域的 |
无链接 None | 不能通过链接属性与其他声明关联 | 普通局部变量 |
这里的“翻译单元”可以简单理解为:一个 .c 文件经过预处理,展开其所包含头文件后形成的编译单位。
例1:普通全局变量 int count = 10; 通常: 文件作用域、静态存储期、外部链接属性
例2:static 全局变量 static int count = 10; 文件作用域、静态存储期、内部链接属性 其他 .c 文件不能通过 extern int count; 引用这个 count 对象。
static 在函数内部和函数外部的主要作用不同。
使用位置 | 代码 | 主要作用 |
|---|---|---|
函数内部 | static int a; | 赋予静态存储期 |
文件作用域 | static int a; | 赋予内部链接属性 |
变量 | 作用域 | 存储期 | 链接属性 |
|---|---|---|---|
文件作用域 | 文件作用域 | 静态 | 外部链接 |
文件作用域 | 文件作用域 | 静态 | 内部链接 |
函数内 | 块作用域 | 自动 | 无链接 |
函数内 | 块作用域 | 静态 | 无链接 |
3、extern 的作用
extern 主要用于声明具有外部链接属性的变量。 例:
// sensor.c
uint16_t sensor_value = 100;sensor.c 定义变量
// sensor.h
extern uint16_t sensor_value;sensor.h 提供外部声明
// main.c
#include "sensor.h"
void test(void)
{
sensor_value = 200;
}main.c 通过声明引用同一变量
但实际嵌入式软件设计中,并不建议将模块内部的所有变量都通过 extern 暴露出去。
例如,传感器模块更合理的封装方式通常是:
// sensor.c
static uint16_t sensor_value = 100;
uint16_t Sensor_GetValue(void)
{
return sensor_value;
}// sensor.h
#ifndef SENSOR_H
#define SENSOR_H
#include <stdint.h>
uint16_t Sensor_GetValue(void);
#endif这样可以避免其他模块随意修改内部数据,降低耦合程度。
例: 假设项目只有两个源文件:
// main.c
extern int count;
int main(void)
{
count = 10;
return 0;
}// data.c
int other = 0;问题: 这两个文件分别编译时可能发生什么?最终链接时会发生什么?如果希望程序正常工作,最小修改是什么? 答: main.c 中 count 被声明为外部变量,因此可以正常单独编译;data.c 也可以正常编译。 但最终链接的时候,链接器需要解析 count 这个外部符号,找到它对应的定义,但找不到,因此链接失败。 可以在 data.c 中添加语句: int count = 0;
六、STM32 中变量存储位置
1、STM32 常见内存布局

Flash:非易失性的程序与数据仓库 SRAM:易失性的高速缓存
2、不同变量的存放位置
例:
int a = 10;
int b;
static int c = 20;
static int d;
void test(void)
{
int e = 30;
static int f = 40;
}变量 | 存储期 | 常见位置 |
|---|---|---|
a | 静态 | .data |
b | 静态 | .bss |
c | 静态 | .data |
d | 静态 | .bss |
e | 自动 | 栈或寄存器,也可能被优化 |
f | 静态 | .data |
.data: 通常保存具有非零初始值的可写静态存储期对象,它的初始值需要保存在非易失性存储器(Flash)中,启动时再被复制到 SRAM。 .bss: 通常保存零初始化的静态存储期对象,启动时一般将对应 SRAM 区域清零,无须为每个零值在 Flash 中保存完整的数据镜像。
3、STM32 上电后初始化变量的典型流程
①STM32 复位,进入启动流程 → ②设置栈指针,准备运行环境 → ③初始化 .data,将初始值从 Flash 复制到 SRAM → ④清零 .bss,初始化零值数据区域 → ⑤运行初始化函数 → ⑥进入main(),开始执行应用程序
全局变量不显式初始化,也能保证最初为零。 这是因为C 语言要求它们被零初始化,嵌入式启动代码负责实现这一要求。
4、FreeRTOS 中的栈
在典型的 Cortex-M FreeRTOS 系统中有两种 CPU 运行模式:
Thread mode(线程模式):普通代码运行,比如
main()和 FreeRTOS 任务代码。Handler mode(处理模式):异常/中断服务程序运行。
Cortex-M 有两个栈指针:
MSP(Main Stack Pointer):主栈指针。
PSP(Process Stack Pointer):进程/任务栈指针。
运行场景 | CPU 模式 | 使用的栈指针 |
|---|---|---|
复位后、启动调度器前、 | Thread mode | MSP |
中断服务程序 ISR、PendSV、SysTick、SVC | Handler mode | MSP |
FreeRTOS 任务中的普通代码 | Thread mode | PSP |
FreeRTOS 任务代码通常跑在 Thread mode 且使用 PSP,从而每个任务用自己的任务栈;MSP 留给异常/中断和启动代码。
各任务拥有自己的任务栈,任务线程模式通常使用 PSP。
任务栈用来保存函数调用过程中需要保留的局部数据、寄存器上下文等。
全局变量和普通
static变量不会因为任务切换就自动生成多个副本,即不会复制全局变量,也不会给每个任务生成一份.data/.bss。
例如:
static int g_count = 0;
void TaskA(void *argument)
{
int local_count = 0;
for (;;)
{
g_count++;
local_count++;
vTaskDelay(pdMS_TO_TICKS(1000));
}
}变量 | 常见存储位置 | 是否任务私有 |
|---|---|---|
g_count | SRAM 中静态数据区 | 否,共享对象 |
local_count | TaskA 栈或寄存器等 | 当前任务调用实例私有 |
如果 TaskB 也访问 g_count,就需要考虑并发访问与同步问题。 static 保证对象持续存在,但不提供线程安全性。
七、const、volatile 与变量的内存访问
C 语言中的变量声明不仅描述变量是什么类型,还可以进一步约束程序如何访问它。
关键字 | 核心作用 | 能否保证线程安全? |
|---|---|---|
const | 限制通过相应表达式修改对象 | 不能 |
volatile | 限制编译器对相关访问进行优化 | 不能 |
1、const:限制修改
int a = 10;
const int b = 20;
a = 30; // 合法
b = 40; // 违反 const 约束const:不能通过具有 const 限定类型的左值修改对象。 但需要注意: const 不等于变量一定被存放在 Flash 中,也不意味着底层内存绝对不可改变。 比如:
int a = 10;
const int *p = &a;
a = 20; // 合法
*p = 30; // 不合法这里 p 指向的数据不能通过 *p 修改,但是原来的变量 a 仍然可以被直接修改。
声明 | 指向的数据可修改? | 指针自身可修改? |
|---|---|---|
int *p | 可以 | 可以 |
const int *p | 不可以通过 p 修改 | 可以 |
int *const p = &a | 可以 | 不可以 |
const int *const p = &a | 不可以通过 p 修改 | 不可以 |
例如:
int a = 10;
int b = 20;
const int *p = &a;
p = &b; // 合法,改变指向
*p = 30; // 不合法,通过 p 修改数据int a = 10;
int b = 20;
int *const p = &a;
*p = 30; // 合法,修改 a
p = &b; // 不合法,p 不能重新指向 b2、volatile
考虑:
int flag = 0;
int main(void)
{
while (flag == 0)
{
}
// 后续操作
}假设 flag 会被中断服务函数修改。 从源代码看,程序应该不断检查 flag。但是对于没有正确建模外部修改的普通对象,编译器可能认为循环中没有任何代码修改 flag,从而优化重复读取,这就会导致可能 flag 值已经改变了,但仍然进行循环。
volatile int flag = 0; 就是告诉编译器对这个对象的访问需要保留,不能简单地把这些访问当成普通内存访问一样省略或合并。 注意: volatile 约束的是编译器对访问的处理,不是保证变量每时每刻都被同步到所有执行单元。 volatile 不是多线程同步的通用解决方案。
3、volatile 不能保证原子性
考虑:
volatile uint32_t counter = 0;
void TaskA(void *p)
{
counter++;
}
void TaskB(void *p)
{
counter++;
}即使使用 volatile,counter++ 仍然可能涉及读取、加法、写回。
例如初始值为 0:

预期增加两次应得到 2,但这种交错可能导致最终值为 1。
4、const volatile:为什么两个关键字可以一起使用
const volatile uint32_t STATUS;
const:程序不能通过这个对象的const限定左值写入。volatile:对该对象的读取不能被随意优化掉。
适合描述软件只读、但硬件可能自行更新的寄存器。
例如,一个硬件状态寄存器可能不断变化:
typedef struct
{
volatile uint32_t CONTROL;
volatile const uint32_t STATUS;
} DeviceRegisters;CONTROL可以由软件读写。STATUS允许软件读取,但不允许通
过该成员直接写入。
硬件仍可能改变
STATUS的内容。
5、STM32 外设寄存器常使用 volatile
对于 STM32,外设寄存器通常通过内存映射方式访问。
假设一个硬件寄存器位于地址 0x40000000:
#define REG (*(volatile uint32_t *)0x40000000u)
uint32_t value = REG;表达式 | 类型 | 说明 |
|---|---|---|
0x40000000u |
| 整数常量,表示字节地址 |
|
| 把整数地址转换成“指向 volatile 32 位无符号整数”的指针 |
|
| 解引用,得到地址 |
REG | 同上 | 宏展开后仍是这个左值表达式 |
这就意味着,uint32_t value = REG; 是从对应寄存器读取数据。 volatile 对这样的内存映射 I/O 很重要,因为寄存器值可能被外设硬件修改,而且读取或写入本身也可能触发硬件行为。
概念 | 解决的问题 | 常见手段 |
|---|---|---|
volatile | 编译器能否省略或合并相关访问 |
|
原子性 | 操作能否被其他执行流观察到中间状态 | 原子操作、合适的硬件机制 |
互斥与同步 | 多个任务如何安全协调访问 | 临界区、互斥锁、原子操作等 |
六、变量、指针与内存地址
术语 | 英文 | 基本含义 | 说明 |
|---|---|---|---|
位 | bit | 二进制位,取值 | 最小存储/信息单位 |
字节 | byte | 一组连续的位,通常作为可寻址的最小存储单元 | 通常1byte = 8 bit,是 C 中 |
字 | word | 常指 CPU 一次处理/寄存器宽度的“机器字” | 字长取决于体系结构,通常指机器字长 |
C 标准中 1 字节 = char 的大小,由 CHAR_BIT 给出;CHAR_BIT 至少为 8,但不保证一定是 8。
1、指针的类型的意义
考虑:
uint8_t *p1;
uint32_t *p2;在常见的 32 位 STM32 环境中,这两种对象指针通常都是 4 字节,但它们指向的对象类型不同。
属性 | uint8_t * | uint32_t * |
|---|---|---|
指向对象的宽度 | 1 字节 | 4 字节 |
| uint8_t | uint32_t |
| 通常 +1 字节 | 通常 +4 字节 |
对齐要求 | 通常较低 | 通常要求 4 字节对齐 |
例如:
uint32_t arr[3] = {10, 20, 30};
uint32_t *p = arr;假设数组首地址为 0x20000000:

p + 1 不是把指针的数值加 1,而是移动一个 uint32_t 元素的位置。
指针类型不仅影响解引用后的数据类型,还影响指针运算的步长。
2、指针类型转换与内存访问
考虑:
uint32_t a = 0x12345678;
uint8_t *p = (uint8_t *)&a;1、
&a得到uint32_t *类型的地址。2、
(uint8_t *)将其转换成uint8_t *。3、
p现在可以按字节访问a的对象表示。

p[0] == 0x78;
p[1] == 0x56;
p[2] == 0x34;
p[3] == 0x12;3、const、volatile 与指针组合
(1)volatile uint32_t *p;
p是一个指针。它指向
volatile uint32_t类型的对象。可以修改
p的指向。通过
*p读取和写入时,使用 volatile 访问语义。
(2)uint32_t *volatile p;
指针对象
p自身具有volatile限定。p指向的uint32_t并不因此具有 volatile 限定。对指针
p自身的读取和写入受 volatile 规则约束。
声明 | 被 volatile 限定的对象 |
|---|---|
volatile uint32_t *p | 指向的 |
uint32_t *volatile p | 指针 |
volatile uint32_t *volatile p | 指针本身及指向的 |