c语言的基本数据类型，运算符及表达式及使用方法
典型 32 位系统输出
char: 1 字节
short: 2 字节
int: 4 字节
long: 4 字节
long long: 8 字节
float: 4 字节
double: 8 字节
long double: 12 字节
典型 64 位系统输出
char: 1 字节
short: 2 字节
int: 4 字节
long: 8 字节
long long: 8 字节
float: 4 字节
double: 8 字节
long double: 16 字节
一、基本数据类型
1. 整数类型
C 语言提供了多种整数类型，它们的主要区别在于取值范围和占用的内存空间：
// 有符号整数
signed char // 通常1字节，范围：-128 到 127
short // 通常2字节，范围：-32,768 到 32,767
int // 通常4字节，范围：-2,147,483,648 到 2,147,483,647
long // 通常4字节(32位系统)或8字节(64位系统)
long long // 至少8字节，范围：-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
// 无符号整数(只能表示非负数)
unsigned char // 通常1字节，范围：0 到 255
unsigned short // 通常2字节，范围：0 到 65,535
unsigned int // 通常4字节，范围：0 到 4,294,967,295
unsigned long // 通常4字节(32位系统)或8字节(64位系统)
unsigned long long // 至少8字节，范围：0 到 18,446,744,073,709,551,615
2. 浮点类型
用于表示小数，精度和范围不同：
float // 单精度浮点数，通常4字节，精度约6-7位小数
double // 双精度浮点数，通常8字节，精度约15-16位小数
long double // 扩展精度浮点数，通常8/10/12/16字节
3. 字符类型
用于存储单个字符：
char // 通常1字节，存储ASCII字符
wchar_t // 宽字符类型，用于存储Unicode字符(通常2或4字节)
4. 布尔类型
C99 标准引入的布尔类型：
_Bool // 布尔类型，1字节，值为0(false)或1(true)
// 需包含<stdbool.h>头文件以使用bool别名
#include <stdbool.h>
bool flag = true; // 等价于 _Bool flag = 1;
二、不同数据类型所占字节数
1. 标准规定的最小字节数
| 数据类型 | 最小字节数 |
|---|---|
| char | 1 |
| short | 2 |
| int | 2 |
| long | 4 |
| long long | 8 |
| float | 4 |
| double | 8 |
| long double | 10 |
2. 常见系统中的实际字节数
| 数据类型 | 32 位系统 | 64 位系统 |
|---|---|---|
| char | 1 | 1 |
| short | 2 | 2 |
| int | 4 | 4 |
| long | 4 | 8 |
| long long | 8 | 8 |
| float | 4 | 4 |
| double | 8 | 8 |
| long double | 12/16 | 16 |
| 指针 | 4 | 8 |
3. 使用sizeof运算符获取字节数
#include <stdio.h>
int main() {
printf("char: %zu 字节\n", sizeof(char));
printf("int: %zu 字节\n", sizeof(int));
printf("float: %zu 字节\n", sizeof(float));
printf("double: %zu 字节\n", sizeof(double));
printf("long long: %zu 字节\n", sizeof(long long));
// 获取变量占用的字节数
int x = 10;
printf("变量x占用: %zu 字节\n", sizeof(x));
return 0;
}
三、运算符及表达式
1. 算术运算符
+ // 加法
- // 减法
* // 乘法
/ // 除法(整数相除结果取整，如 5/2 = 2)
% // 取余(只能用于整数，如 5%2 = 1)
++ // 自增(前缀++a 或 后缀a++)
-- // 自减(前缀--a 或 后缀a--)
示例：
int a = 10, b = 3;
int sum = a + b; // 13
int diff = a - b; // 7
int prod = a * b; // 30
int quot = a / b; // 3
int rem = a % b; // 1
a++; // a变为11
--b; // b变为2
2. 关系运算符
== // 等于
!= // 不等于
> // 大于
< // 小于
>= // 大于等于
<= // 小于等于
示例：
int a = 5, b = 10;
bool result1 = (a == b); // false
bool result2 = (a != b); // true
bool result3 = (a > b); // false
bool result4 = (a < b); // true
3. 逻辑运算符
&& // 逻辑与(两边都为真时结果为真)
|| // 逻辑或(两边有一个为真时结果为真)
! // 逻辑非(取反)
示例：
int a = 5, b = 10;
bool result1 = (a < 10) && (b > 5); // true
bool result2 = (a > 10) || (b < 5); // false
bool result3 = !(a == b); // true
4. 赋值运算符
= // 基本赋值
+= // 加等于，如 a += 5 等价于 a = a + 5
-= // 减等于
*= // 乘等于
/= // 除等于
%= // 取余等于
示例：
int a = 10;
a += 5; // a变为15
a *= 2; // a变为30
a /= 3; // a变为10
a %= 7; // a变为3
5. 位运算符
& // 按位与
| // 按位或
^ // 按位异或
~ // 按位取反
<< // 左移
>> // 右移
示例：
int a = 5; // 二进制: 0101
int b = 3; // 二进制: 0011
int c = a & b; // 二进制: 0001 (十进制: 1)
int d = a | b; // 二进制: 0111 (十进制: 7)
int e = a ^ b; // 二进制: 0110 (十进制: 6)
int f = a << 2; // 二进制: 010100 (十进制: 20)
int g = a >> 1; // 二进制: 0010 (十进制: 2)
6. 条件运算符 (三元运算符)
条件 ? 表达式1 : 表达式2
int a = 10, b = 20;
int max = (a > b) ? a : b; // max等于20
7. 运算符优先级
运算符优先级决定了表达式中运算的先后顺序
int result = 3 + 4 * 2; // 结果为11，因为*优先级高于+
int result = (3 + 4) * 2; // 结果为14，括号可以改变优先级
四、类型转换
1. 隐式类型转换
在混合类型的表达式中，较小的类型会自动转换为较大的类型：
int a = 10;
double b = 3.5;
double result = a + b; // a被隐式转换为double类型
2. 强制类型转换
(double)5 // 将整数5转换为double类型(5.0)
(int)3.14 // 将浮点数3.14转换为整数(3)
(int)(a + b) // 先计算a+b，再将结果转换为int类型
3. 避免类型转换错误
// 错误示例：整数除法导致精度丢失
int a = 5, b = 2;
double result = a / b; // 结果为2.0，因为a/b先计算得到2
// 正确做法：先转换为浮点数
double result = (double)a / b; // 结果为2.5
五、总结
#include <stdio.h>
int main() {
int a = 10, b = 3;
double c = 3.14;
// 算术运算
printf("a + b = %d\n", a + b);
printf("a / b = %d\n", a / b); // 整数除法
printf("a / (double)b = %f\n", a / (double)b); // 浮点数除法
// 位运算
printf("a & b = %d\n", a & b);
// 条件运算
int max = (a > b) ? a : b;
printf("max = %d\n", max);
return 0;
}六、C语言基础概念演示程序
#include <stdio.h>
#include <stdbool.h> // 引入布尔类型支持 (C99标准)
#include <limits.h> // 提供数据类型范围的宏定义
int main() {
// 程序标题
printf("===== C语言基础概念演示程序 =====\n\n");
/********** 一、基本数据类型展示 **********/
printf("===== 一、基本数据类型 =====\n\n");
// 1. 整数类型
// - 有符号整数可表示正负数
// - 无符号整数只能表示非负数(范围更大)
printf("=== 整数类型 ===\n");
// char通常为1字节，存储ASCII字符
signed char char_var = 'A'; // ASCII值: 65
short short_var = 32000; // 2字节，范围约±32,767
int int_var = 2147483647; // 4字节，范围约±21亿
long long_var = 2147483647L; // 4/8字节，L后缀表示long类型
long long longlong_var = 9223372036854775807LL; // 8字节，LL后缀
// 打印整数类型变量的值
printf("char: %c (ASCII值: %d)\n", char_var, char_var);
printf("short: %d\n", short_var);
printf("int: %d\n", int_var);
printf("long: %ld\n", long_var); // long使用%ld格式化
printf("long long: %lld\n\n", longlong_var); // long long使用%lld
// 2. 浮点类型
// - 用于表示小数，精度和范围不同
printf("=== 浮点类型 ===\n");
float float_var = 3.14159f; // 4字节，单精度，f后缀表示float
double double_var = 3.14159265358979; // 8字节，双精度
long double longdouble_var = 3.14159265358979323846L; // 扩展精度
// 打印浮点类型，%.6f表示保留6位小数
printf("float: %.6f (%.20f) - 单精度精度限制\n", float_var, float_var);
printf("double: %.15lf (%.20lf) - 双精度更高精度\n", double_var, double_var);
printf("long double: %.20Lf\n\n", longdouble_var); // long double使用%Lf
// 3. 布尔类型
// - C99引入，值为true(1)或false(0)
printf("=== 布尔类型 ===\n");
bool bool_var1 = true;
bool bool_var2 = false;
printf("bool(true): %d\n", bool_var1);
printf("bool(false): %d\n\n", bool_var2);
/********** 二、数据类型字节数 **********/
printf("===== 二、数据类型字节数 =====\n\n");
// sizeof是C语言的运算符，返回类型或变量占用的字节数
printf("char: %zu 字节\n", sizeof(char));
printf("short: %zu 字节\n", sizeof(short));
printf("int: %zu 字节\n", sizeof(int));
printf("long: %zu 字节\n", sizeof(long));
printf("long long: %zu 字节\n", sizeof(long long));
printf("float: %zu 字节\n", sizeof(float));
printf("double: %zu 字节\n", sizeof(double));
printf("long double: %zu 字节\n", sizeof(long double));
printf("bool: %zu 字节\n", sizeof(bool));
printf("指针: %zu 字节 - 32位系统通常4字节，64位系统8字节\n\n", sizeof(int*));
/********** 三、运算符及表达式 **********/
printf("===== 三、运算符及表达式 =====\n\n");
int a = 10, b = 3;
double x = 3.5, y = 2.1;
// 1. 算术运算符
printf("=== 算术运算符 ===\n");
printf("a + b = %d\n", a + b);
printf("a - b = %d\n", a - b);
printf("a * b = %d\n", a * b);
printf("a / b = %d (整数除法，截断小数部分)\n", a / b);
printf("a / (double)b = %.2f (浮点数除法，需类型转换)\n", a / (double)b);
printf("a %% b = %d (取余运算，仅用于整数)\n", a % b);
// 自增运算符: 前缀先加1再使用，后缀先使用再加1
printf("a++ = %d (后缀自增，先返回a的值再+1)\n", a++);
printf("此时a = %d\n", a); // a变为11
printf("++b = %d (前缀自增，先+1再返回b的值)\n\n", ++b); // b变为4
// 重置a和b的值以便后续测试
a = 10; b = 3;
// 2. 关系运算符
// - 返回值为0(假)或1(真)
printf("=== 关系运算符 ===\n");
printf("a == b: %d\n", a == b);
printf("a != b: %d\n", a != b);
printf("a > b: %d\n", a > b);
printf("a < b: %d\n", a < b);
printf("a >= b: %d\n", a >= b);
printf("a <= b: %d\n\n", a <= b);
// 3. 逻辑运算符
// - 操作布尔值，具有短路特性
printf("=== 逻辑运算符 ===\n");
printf("(a > 5) && (b < 10): %d (逻辑与，两边都为真才为真)\n", (a > 5) && (b < 10));
printf("(a > 20) || (b < 10): %d (逻辑或，一边为真即为真)\n", (a > 20) || (b < 10));
printf("!(a == b): %d (逻辑非，取反)\n\n", !(a == b));
// 4. 赋值运算符
printf("=== 赋值运算符 ===\n");
int c = a; // 初始赋值
c += 5; printf("c += 5: %d (等价于c = c + 5)\n", c);
c -= 3; printf("c -= 3: %d (等价于c = c - 3)\n", c);
c *= 2; printf("c *= 2: %d (等价于c = c * 2)\n", c);
c /= 4; printf("c /= 4: %d (等价于c = c / 4)\n", c);
c %= 3; printf("c %%= 3: %d (等价于c = c %% 3)\n\n", c);
// 5. 位运算符
// - 直接对二进制位进行操作
printf("=== 位运算符 ===\n");
// 为简化表示，直接写出二进制值
printf("a = %d (二进制简化表示: 0b%04d)\n", a, 1010); // 10的二进制是1010
printf("b = %d (二进制简化表示: 0b%04d)\n", b, 0011); // 3的二进制是0011
// 按位与: 对应位都为1时结果为1
printf("a & b = %d (二进制: 0b%04d)\n", a & b, 0010);
// 按位或: 对应位有一个为1时结果为1
printf("a | b = %d (二进制: 0b%04d)\n", a | b, 1011);
// 按位异或: 对应位不同时结果为1
printf("a ^ b = %d (二进制: 0b%04d)\n", a ^ b, 1001);
// 按位取反: 每一位取反
printf("~a = %d (二进制补码表示: 0b%08d)\n", ~a, -1011);
// 左移: 所有位向左移动，右边补0，相当于乘以2的n次方
printf("a << 2 = %d (二进制: 0b%06d)\n", a << 2, 101000);
// 右移: 所有位向右移动，左边补符号位，相当于除以2的n次方
printf("a >> 1 = %d (二进制: 0b%03d)\n\n", a >> 1, 0101);
// 6. 条件运算符(三元运算符)
// - 格式: 条件 ? 表达式1 : 表达式2
printf("=== 条件运算符 ===\n");
printf("a和b中的较大值: %d\n\n", (a > b) ? a : b);
/********** 四、类型转换 **********/
printf("===== 四、类型转换 =====\n\n");
int int_val = 5;
double double_val = 2.7;
// 隐式转换: 小类型自动转换为大类型
printf("隐式转换: int + double = %lf (int自动转换为double)\n", int_val + double_val);
// 强制转换: 显式指定类型转换
printf("强制转换: (int)double_val = %d (截断小数部分)\n", (int)double_val);
// 整数除法问题: 先转换为double再计算
printf("整数除法问题: int_val / 2 = %d (错误结果)\n", int_val / 2);
printf("正确做法: (double)int_val / 2 = %lf\n\n", (double)int_val / 2);
/********** 五、数据类型取值范围 **********/
printf("===== 五、数据类型取值范围 =====\n\n");
// 这些宏定义来自<limits.h>头文件
printf("char 最小值: %d\n", CHAR_MIN);
printf("char 最大值: %d\n", CHAR_MAX);
printf("int 最小值: %d\n", INT_MIN);
printf("int 最大值: %d\n", INT_MAX);
printf("unsigned int 最大值: %u\n", UINT_MAX); // 无符号整数使用%u格式化
printf("long long 最小值: %lld\n", LLONG_MIN);
printf("long long 最大值: %lld\n\n", LLONG_MAX);
return 0;
} 
浙公网安备 33010602011771号