基本数据类型的定义、初始化和引用

发布时间：2026-05-06 16:08
42次浏览
分类： C语言

C语言基本数据类型

定义 · 初始化 · 引用 —— 完整操作指南

int short long long long unsigned float double char _Bool

💾 各类型内存占用直观对比（字节数）

char 1 字节

short 2 字节

int / float 4 字节

long long 8 字节

double 8 字节

🔢 一、整型家族

int / short / long / long long / unsigned —— 存储整数，可带符号或显式指定无符号。

1. 定义变量

int a;                  // 定义int型变量a
            short b;                // 定义short型变量b
            long c;                 // 定义long型变量c
            long long d;            // 定义long long型变量d
            unsigned int e;         // 定义无符号int型变量e

2. 初始化（三种常见形式）

// 形式一：定义时直接赋值
            int score = 95;
            short year = 2025;
            long distance = 150000000L;      // 长整型常量加L后缀
            long long bigNum = 1234567890123LL;
            unsigned int count = 100U;       // 无符号常量加U后缀

            // 形式二：先定义，后赋值（不是初始化，是赋值操作）
            int temperature;
            temperature = 26;

        // 形式三：多个变量同时定义并分别初始化
        int x = 1, y = 2, z = 3;

3. 引用变量

// 读取值参与运算
            int sum = score + 10;           // 取值运算，sum = 105
            score = score - 5;              // 修改自身，score变为90
            count++;                        // 自增，count变为101
            printf("score = %d, year = %hd\n", score, year);

            // 变量出现在赋值号左边时表示地址（左值）
            x = y;      // 将y的值复制到x的内存空间中

            // 取变量地址（产生指针）
            int* ptr = &score;              // ptr存储score的地址
            *ptr = 100;                     // 通过指针间接修改score的值
        printf("score now = %d\n", score);

⚠️ 注意：局部整型变量若未初始化，其值是随机的垃圾值，使用前必须赋值。无符号数循环：unsigned int u = 0; u--; 会变成最大值。

📐 二、浮点型家族

float / double / long double —— 存储带小数的实数，遵循IEEE 754标准。

1. 定义

float pi;
            double e;
        long double precise;

2. 初始化

float piValue = 3.14159265f;      // 字面量默认是double，加f表示float
            double eValue = 2.718281828;
            long double ldValue = 3.14159265358979323846L;  // 加L表示long double

            // 错误示范（精度丢失告警）：
            // float f2 = 3.14159265;   // 3.14159265是double，赋值给float可能截断

3. 引用

float radius = 5.0f;
            float area = 3.14159f * radius * radius;   // 浮点运算
            printf("Area = %.2f\n", area);

            // 科学计数法
            double atom = 1.6e-19;          // 1.6×10^-19
            double lightSpeed = 3.0e8;      // 3.0×10^8

            // 浮点数比较陷阱
            float a = 0.1f, b = 0.2f, c = 0.3f;
            if (a + b == c) {               // 很可能为假，浮点误差
            printf("Equal\n");
            } else {
            printf("Not equal due to precision\n");
        }

🚫 陷阱：浮点数不能精确表示所有小数，避免直接用 == 比较，应使用差值小于阈值的方式。float 有效位数约6~7位，double 约15~16位。

🔤 三、字符型

char / signed char / unsigned char —— 存储单个字符，实质是8位整数，可与整型混用。

1. 定义

char ch;
            signed char sc;      // 明确有符号
        unsigned char uc;    // 明确无符号

2. 初始化

char grade = 'A';          // 用字符常量初始化
            char newline = '\n';       // 转义字符
            char digit = 65;           // 等价于 'A'，用ASCII码初始化
        unsigned char byte = 200;  // 无符号char可存0~255

3. 引用

