飞翔飞翔
主页
  • 计算机基础

    • TCP/IP协议
    • Linux命令
  • 数据库

    • SQL教程
  • 编程语言

    • C语言
    • Python2
    • Python3
  • 数据格式

    • JSON教程
  • 工具

    • Markdown指南
  • Git

    • GitFlow
  • Quartz

    • Quartz教程
  • Java

    • Java设计模式
  • 缓存

    • Redis教程
联系
阿里云
主页
  • 计算机基础

    • TCP/IP协议
    • Linux命令
  • 数据库

    • SQL教程
  • 编程语言

    • C语言
    • Python2
    • Python3
  • 数据格式

    • JSON教程
  • 工具

    • Markdown指南
  • Git

    • GitFlow
  • Quartz

    • Quartz教程
  • Java

    • Java设计模式
  • 缓存

    • Redis教程
联系
阿里云
  • 学习路径
  • 第1章 编程基础概念

    • 冯·诺依曼体系结构
    • 数据在计算机中的表示
    • 编程语言的层次
    • C语言的起源与发展
    • C99标准的主要改进
    • 开发环境搭建
    • 第一个C程序
    • 编译与运行流程
    • 可移植性风险的三级体系
  • 第2章 数据类型与运算

    • 字符集与标识符
    • 关键字
    • 注释
    • char 类型
    • short 与 int
    • long 与 long long
    • 有符号与无符号
    • 取值范围与 limits.h
    • float 与 double
    • long double
    • _Bool 类型
    • 变量声明与定义
    • 常量
    • 转义序列
    • 算术运算符
    • 赋值运算符
    • 自增自减运算符
    • 关系与判等运算符
    • 逻辑运算符
    • 位运算符
    • 条件运算符
    • 逗号运算符
    • 运算符优先级
    • 隐式类型转换
    • 显式类型转换
  • 第3章 控制流

    • 表达式语句与空语句
    • 复合语句
    • if 语句
    • switch 语句
    • while 循环
    • do-while 循环
    • for 循环
    • break 与 continue
    • goto 语句
    • return 语句
  • 第4章 函数与模块化编程

    • 函数定义
    • 函数声明与原型
    • main 函数
    • 函数调用机制
    • 传值调用
    • 数组参数
    • 作用域
    • 存储期
    • 链接属性
    • static 与 extern
    • 递归
    • 头文件与源文件
    • 头文件保护
    • include 规则
  • 第5章 数组与字符串

    • 一维数组声明与初始化
    • 数组的存储模型
    • 数组访问与越界
    • 数组操作
    • 二维数组
    • 变长数组 VLA
    • 字符串基础
    • 字符串输入输出
    • 字符串处理函数
    • 字符串与数字转换
  • 第6章 指针

    • 指针的概念
    • 指针的声明与使用
    • 指针运算
    • const 与指针
    • 数组名与指针
    • 指针遍历数组
    • 指针与多维数组
    • 指针作为函数参数
    • 函数返回指针
    • 函数指针
    • 二级指针
    • 复杂声明解析
  • 第7章 结构体、联合体与枚举

    • 结构体定义与声明
    • 结构体初始化
    • 结构体成员访问
    • 结构体嵌套
    • 结构体指针
    • 结构体与函数
    • 联合体
    • 联合体与类型双关
    • 枚举类型
    • 位域
    • 内存对齐与填充
  • 第8章 动态内存管理

    • malloc 与 free
    • calloc 与 realloc
    • 内存泄漏
    • 悬垂指针
    • 内存分配策略
    • 自定义内存池
    • Valgrind 与内存检测
    • 内存碎片
    • 内存对齐分配
    • 常见内存错误
  • 第9章 文件输入输出

    • 文件打开与关闭
    • 文本读写
    • 格式化输入输出
    • 二进制读写
    • 文件定位
    • 错误处理
    • 标准流
    • 临时文件
    • 文件操作示例
  • 第10章 预处理器

    • 预处理器基础
    • 宏定义
    • 带参数的宏
    • 条件编译
    • 头文件包含
    • 预定义宏
    • 宏的高级技巧
    • 预处理器陷阱
    • 编译器特定扩展
  • 第11章 标准库概览

    • 标准库概述
    • assert.h
    • ctype.h
    • errno.h
    • float.h
    • limits.h
    • locale.h
    • math.h
    • setjmp.h
    • signal.h
    • stdarg.h
    • stddef.h
    • stdlib.h
  • 第12章 进阶主题

    • 内联函数
    • 变长数组 VLA
    • 复数类型
    • 布尔类型
    • stdint 与 inttypes
    • 灵活数组成员
    • 匿名结构体与联合体
    • 静态断言
    • 线程支持
    • 原子操作

变量声明与定义

变量是程序中存储数据的命名内存空间。在 C 语言中,使用变量前必须先声明或定义,告诉编译器变量的类型和名称。C99 允许声明与代码交织,不必像 C89 那样把所有声明放在代码块开头,这让代码更灵活,可以在需要时才引入变量。

