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;

01、整数在内存中的存储方式

类型

位数

最小值

最大值

int8_t

8

-128

127

uint8_t

8

0

255

二者有所不同。

**在常见的二进制补码表示中,有符号整数的最高位具有负权重,而无符号整数的全部位都具有正权重。**int8_t 中最高位为 1 时,表示该数为负;最高位为 0 时,表示该数为正。

3、int 的大小不是固定

sizeof(int)在 STM32 上通常返回 4。 但 C 语言标准并没有要求 int 必须占 4 字节。 不同环境下,编译器对整型宽度的实现可能不同。

02、数据类型

因此在嵌入式开发中,如果硬件寄存器规定为 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 等级的整数类型在参与许多算术运算前,会进行整数提升。

03、整数提升

整数提升的基本规则: 对于 char、short 等低等级整数类型:

条件

提升后的类型

int 可以表示原类型的全部值

int

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
04、整数提升发生在赋值前

这说明 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 数值转换为电压:

05、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

名字只在当前翻译单元内链接

文件作用域的 static 变量

无链接 None

不能通过链接属性与其他声明关联

普通局部变量

这里的“翻译单元”可以简单理解为:一个 .c 文件经过预处理,展开其所包含头文件后形成的编译单位。

例1:普通全局变量 int count = 10; 通常: 文件作用域、静态存储期、外部链接属性

例2:static 全局变量 static int count = 10; 文件作用域、静态存储期、内部链接属性 其他 .c 文件不能通过 extern int count; 引用这个 count 对象。

static 在函数内部和函数外部的主要作用不同。

使用位置

代码

主要作用

函数内部

static int a;

赋予静态存储期

文件作用域

static int a;

赋予内部链接属性

变量

作用域

存储期

链接属性

文件作用域 int a

文件作用域

静态

外部链接

文件作用域 static int a

文件作用域

静态

内部链接

函数内 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 常见内存布局

06、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 模式

使用的栈指针

复位后、启动调度器前、main()

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 不能重新指向 b

2、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:

08、交错执行

预期增加两次应得到 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

unsigned int(通常 32 位无符号)

整数常量,表示字节地址

(volatile uint32_t*)0x40000000u

volatile uint32_t *

把整数地址转换成“指向 volatile 32 位无符号整数”的指针

*(volatile uint32_t*)0x40000000u

volatile uint32_t 左值

解引用,得到地址 0x40000000 处的对象

REG

同上

宏展开后仍是这个左值表达式

这就意味着,uint32_t value = REG; 是从对应寄存器读取数据。 volatile 对这样的内存映射 I/O 很重要,因为寄存器值可能被外设硬件修改,而且读取或写入本身也可能触发硬件行为。

概念

解决的问题

常见手段

volatile

编译器能否省略或合并相关访问

volatile 限定符

原子性

操作能否被其他执行流观察到中间状态

原子操作、合适的硬件机制

互斥与同步

多个任务如何安全协调访问

临界区、互斥锁、原子操作等

六、变量、指针与内存地址

术语

英文

基本含义

说明

位

bit

二进制位,取值 0 或 1,是信息的最小单位

最小存储/信息单位

字节

byte

一组连续的位,通常作为可寻址的最小存储单元

通常1byte = 8 bit,是 C 中 char 的大小

字

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 字节

*p 访问的数据类型

uint8_t

uint32_t

p + 1 的地址变化

通常 +1 字节

通常 +4 字节

对齐要求

通常较低

通常要求 4 字节对齐

例如:

uint32_t arr[3] = {10, 20, 30};

uint32_t *p = arr;

假设数组首地址为 0x20000000:

09、uint32_t 数组地址布局

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 的对象表示。

10、0x12345678小端字节布局
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

uint32_t *volatile p

指针 p 自身

volatile uint32_t *volatile p

指针本身及指向的 uint32_t