【绝对干货】C语言常量，变量，内存全方位总结：从入门到精通，这一篇就够了！

c

#include <stdio.h>

// 定义常量（一般大写，方便区分）
#define PRICE 98.5
#define PI 3.14159
#define MAX_STUDENTS 50
#define COURSE_NAME "C语言程序设计"

int main() {
    // 使用常量
    printf("课程：%s\n", COURSE_NAME);
    printf("价格：%.2f 元\n", PRICE);
    printf("圆周率：%f\n", PI);
    printf("最多学生数：%d\n", MAX_STUDENTS);
    
    // PRICE = 100;  // 错误！不能修改
    return 0;
}

c

#include <stdio.h>

int main() {
    // 定义常量（const修饰的变量就是常量）
    const double PI = 3.14159;
    const int DAYS_OF_WEEK = 7;
    const char GRADE = 'A';
    
    // 使用常量
    printf("圆周率：%f\n", PI);
    printf("一周有 %d 天\n", DAYS_OF_WEEK);
    printf("成绩：%c\n", GRADE);
    
    // PI = 3.14;  // 错误！const常量不能修改
    return 0;
}

c

#include <stdio.h>

// 定义符号常量
#define TAX_RATE 0.06
#define STUDENT_NUM 5

int main() {
    // const常量
    const double PRICE_PER_BOOK = 45.5;
    
    // 变量
    double total;
    int count = 3;
    
    // 计算总价
    total = count * PRICE_PER_BOOK * (1 + TAX_RATE);
    
    printf("买了 %d 本书\n", count);
    printf("单价：%.2f 元\n", PRICE_PER_BOOK);
    printf("税率：%.0f%%\n", TAX_RATE * 100);
    printf("总价：%.2f 元\n", total);
    
    // 字符常量的使用
    char c1 = 'A';
    char c2 = '\n';  // 转义字符
    char c3 = '\t';  // Tab
    
    printf("字符常量测试：%c%c前面有个Tab%c结束", c1, c2, c3);
    
    return 0;
}

c

char name = 'Tom';    // 错误！字符常量不能放多个字符
char name[] = "Tom";  // 正确！字符串要用双引号和数组

c

printf("C:\name");    // 错误！\n被解释成换行
printf("C:\\name");   // 正确！\\表示一个反斜杠

c

#define MAX 100
MAX = 200;            // 错误！不能修改常量

const int MIN = 0;
MIN = -10;            // 错误！不能修改const常量

c

#include <stdio.h>

int main() {
    int a = 100;      // 十进制
    int b = 0144;     // 八进制 (1*64 + 4*8 + 4 = 100)
    int c = 0x64;     // 十六进制 (6*16 + 4 = 100)
    
    printf("十进制: %d\n", a);      // 输出: 100
    printf("八进制: %o\n", a);      // 输出: 144
    printf("十六进制: %x\n", a);    // 输出: 64
    
    return 0;
}

c

#include <stdio.h>

int main() {
    int a = 100;           // int类型
    long b = 100L;         // long类型
    long long c = 100LL;   // long long类型
    unsigned int d = 100U; // unsigned int类型
    
    printf("a的大小: %llu 字节\n", sizeof(a));  // 4
    printf("b的大小: %llu 字节\n", sizeof(b));  // 4或8
    printf("c的大小: %llu 字节\n", sizeof(c));  // 8
    printf("d的大小: %llu 字节\n", sizeof(d));  // 4
    
    return 0;
}

c

#include <stdio.h>

int main() {
    double d1 = 3.14159;      // double类型
    double d2 = .123;          // 0.123
    double d3 = 5.;            // 5.0
    
    float f1 = 3.14F;          // float类型
    float f2 = 2.5e-3f;        // 0.0025
    
    // 科学计数法
    double sun = 1.496e8;      // 太阳距离：1.496*10^8 km
    double electron = 1.6e-19; // 电子电量：1.6*10^-19 C
    
    printf("圆周率：%f\n", d1);
    printf("0.123 = %f\n", d2);
    printf("5.0 = %f\n", d3);
    printf("2.5e-3 = %f\n", f2);
    printf("太阳距离：%e km\n", sun);     // 科学计数法输出
    printf("电子电量：%e C\n", electron);
    
    return 0;
}

c

#include <stdio.h>

