C语言变量与常量 #

一、变量概述 #

1.1 什么是变量 #

变量是程序中存储数据的容器，具有以下特征：

  • 名称：变量的标识符
  • 类型：变量存储数据的类型
  • 值：变量存储的数据
  • 地址：变量在内存中的位置

1.2 变量的本质 #

c 
int a = 10;

这行代码做了什么：

  1. 在内存中分配4字节空间
  2. 将空间命名为 a
  3. 将数值10存入该空间

二、变量定义与初始化 #

2.1 变量定义 #

c 
int a;
float b;
char c;
double d;

2.2 变量初始化 #

定义时初始化：

c 
int a = 10;
float b = 3.14;
char c = 'A';

先定义后初始化：

c 
int a;
a = 10;

部分初始化：

c 
int a = 10, b, c = 20;

2.3 未初始化变量 #

局部变量未初始化，值是随机的：

c 
int main() {
    int a;
    printf("%d\n", a);
    return 0;
}

全局变量未初始化，默认为0：

c 
int global_var;

int main() {
    printf("%d\n", global_var);
    return 0;
}

三、变量命名规则 #

3.1 命名规则 #

必须遵守：

  • 只能由字母、数字、下划线组成
  • 必须以字母或下划线开头
  • 不能使用关键字
  • 区分大小写

合法命名：

c 
int age;
int _count;
int student_name;
int MAX_SIZE;
int value1;
int _1st_place;

非法命名：

c 
int 2nd_place;
int my-var;
int int;
int @email;
int my var;

3.2 命名规范 #

驼峰命名法：

c 
int studentAge;
int maxCount;
void calculateTotal();

下划线命名法：

c 
int student_age;
int max_count;
void calculate_total();

匈牙利命名法：

c 
int iAge;
float fPrice;
char* pszName;

3.3 命名建议 #

类型 命名风格 示例
局部变量 小写+下划线 student_name
全局变量 g_前缀 g_total_count
静态变量 s_前缀 s_instance
常量 大写+下划线 MAX_BUFFER_SIZE

四、变量作用域 #

4.1 局部变量 #

在函数内部定义的变量：

c 
void func() {
    int a = 10;
    printf("%d\n", a);
}
  • 作用域：从定义处到函数结束
  • 生命周期：函数调用时创建，函数返回时销毁
  • 存储位置：栈区

4.2 全局变量 #

在函数外部定义的变量：

c 
int global_var = 100;

void func() {
    printf("%d\n", global_var);
}

int main() {
    printf("%d\n", global_var);
    func();
    return 0;
}
  • 作用域：整个程序
  • 生命周期：程序开始到结束
  • 存储位置：全局区

4.3 块级变量 #

在语句块内定义的变量：

c 
int main() {
    int a = 10;
    {
        int a = 20;
        printf("内部: %d\n", a);
    }
    printf("外部: %d\n", a);
    return 0;
}

输出：

text 
内部: 20
外部: 10

4.4 作用域规则 #

c 
int a = 100;

void func() {
    int a = 200;
    printf("func: %d\n", a);
}

int main() {
    printf("main: %d\n", a);
    func();
    
    {
        int a = 300;
        printf("block: %d\n", a);
    }
    
    printf("main: %d\n", a);
    return 0;
}

输出：

text 
main: 100
func: 200
block: 300
main: 100

五、常量 #

5.1 字面常量 #

直接写出的固定值：

c 
int a = 10;
float b = 3.14;
char c = 'A';
char* s = "Hello";

整型常量：

c 
int decimal = 100;
int octal = 0144;
int hex = 0x64;
int binary = 0b1100100;

浮点常量：

c 
float f1 = 3.14;
float f2 = 3.14f;
double d1 = 3.14;
double d2 = 3.14e10;

字符常量：

c 
char c1 = 'A';
char c2 = '\n';
char c3 = '\x41';

5.2 const关键字 #

定义只读变量：

c 
const int MAX_SIZE = 100;
const float PI = 3.14159;
const char NEWLINE = '\n';

const变量不能修改：

c 
const int a = 10;
a = 20;

5.3 #define宏定义 #

定义符号常量：

c 
#define MAX_SIZE 100
#define PI 3.14159
#define NEWLINE '\n'
#define MSG "Hello, World!"

使用：

c 
#include <stdio.h>