printf("Grade: %c, ASCII: %d\n", grade, grade);  // 按字符和整数输出

            // 字符参与算术运算（自动转为int）
            char nextGrade = grade + 1;       // 'B'

            // 当作小整数使用
            char i;
            for (i = 'a'; i <= 'z'; i++) {
            printf("%c ", i);            // 打印a~z
            }

            // 输入输出
            char key;
            scanf(" %c", &key);              // 取地址符 & 获取变量地址
        printf("You pressed: %c\n", key);

✅ 四、布尔型

_Bool / bool —— C99引入，包含 <stdbool.h> 后可用 bool、true、false。

1. 定义与初始化

#include <stdbool.h>    // 提供 bool, true, false

            _Bool flag1;
            bool flag2;         // 需要stdbool.h

            flag1 = 1;               // 任何非零值赋给_Bool都会变成1
            flag2 = true;            // true = 1
        bool isReady = false;    // false = 0

2. 引用

if (isReady) {
            printf("Ready!\n");
            } else {
            printf("Not ready.\n");
            }

            // 逻辑运算产生布尔值
            int age = 20;
            bool adult = (age >= 18);       // 关系运算结果为1(true)或0(false)
        printf("Adult: %d\n", adult);   // 输出1

ℹ️ 规律：_Bool 只有0和1两个值，赋值任何非零整数都会被转换为1。用 %d 格式输出布尔值，显示0或1。

⚙️ 五、特殊修饰与组合定义

const / volatile / typedef / enum / sizeof —— 与基本类型组合使用，影响引用行为。

// 常量定义（不可修改）
            const int MAX = 100;
            // MAX = 200;               // 错误，不能修改

            // volatile 告诉编译器该变量可能被外部改变，每次从内存读取
            volatile int sensorValue;
            sensorValue = 42;
            // 引用时确保从内存重新读取，而非使用寄存器缓存

            // 定义别名（typedef）
            typedef unsigned char BYTE;
            BYTE data = 0xFF;           // 等价于 unsigned char data = 255;

            // 枚举常量（一种整型常量的集合）
            enum Color { RED, GREEN, BLUE };
            enum Color c = GREEN;       // c值为1

            // sizeof 获取大小（以字节为单位）
            printf("Size of int: %zu\n", sizeof(int));
        printf("Size of float: %zu\n", sizeof(float));

🔗 六、综合引用示例

函数参数传值 vs 传指针、数组元素引用、结构体成员引用。

// 函数参数：值传递，形参是实参的副本
            void modify(int x) {
            x = 100;    // 只修改副本，不影响实参
            }

            void modifyByPointer(int *x) {
            *x = 100;   // 通过指针修改实参
            }

            int main() {
            int num = 10;
            modify(num);
            printf("After modify: %d\n", num);   // 仍为10

            modifyByPointer(&num);
            printf("After pointer modify: %d\n", num); // 变为100

            // 数组元素引用
            int arr[5] = {1, 2, 3, 4, 5};
            int second = arr[1];            // 读取数组元素，等价于 *(arr+1)
            arr[2] = 30;                    // 修改元素

            // 结构体变量（包含基本类型成员）
            struct Point {
            int x;
            int y;
            };
            struct Point p1 = {10, 20};
            p1.x = p1.x + 5;                // 引用成员变量

            return 0;
        }

📋 七、总结规律

掌握以下核心规律，即可游刃有余地操作C语言基本数据类型。

1 定义：类型在前，变量名在后，一次可声明多个。先归类，后命名。
2 初始化：建议定义时立即赋初值；全局/静态变量自动为0，局部变量值是随机的。
3 引用-右值：取值参与表达式、作为函数实参传递。
4 引用-左值：出现在赋值号左边，或作为修改操作（自增、赋值）的对象。
5 取地址：&变量 得到指针，指针类型严格匹配基本类型。
6 类型安全：C语言允许隐式类型转换，但可能丢失数据或精度，建议显式转换或保持类型一致。
7 底层映射：每个变量都有确定的内存大小和位模式，编译器根据类型生成对应指令。

本站所有文章、数据、图片来源于网络，仅供学习使用，如有侵权，联系删除！