int main() {
    // 1. 整型常量 - 不同进制
    printf("=== 进制表示 ===\n");
    printf("十进制 100 = %d\n", 100);
    printf("八进制 0144 = %d\n", 0144);     // 100
    printf("十六进制 0x64 = %d\n", 0x64);   // 100
    
    // 2. 整型常量 - 不同后缀
    printf("\n=== 类型后缀 ===\n");
    printf("int: %d\n", 100);
    printf("long int: %ld\n", 100L);
    printf("long long: %lld\n", 100LL);
    printf("unsigned: %u\n", 100U);
    
    // 3. 实型常量
    printf("\n=== 实型常量 ===\n");
    printf("小数形式: %f\n", 3.14159);
    printf("小数形式(无整数部分): %f\n", .5);
    printf("指数形式(大数): %e\n", 1.23e8);
    printf("指数形式(小数): %e\n", 1.23e-4);
    
    // 4. 各种类型的大小
    printf("\n=== 占用字节 ===\n");
    printf("100 的类型大小: %llu 字节\n", sizeof(100));
    printf("100L 的类型大小: %llu 字节\n", sizeof(100L));
    printf("100LL 的类型大小: %llu 字节\n", sizeof(100LL));
    printf("3.14 的类型大小: %llu 字节\n", sizeof(3.14));
    printf("3.14F 的类型大小: %llu 字节\n", sizeof(3.14F));
    
    return 0;
}

c

int a = 012;  // 你以为的12，实际是10
printf("%d", a);  // 输出10

c

float f = 1.2e-3.5;  // 错误！指数必须是整数
float f = 1.2e-3;    // 正确

c

long big = 4000000000;     // 可能溢出（超出int范围）
long big = 4000000000L;    // 正确，指定为long类型

c

// 错误1：普通字符常量不能表示换行
char c1 = '';      // 错误！空字符
char c2 = 'AB';    // 错误！只能一个字符
char c3 = '10';    // 错误！只能一个字符

// 正确写法
char c1 = '\0';    // 空字符
char c2 = 'A';     // 一个字符
char c3 = '1';     // 字符1

// 错误2：忘记转义
printf("C:\name");    // 错误！\n被解释成换行
printf("C:\\name");   // 正确！

// 错误3：字符串和字符混淆
char c4 = "A";        // 错误！"A"是字符串常量
char c5 = 'A';        // 正确！'A'是字符常量

\n  - newline（换行）
\t  - tab（制表符）
\r  - return（回车）
\b  - backspace（退格）
\a  - alarm（响铃）
\\  - 反斜杠
\'  - 单引号
\"  - 双引号
\0  - null（字符串结束标志）

【比特(bit)级别】
  ┌─────┐
  │  1  │  一个比特：只能存0或1
  └─────┘

【字节(byte)级别】
  ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
  │  0  │  1  │  0  │  0  │  0  │  0  │  1  │  1  │   1字节 = 8比特
  └─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘
   bit7  bit6  bit5  bit4  bit3  bit2  bit1  bit0
   (最高位)                            (最低位)

【字(word)级别 - 32位系统】
  ┌─────────────────────────────────────────────────┐
  │                   1个字 = 4字节                 │
  ├─────────┬─────────┬─────────┬─────────┬─────────┤
  │  字节3  │  字节2  │  字节1  │  字节0  │         │
  │ (31-24) │ (23-16) │ (15-8)  │  (7-0)  │         │
  └─────────┴─────────┴─────────┴─────────┴─────────┘

【层次关系】
                                   ┌─────────────────┐
                                   │    1个字        │
                                   │ (word)          │
                                   ├─────────────────┤
              ┌────────────────────┼─────────────────┼────────────────────┐
              │    1字节(byte)     │    1字节        │    1字节           │
              ├────────────────────┼─────────────────┼────────────────────┤
    ┌────┬────┼────┬────┬────┬────┼────┬────┬────┬──┼──┬────┬────┬────┬──┐
    │bit7│bit6│bit5│bit4│bit3│bit2│bit1│bit0│bit7│...                    │
    └────┴────┴────┴────┴────┴────┴────┴────┴────┴──┴──┴────┴────┴────┴──┘
    
    1字节 = 8比特
    1字 = CPU位宽（如32位系统1字=32比特=4字节）
    1双字 = 2字

c

#include <stdio.h>

int main() {
    // 以char为例（1字节 = 8位二进制）
    printf("=== 8位二进制能表示的数 ===\n");
    
    // 无符号char：8位全是数值位
    unsigned char uc = 0;
    printf("最小(全0): 00000000 = %d\n", uc);
    uc = 255;  // 11111111
    printf("最大(全1): 11111111 = %d\n", uc);
    printf("无符号char范围: 0 ~ 255 (2⁸-1)\n\n");
    
    // 有符号char：最高位是符号位（0正1负）
    signed char sc = -128;  // 10000000
    printf("最小: 10000000 = %d\n", sc);
    sc = 127;  // 01111111
    printf("最大: 01111111 = %d\n", sc);
    printf("有符号char范围: -128 ~ 127\n");
    
    printf("\n=== 二进制与最大值的关系 ===\n");
    printf("8位全1 = 2⁸ - 1 = %d\n", (1<<8)-1);
    printf("16位全1 = 2¹⁶ - 1 = %d\n", (1<<16)-1);
    printf("32位全1 = 2³² - 1 = %u\n", (unsigned)-1);
    
    return 0;
}