#define MAX_SIZE 100

int main() {
    int arr[MAX_SIZE];
    printf("数组大小: %d\n", MAX_SIZE);
    return 0;
}

5.4 枚举常量 #

定义一组相关常量：

c 
enum Weekday {
    SUNDAY,
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY
};

int main() {
    enum Weekday today = WEDNESDAY;
    printf("今天是周%d\n", today + 1);
    return 0;
}

指定值：

c 
enum Color {
    RED = 1,
    GREEN = 2,
    BLUE = 4
};

enum Status {
    OK = 200,
    NOT_FOUND = 404,
    SERVER_ERROR = 500
};

5.5 const vs #define #

特性 const #define
类型检查 有 无
作用域 遵循作用域规则 全局替换
调试 可调试 不可调试
内存 占用内存 不占用
定义时机 编译时 预处理时

推荐使用const：

c 
const int MAX_SIZE = 100;

六、变量存储类 #

6.1 auto #

默认存储类，可省略：

c 
void func() {
    auto int a = 10;
    int b = 20;
}

6.2 static #

静态变量，值保持：

c 
void counter() {
    static int count = 0;
    count++;
    printf("调用次数: %d\n", count);
}

int main() {
    counter();
    counter();
    counter();
    return 0;
}

输出：

text 
调用次数: 1
调用次数: 2
调用次数: 3

6.3 extern #

声明外部变量：

c 
extern int global_var;

void func() {
    printf("%d\n", global_var);
}

跨文件使用：

c 
int global_var = 100;
c 
extern int global_var;

void func() {
    global_var++;
}

6.4 register #

建议存储在寄存器：

c 
void func() {
    register int i;
    for (i = 0; i < 1000000; i++) {
    }
}

注意：register变量不能取地址。

6.5 存储类对比 #

存储类 作用域 生命周期 初始值 存储位置
auto 局部 函数内 随机 栈
static 局部/全局 程序期 0 全局区
extern 全局 程序期 0 全局区
register 局部 函数内 随机 寄存器

七、变量类型推断（C11） #

7.1 _Generic #

c 
#define type_name(x) _Generic((x), \
    int: "int", \
    float: "float", \
    double: "double", \
    char: "char", \
    default: "unknown")

int main() {
    int a = 10;
    float b = 3.14;
    printf("%s\n", type_name(a));
    printf("%s\n", type_name(b));
    return 0;
}

八、最佳实践 #

8.1 变量定义位置 #

C89要求变量定义在块开头：

c 
void func() {
    int a = 10;
    int b = 20;
    
    printf("%d\n", a);
}

C99允许在任意位置定义：

c 
void func() {
    printf("Hello\n");
    int a = 10;
    printf("%d\n", a);
}

8.2 初始化建议 #

定义时初始化：

c 
int a = 0;
int* p = NULL;

避免未初始化：

c 
int a;
printf("%d\n", a);

8.3 命名建议 #

有意义的名称：

c 
int student_count;
float average_score;
char* user_name;

避免单字母变量（循环除外）：

c 
for (int i = 0; i < n; i++) {
    printf("%d\n", i);
}

8.4 常量使用 #

使用常量代替魔法数字：

c 
#define MAX_BUFFER_SIZE 1024
#define PI 3.14159

char buffer[MAX_BUFFER_SIZE];
double area = PI * r * r;

九、常见错误 #

9.1 未初始化 #

c 
int a;
int b = a + 1;

9.2 类型不匹配 #

c 
int a = 3.14;

9.3 作用域错误 #

c 
void func() {
    int a = 10;
}
int main() {
    printf("%d\n", a);
    return 0;
}

9.4 常量修改 #

c 
const int a = 10;
a = 20;

9.5 重复定义 #

c 
int a = 10;
int a = 20;

十、总结 #

变量要点 #

要点 说明
定义 类型 变量名;
初始化 类型 变量名 = 值;
命名 字母、数字、下划线，不能数字开头
作用域 局部、全局、块级

常量要点 #

方式 示例
字面常量 10, 3.14, ‘A’
const const int MAX = 100;
#define #define MAX 100
enum enum { A, B, C };

存储类要点 #

存储类 说明
auto 默认，局部变量
static 静态，值保持
extern 外部变量声明
register 寄存器变量

下一步，让我们学习基本数据类型！

最后更新：2026-03-26