开发环境：

1. 网页版：跳转
2. 本地开发(Vscode)：跳转

一、基本变量大小和范围

（1）在8位/32位单⽚机中：

名称	中文名	大小(byte)	范围	格式化符号 (<4byte的都可以使用%d)
char	字符	1	-128 ~ 127	%c
short	短整型	2	-32768 ~ 32767	%d
int	整型	4	-2147483648 ~ 2147483647	%d
long	长整型	4	-2147483648 ~ 2147483647	%ld
bool	布尔型(逻辑型)	4	0-1	%u
float	单精度浮点型	4	符号位：1bit, 整数部分：8bit, 小数部分：23bit	%f
double	双精度浮点型	8	符号位：1bit, 整数部分：11bit, 小数部分：52bit	%lf
long long	长长整型	8	-9223372036854775808~ 9223372036854775807	%lld
enum	枚举型	4(可调整为1)		%d
struct	结合体型	可变 (根据成员计算)		%u
union	联合体型	可变 (根据成员计算)		%u
*	指针型	4		%u 或者 %x
unsigned	无符号	—	--------------	---------------
unsigned char (uint8_t)	字符	1	0 ~ 255 或 0x00 ~ 0xFF	%c
unsigned short (uint16_t)	短整型	2	0 ~ 65,535 或 0x00 ~ 0xFFFF	%u
unsigned int (uint32_t)	整型	4	0 ~ 4,294,967,295 或 0x00 ~ 0xFFFFFFFF	%u
unsigned long long (uint64_t)	长长整型	8	0 ~18,446,744,073,709,551,615 或 0x00 ~ 0xFFFFFFFFFFFFFFFF	%lld
long double	12 10 16	—	暂无 — 暂无 — 符号位：1bit, 整数部分：16bit, 小数部分：111bit	%Lf 或 %lld 或 %llx

测试代码

#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
enum {
	ONE = 1,
}num_t;

typedef struct { // 字节对齐，按最大成员字节转换
	uint8_t a; // 编译器强制转换为uint16_t
	uint16_t b;
}xjq_t;

typedef union { // 
	uint8_t buff[8]; // 如果buff>pack,则以此为准，8byte
	struct {
		uint8_t a;  // 1 byte
		uint16_t b; // 2 byte
		uint32_t c; // 4 byte
		uint32_t d; // 4 byte
	}pack; // 共计 11字节， 编译对齐后，12byte
}lisun_t;

int main () { // \t 代表tab
	printf("char:\t%d byte\r\n", sizeof(char));
	printf("short:\t%d byte\r\n", sizeof(short));
	printf("int:\t\t%d byte\r\n", sizeof(int));
	printf("long:\t%d byte\r\n", sizeof(long));
	printf("bool:\t%d byte\r\n", sizeof(bool));
	printf("float:\t%d byte\r\n", sizeof(float));
	printf("double:\t%d byte\r\n", sizeof(double));
	printf("long long:\t%d byte\r\n", sizeof(long long));
	printf("\r\n");
	printf("enum:\t%d byte\r\n", sizeof(num_t));
	printf("struct:\t%d byte\r\n", sizeof(xjq_t));
	printf("union:\t%d byte\r\n", sizeof(lisun_t));
	printf("\r\n");
	printf("uint8_t:\t%d byte\r\n", sizeof(uint8_t));
	printf("uint16_t:\t%d byte\r\n", sizeof(uint16_t));
	printf("uint32_t:\t%d byte\r\n", sizeof(uint32_t));
	printf("uint64_t:\t%d byte\r\n", sizeof(uint64_t));
	long double test = 0xFFFFFFFFFFFFFFFFull;
	printf("long double:\t%d byte, Max:%Lf\r\n", sizeof(long double), test);
}

结果：64位机器

结果：32位机器（单片机）无对齐限制

二、 局部变量 全局变量 静态变量 常量

特点：① 有变量名，变量值，有类型，占存储单元
   ② 变量名是一个存储地址

（1）局部变量

定义: 局部变量函数中定义的变量。函数执行完毕后，变量自动删除。
使用方式：int a = 3；

#include <stdio.h>
#include <stdint.h>
int main () {
	uint8_t test = 8; // 局部变量
	while(1);
}

（2）全局变量

定义：在函数外定义的变量就是全局变量。全局变量不会被删除。可以被外部文件使用。

#include <stdio.h>
#include <stdint.h>
uint8_t g_test = 8; // 全局变量
int main () {
	while(1);
}

（3）静态变量 (static)

定义：

1. 局部变量和全局变量都可以作为静态变量。
2. 不可被外部文件使用。
3. 成为静态变量后，无法被删除，将永远存在。(不掉电的情况)

#include <stdio.h>
#include <stdint.h>
static uint8_t g_test = 8; // 静态全局变量
int main () {
	static uint8_t test = 8; // 静态局部变量 （这样的定义等同静态全局变量）
	while(1);
}

（4）常量 (const)

使用方式：const int a=3;

特点：① 常变量具有变量的属性，有类型，占存储单元，只是不允许修改值
   ② 常变量在芯片的堆区。

#include <stdio.h>
#include <stdint.h>
const uint8_t g_test = 8; // 全局常量 （全部函数均可使用）
int main () {
	const uint8_t test = 8; // 局部常量 （作用域仅限本函数）
	while(1);
}

宏定义也可以定义常量（#define）

使用方式：#define PI 3.1416
特点：① 对符号常量的名字是不分配存储单元，PI只是临时变量
   ②预编译后，符号所在的位置均变为符号常量的值

#include <stdio.h>
#include <stdint.h>
#define  PI  3.1416
const uint8_t g_test = PI; // 全局常量 （全部函数均可使用）
int main () {
	const uint8_t test = PI; // 局部常量 （作用域仅限本函数）
	while(1);
}