C语言变量与数据类型

概述

本文档详细介绍C语言中的各种基本数据类型，包括整型、浮点型、字符型和布尔型，以及它们的声明、初始化、大小范围和基本操作。

整数类型

基本整数类型

类型 大小 范围 说明
int 通常4字节 -2,147,483,648 到 2,147,483,647 最常用的整数类型
short 通常2字节 -32,768 到 32,767 短整型，占用空间较小
long 通常4字节或8字节 取决于编译器和系统 长整型，可表示更大的数值
long long 通常8字节 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807 长长整型，可表示非常大的数值

无符号整数类型

类型 大小 范围 说明
unsigned int 通常4字节 0 到 4,294,967,295 无符号整型，只能表示非负数
unsigned short 通常2字节 0 到 65,535 无符号短整型
unsigned long 通常4字节或8字节 取决于编译器和系统 无符号长整型
unsigned long long 通常8字节 0 到 18,446,744,073,709,551,615 无符号长长整型

整数类型示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 基本整数类型
int age = 25;                     // 整型，通常4字节
short short_num = 32767;          // 短整型，通常2字节
long long_num = 1234567890;       // 长整型，通常4字节或8字节
long long big_num = 123456789012345LL; // 长长整型，通常8字节

// 无符号整数类型
unsigned int positive_num = 4294967295U; // 无符号整型
unsigned short ushort_num = 65535U;      // 无符号短整型

// 输出整数类型的值
printf("int age = %d\n", age);
printf("short short_num = %d\n", short_num);
printf("long long_num = %ld\n", long_num);
printf("long long big_num = %lld\n", big_num);
printf("unsigned int positive_num = %u\n", positive_num);
printf("unsigned short ushort_num = %u\n", ushort_num);

整数类型的大小和范围

1
2
3
4
5
6
7
8
#include <limits.h>

// 显示整数类型的大小和范围
printf("int 大小: %zu 字节, 范围: %d 到 %d\n", sizeof(int), INT_MIN, INT_MAX);
printf("short 大小: %zu 字节, 范围: %d 到 %d\n", sizeof(short), SHRT_MIN, SHRT_MAX);
printf("long 大小: %zu 字节\n", sizeof(long));
printf("long long 大小: %zu 字节\n", sizeof(long long));
printf("unsigned int 大小: %zu 字节, 最大值: %u\n", sizeof(unsigned int), UINT_MAX);

浮点类型

浮点类型概述

类型 大小 精度 说明
float 4字节 约6-7位有效数字 单精度浮点数
double 8字节 约15-17位有效数字 双精度浮点数（默认）
long double 8字节或16字节 约18-19位有效数字 长双精度浮点数

浮点类型示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 浮点类型
float pi_float = 3.14159f;        // 单精度浮点数，4字节
double pi_double = 3.141592653589793; // 双精度浮点数，8字节
long double pi_long_double = 3.141592653589793238L; // 长双精度浮点数

// 输出浮点类型的值
printf("float pi_float = %.5f\n", pi_float);
printf("double pi_double = %.15lf\n", pi_double);
printf("long double pi_long_double = %.20Lf\n", pi_long_double);

// 显示浮点类型的大小
printf("float 大小: %zu 字节\n", sizeof(float));
printf("double 大小: %zu 字节\n", sizeof(double));
printf("long double 大小: %zu 字节\n", sizeof(long double));

浮点类型的特殊值

1
2
3
4
5
6
7
8
#include <math.h>

// 浮点类型的特殊值
double infinity = INFINITY;       // 无穷大
double not_a_number = NAN;        // 非数字

printf("无穷大: %f\n", infinity);
printf("非数字: %f\n", not_a_number);

字符类型

字符类型概述

类型 大小 范围 说明
char 1字节 通常-128到127或0到255 字符类型，可表示ASCII字符
unsigned char 1字节 0到255 无符号字符类型
signed char 1字节 -128到127 有符号字符类型

字符类型示例

1
2
3
4
5
6
7
8
9
// 字符类型
char letter = 'A';                // 字符类型，1字节
char symbol = '$';
char newline = '\n';

// 输出字符类型的值
printf("char letter = %c (ASCII值: %d)\n", letter, letter);
printf("char symbol = %c\n", symbol);
printf("换行符演示: 第一行%c第二行\n", newline);

转义序列

转义序列 说明
\n 换行符
\t 制表符
\r 回车符
\' 单引号
\" 双引号
\\ 反斜杠
\0 空字符

布尔类型

布尔类型概述

类型 大小 值 说明
bool 通常1字节 true (1) 或 false (0) 布尔类型，需要包含头文件<stdbool.h>