声明与定义的区别

定义创建实际的变量,分配内存空间:

int count;              /* 定义:分配内存,未初始化 */
int total = 0;          /* 定义并初始化 */

声明告诉编译器变量的类型和名称,但不分配内存(用于引用在其他地方定义的变量):

extern int global_count;    /* 声明:global_count 在其他文件中定义 */

一个变量只能被定义一次,但可以被声明多次。

基本语法

变量定义的格式为:类型 标识符 [= 初始值];

int age;                    /* 定义未初始化的 int 变量 */
int score = 100;            /* 定义并初始化为 100 */
double pi = 3.14159;        /* 定义并初始化 double */
char grade = 'A';           /* 定义并初始化 char */
bool passed = true;         /* 定义并初始化 bool(C99) */

可以在一条语句中定义多个同类型变量:

int a, b, c;                /* 三个 int 变量,均未初始化 */
int x = 1, y = 2, z = 3;   /* 三个 int 变量,均初始化 */

初始化与未初始化

自动变量(函数内的局部变量)如果不初始化,其值是不确定的(垃圾值):

int main(void)
{
    int x;
    printf("%d\n", x);      /* 未定义行为!x 的值不确定 */
    return 0;
}

某些编译器在调试模式下会将未初始化变量设为 0,但发布模式下不会。永远不要依赖未初始化变量的值。

静态变量(static 修饰的局部变量和全局变量)自动初始化为 0:

int main(void)
{
    static int count;       /* 自动初始化为 0 */
    printf("%d\n", count);  /* 输出 0 */
    return 0;
}

C99 混合声明

C89 要求所有变量声明必须放在代码块的开头。C99 允许在需要时才声明变量,甚至可以在 for 循环中声明:

int main(void)
{
    int n = 10;
    printf("n = %d\n", n);
    
    double arr[n];          /* C99:VLA,在语句后声明 */
    
    for (int i = 0; i < n; i++) {   /* C99:for 循环内声明 i */
        arr[i] = i * 0.5;
    }
    
    int sum = 0;            /* C99:在代码中间声明 */
    for (int i = 0; i < n; i++)
        sum += (int)arr[i];
    
    printf("sum = %d\n", sum);
    return 0;
}

for (int i = 0; ...) 中的 i 作用域仅限于循环体,避免了循环变量污染外部命名空间。

作用域

变量的可见范围由声明位置决定:

块作用域:在代码块 { ... } 内声明的变量,只在该块内可见:

int main(void)
{
    int a = 10;             /* 块作用域:从声明到 main 结束 */
    
    {
        int b = 20;       /* 块作用域:从声明到内层块结束 */
        printf("%d %d\n", a, b);   /* 可以访问 a 和 b */
    }
    
    /* printf("%d\n", b); */   /* 错误:b 已不可见 */
    printf("%d\n", a);      /* 正确 */
    
    return 0;
}

文件作用域:在所有函数之外声明的变量,从声明位置到文件末尾可见:

#include <stdio.h>

int global_count = 0;       /* 文件作用域 */

void increment(void)
{
    global_count++;         /* 可以访问 */
}

int main(void)
{
    printf("%d\n", global_count);   /* 可以访问 */
    increment();
    return 0;
}

同名变量的遮蔽:内层块可以声明与外层同名的变量,内层变量会遮蔽外层变量:

int main(void)
{
    int x = 10;
    
    {
        int x = 20;       /* 遮蔽外层的 x */
        printf("%d\n", x);   /* 输出 20 */
    }
    
    printf("%d\n", x);      /* 输出 10 */
    return 0;
}

存储类说明符

auto、register、static、extern 控制变量的存储期和链接属性:

auto int a = 10;            /* auto:自动存储期(默认,极少显式写) */

register int counter = 0;   /* register:建议编译器放入寄存器 */
                            /* 现代编译器优化已足够智能,register 基本无用 */
                            /* C11 起 register 仅作为提示,不能取地址 */

static int persistent = 0;  /* static:静态存储期,只初始化一次 */

extern int shared;          /* extern:声明外部定义的变量 */

static 局部变量在函数调用之间保持值:

int counter(void)
{
    static int count = 0;   /* 只初始化一次 */
    return ++count;
}

int main(void)
{
    printf("%d\n", counter());   /* 1 */
    printf("%d\n", counter());   /* 2 */
    printf("%d\n", counter());   /* 3 */
    return 0;
}

常见错误

未初始化就使用:

int sum;
for (int i = 0; i < 10; i++)
    sum += i;               /* 错误:sum 初始值不确定 */

重复定义:

int x = 10;
int x = 20;                 /* 错误:同一作用域重复定义 */

声明与定义混淆:

extern int x = 10;          /* 有初始化,这是定义而非声明 */
                            /* 某些编译器警告或报错 */

VLA 在文件作用域:

int n = 10;
int arr[n];                 /* 错误:VLA 只能在块作用域 */
上一页
_Bool 类型
下一页
常量