【内存中的一个int变量（4字节=32位）】
数值：123456789 的二进制表示：

内存地址：0x1000
┌─────────────────────────────────────────────────┐
│ 高位字节          │          低位字节            │
│ 00000111 │ 01011011 │ 11001101 │ 00010101        │
│ (0x07)   │ (0x5B)   │ (0xCD)   │ (0x15)          │
└─────────────────────────────────────────────────┘
  bit31     bit23     bit15     bit7      bit0

每个bit的位置：
bit31 bit30 ... bit2 bit1 bit0
  0     0         1    0    1

c

#include <stdio.h>
#include <math.h>

int main() {
    printf("=== 二进制位数与数据范围 ===\n");
    printf("------------------------------------------------\n");
    printf("位数\t状态数\t\t数据类型\t范围\n");
    printf("------------------------------------------------\n");
    
    printf("1位\t2\t\tbit\t\t0~1\n");
    printf("4位\t16\t\tnibble\t\t0~15\n");
    printf("8位\t256\t\tchar\t\t0~255 或 -128~127\n");
    printf("16位\t65536\t\tshort\t\t0~65535 或 -32768~32767\n");
    printf("32位\t%.0f\tint\t\t0~%.0f\n", 
           pow(2,32), pow(2,32)-1);
    printf("64位\t%.0f\tlong long\t0~%.0f\n", 
           pow(2,64), pow(2,64)-1);
    
    // 演示二进制位如何决定范围
    printf("\n=== 二进制位计算 ===\n");
    int bits = 8;
    printf("%d位无符号整数范围: 0 ~ %u\n", bits, (unsigned)(1<<bits) - 1);
    printf("%d位有符号整数范围: -%d ~ %d\n", 
           bits, 1<<(bits-1), (1<<(bits-1))-1);
    
    return 0;
}

c

#include <stdio.h>

// 打印整数的二进制表示
void print_binary(unsigned int num, int bits) {
    printf("二进制(");
    for(int i = bits-1; i >= 0; i--) {
        printf("%d", (num >> i) & 1);
        if(i % 4 == 0 && i != 0) printf(" ");  // 每4位加空格
    }
    printf(")");
}

int main() {
    int a = 42;
    char c = 'A';
    
    printf("=== 二进制视角看数据 ===\n\n");
    
    // 数字42的二进制
    printf("数字 %d 的存储：\n", a);
    printf("十进制：%d\n", a);
    printf("十六进制：0x%X\n", a);
    printf("二进制：");
    for(int i = 31; i >= 0; i--) {
        printf("%d", (a >> i) & 1);
        if(i % 8 == 0 && i != 0) printf(" | ");  // 字节分隔
    }
    printf("\n");
    printf("占用：%d字节 = %d位\n\n", sizeof(a), sizeof(a)*8);
    
    // 字符'A'的二进制
    printf("字符 '%c' 的存储：\n", c);
    printf("ASCII码：%d\n", c);
    printf("二进制：");
    for(int i = 7; i >= 0; i--) {
        printf("%d", (c >> i) & 1);
        if(i % 4 == 0 && i != 0) printf(" ");
    }
    printf("\n");
    printf("占用：%d字节 = %d位\n", sizeof(c), sizeof(c)*8);
    
    return 0;
}

c

#include <stdio.h>

int main() {
    // 1. 为什么char只有256种可能？
    printf("1字节 = 8位二进制\n");
    printf("8位二进制所有可能组合：\n");
    printf("最小：00000000\n");
    printf("最大：11111111\n");
    printf("组合数 = 2⁸ = 256种\n\n");
    
    // 2. 为什么会有溢出？
    unsigned char uc = 255;  // 11111111
    printf("uchar最大值255：11111111\n");
    uc = uc + 1;  // 100000000（9位，只能存低8位）
    printf("255 + 1 = %d（实际变成了00000000）\n", uc);
    printf("原因：只能存8位，高位丢失\n\n");
    
    // 3. 为什么有符号和无符号范围不同？
    printf("有符号char：最高位是符号位\n");
    printf("01111111 = +127\n");
    printf("10000000 = -128（补码表示）\n");
    printf("范围：-128 ~ +127\n");
    
    return 0;
}