布尔类型示例

1
2
3
4
5
6
7
8
9
#include <stdbool.h>

// 布尔类型
bool is_active = true;            // 布尔类型，需要#include <stdbool.h>
bool is_empty = false;

// 布尔类型在printf中通常用%d输出，true为1，false为0
printf("bool is_active = %d\n", is_active);
printf("bool is_empty = %d\n", is_empty);

变量的基本操作

算术运算符

运算符 描述 示例 结果
+ 加法 a + b a和b的和
- 减法 a - b a和b的差
* 乘法 a * b a和b的积
/ 除法 a / b a除以b的商
% 取余 a % b a除以b的余数

算术运算示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 变量的基本操作
int a = 10;
int b = 5;
int sum = a + b;
int difference = a - b;
int product = a * b;
int quotient = a / b;
int remainder = a % b;

printf("a = %d, b = %d\n", a, b);
printf("a + b = %d\n", sum);
printf("a - b = %d\n", difference);
printf("a * b = %d\n", product);
printf("a / b = %d\n", quotient);
printf("a %% b = %d\n", remainder);

自增和自减运算符

运算符 描述 示例 结果
++ 自增 a++ 或 ++a a的值加1
-- 自减 a-- 或 --a a的值减1

自增自减示例

1
2
3
4
5
6
7
8
9
10
11
// 自增和自减操作
int a = 10;
int b = 5;

a++;    // 后置自增，先使用a的值，再自增
b--;    // 后置自减，先使用b的值，再自减
printf("a++ = %d, b-- = %d\n", a, b);

++a;    // 前置自增，先自增，再使用a的值
--b;    // 前置自减，先自减，再使用b的值
printf("++a = %d, --b = %d\n", a, b);

类型转换

隐式类型转换

当不同类型的操作数进行运算时，C语言会自动进行类型转换，通常是将较小的类型转换为较大的类型，以避免数据丢失。

1
2
3
4
5
6
7
8
// 隐式类型转换示例
int int_num = 100;
float float_num = 3.14;
double result = int_num + float_num; // int转换为float，结果为double

printf("int_num = %d\n", int_num);
printf("float_num = %f\n", float_num);
printf("result = %lf\n", result);

显式类型转换

可以使用强制类型转换运算符来显式地转换类型。

1
2
3
4
5
6
7
8
9
10
11
// 显式类型转换示例
double pi = 3.1415926535;
int int_pi = (int)pi; // 强制转换为int，小数部分被截断

printf("pi = %lf\n", pi);
printf("int_pi = %d\n", int_pi);

// 另一个示例：计算圆的面积
int radius = 5;
double area = 3.14159 * radius * radius;
printf("半径为%d的圆的面积: %lf\n", radius, area);

常量

字面常量

类型 示例 说明
整型常量 100, 0x64 (十六进制), 0144 (八进制) 整数字面量
浮点常量 3.14, 6.02e23 (科学记数法) 浮点数字面量
字符常量 'A', '\n' 字符字面量
字符串常量 "Hello, World!" 字符串字面量

const修饰符

使用const关键字可以定义常量，常量的值在程序执行过程中不能被修改。

1
2
3
4
5
6
7
8
// const修饰符示例
const int MAX_AGE = 100;
const float PI = 3.14159;
const char NEWLINE = '\n';

printf("MAX_AGE = %d\n", MAX_AGE);
printf("PI = %f\n", PI);
printf("使用换行符: 第一行%c第二行\n", NEWLINE);

#define预处理器指令

使用#define可以定义宏常量，在编译前会被替换为对应的值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>

// #define预处理器指令示例
#define MAX_AGE 100
#define PI 3.14159
#define NEWLINE '\n'

int main() {
    printf("MAX_AGE = %d\n", MAX_AGE);
    printf("PI = %f\n", PI);
    printf("使用换行符: 第一行%c第二行\n", NEWLINE);
    
    return 0;
}

变量命名规则

  1. 变量名只能包含字母、数字和下划线
  2. 变量名不能以数字开头
  3. 变量名区分大小写
  4. 变量名不能是C语言的关键字
  5. 变量名应具有描述性，便于理解代码

变量命名示例

1
2
3
4
5
6
7
8
9
10
11
// 好的变量命名
int student_age;
float average_score;
bool is_student_active;

// 不好的变量命名
int a;              // 过于简单，不具描述性
float s;            // 过于简单，不具描述性
bool b;             // 过于简单，不具描述性
int 123abc;         // 不能以数字开头
int for;            // 不能使用关键字

总结

C语言提供了丰富的数据类型，包括：

  1. 整数类型：int, short, long, long long及其无符号版本
  2. 浮点类型：float, double, long double
  3. 字符类型：char, unsigned char, signed char
  4. 布尔类型：bool (需要包含<stdbool.h>)

选择合适的数据类型对于编写高效、可靠的C程序非常重要。应根据实际需求选择能够满足范围和精度要求的最小数据类型，以节省内存空间并提高程序性能。

同时，良好的变量命名和常量使用习惯可以提高代码的可读性和可维护性。

variables.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
#include <stdio.h>
#include <stdbool.h>
#include <limits.h>
#include <float.h>

/**
 * @brief 变量和数据类型示例
 * @details 这个程序演示了C语言中各种基本数据类型的使用，
 *          包括整型、浮点型、字符型和布尔型，并展示了它们的
 *          声明、初始化和基本操作。
 * @return 0 表示程序成功执行
 */
int main() {
    // =========================
    // 整数类型
    // =========================
    printf("=== 整数类型 ===\n");
    
    // 基本整数类型
    int age = 25;                     // 整型，通常4字节
    short short_num = 32767;          // 短整型，通常2字节
    long long_num = 1234567890;       // 长整型，通常4字节或8字节
    long long big_num = 123456789012345LL; // 长长整型，通常8字节
    
    // 无符号整数类型
    unsigned int positive_num = 4294967295U; // 无符号整型
    unsigned short ushort_num = 65535U;      // 无符号短整型
    
    printf("int age = %d\n", age);
    printf("short short_num = %d\n", short_num);
    printf("long long_num = %ld\n", long_num);
    printf("long long big_num = %lld\n", big_num);
    printf("unsigned int positive_num = %u\n", positive_num);
    printf("unsigned short ushort_num = %u\n\n", ushort_num);
    
    // 显示整数类型的大小和范围
    printf("int 大小: %zu 字节, 范围: %d 到 %d\n", sizeof(int), INT_MIN, INT_MAX);
    printf("short 大小: %zu 字节, 范围: %d 到 %d\n", sizeof(short), SHRT_MIN, SHRT_MAX);
    printf("long 大小: %zu 字节\n", sizeof(long));
    printf("long long 大小: %zu 字节\n\n", sizeof(long long));
    
    // =========================
    // 浮点类型
    // =========================
    printf("=== 浮点类型 ===\n");
    
    float pi_float = 3.14159f;        // 单精度浮点数，4字节
    double pi_double = 3.141592653589793; // 双精度浮点数，8字节
    long double pi_long_double = 3.141592653589793238L; // 长双精度浮点数
    
    printf("float pi_float = %.5f\n", pi_float);
    printf("double pi_double = %.15lf\n", pi_double);
    printf("long double pi_long_double = %.20Lf\n\n", pi_long_double);
    
    // 显示浮点类型的大小
    printf("float 大小: %zu 字节\n", sizeof(float));
    printf("double 大小: %zu 字节\n", sizeof(double));
    printf("long double 大小: %zu 字节\n\n", sizeof(long double));
    
    // =========================
    // 字符类型
    // =========================
    printf("=== 字符类型 ===\n");
    
    char letter = 'A';                // 字符类型，1字节
    char symbol = '$';
    char newline = '\n';
    
    printf("char letter = %c (ASCII值: %d)\n", letter, letter);
    printf("char symbol = %c\n", symbol);
    printf("换行符演示: 第一行%c第二行\n\n", newline);
    
    // =========================
    // 布尔类型
    // =========================
    printf("=== 布尔类型 ===\n");
    
    bool is_active = true;            // 布尔类型，需要#include <stdbool.h>
    bool is_empty = false;
    
    // 布尔类型在printf中通常用%d输出，true为1，false为0
    printf("bool is_active = %d\n", is_active);
    printf("bool is_empty = %d\n\n", is_empty);
    
    // =========================
    // 变量的基本操作
    // =========================
    printf("=== 变量操作 ===\n");
    
    int a = 10;
    int b = 5;
    int sum = a + b;
    int difference = a - b;
    int product = a * b;
    int quotient = a / b;
    int remainder = a % b;
    
    printf("a = %d, b = %d\n", a, b);
    printf("a + b = %d\n", sum);
    printf("a - b = %d\n", difference);
    printf("a * b = %d\n", product);
    printf("a / b = %d\n", quotient);
    printf("a %% b = %d\n", remainder);
    
    // 自增和自减操作
    a++;
    b--;
    printf("a++ = %d, b-- = %d\n", a, b);
    
    return 0;
}