C语言中的变量与常量

变量

定义

变量是程序中用于存储数据的容器。在C语言中，变量需要先声明后使用，声明时需要指定变量的类型。变量的类型决定了变量可以存储的数据类型以及变量在内存中的大小。

命名规则

C 语言变量命名规则

Vue 3 中的变量命名规则

通用编程变量命名规则

变量数据类型

变量的作用域

变量的作用域是指变量在程序中有效的范围，其中C语言的作用域包括：局部变量、全局变量、块作用域变量、文件作用域变量、静态局部变量、静态全局变量

局部变量

在函数内部声明的变量，只能在该函数内部访问。

void function() {
    int localVar = 20; // 局部变量
    // 只能在这里访问 localVar
}

全局变量

在函数外部声明的变量，可以在整个程序中访问。

int globalVar = 10; // 全局变量

void function() {
    // 可以访问 globalVar
}

块作用域变量

在代码块（如{}内的代码）中声明的变量，只能在该代码块内访问。

void function() {
    {
        int blockVar = 30; // 块作用域变量
        // 只能在这里访问 blockVar
    }
    // 不能在这里访问 blockVar
}

文件作用域变量

使用static关键字在函数外部声明的变量，只能在声明它的文件内部访问。

static int fileScopeVar = 40; // 文件作用域变量

void function() {
    // 可以访问 fileScopeVar
}

函数作用域变量（通常指静态局部变量）

在函数内部使用static关键字声明的变量，它在函数调用之间保持其值，但只能在该函数内部访问。

void function() {
    static int staticLocalVar = 50; // 静态局部变量
    // 每次调用函数时，staticLocalVar 保持其值
}

静态全局变量

在所有函数外部声明的静态变量，只在定义它的文件内部有效。

static int staticGlobalVar = 40; // 静态全局变量

void func() {
    printf("静态全局变量: %d\n", staticGlobalVar);
}

int main() {
    func();
    // 在其他文件中无法访问 staticGlobalVar
    return 0;
}

变量生命周期

生命周期是指变量在程序中存在的时间段,其中C语言的变量生命周期包括静态存储期、自动存储期、动态存储期。

静态存储期

全局变量和静态变量的生命周期从程序开始运行到程序结束。

int globalVar = 60; // 全局变量
static int staticVar = 70; // 静态全局变量

void func() {
    static int staticLocalVar = 80; // 静态局部变量
    printf("静态局部变量: %d\n", staticLocalVar);
    staticLocalVar++;
}

int main() {
    printf("全局变量: %d\n", globalVar);
    printf("静态全局变量: %d\n", staticVar);
    func(); // 输出: 静态局部变量: 80
    func(); // 输出: 静态局部变量: 81
    return 0;
}

自动存储期

局部变量的生命周期从变量声明开始，到函数结束时结束。

void func() {
    int localVar = 50; // 局部变量
    printf("局部变量: %d\n", localVar);
    // localVar 在函数结束时被销毁
}

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

动态存储期

通过动态内存分配（如malloc在C语言中）创建的变量，其生命周期从分配开始，到 free 调用结束。

#include <stdlib.h>
#include <stdio.h>

int main() {
    int* dynamicVar = (int*)malloc(sizeof(int)); // 动态分配内存
    if (dynamicVar == NULL) {
        printf("内存分配失败\n");
        return 1;
    }
    *dynamicVar = 90;
    printf("动态分配的变量: %d\n", *dynamicVar);
    free(dynamicVar); // 释放内存
    return 0;
}

综合例子

#include <stdio.h>
#include <stdlib.h>

// 全局变量
int globalVar = 10;

// 文件作用域变量
static int fileScopeVar = 20;

void function() {
    // 静态局部变量
    static int staticLocalVar = 30;

    // 局部变量
    int localVar = 40;

    // 块作用域变量
    {
        int blockVar = 50;
        printf("blockVar: %d\n", blockVar); // 可以访问 blockVar
    }
    // printf("blockVar: %d\n", blockVar); // 错误：blockVar 在这里不可访问

    printf("globalVar: %d\n", globalVar);   // 可以访问 globalVar
    printf("fileScopeVar: %d\n", fileScopeVar); // 可以访问 fileScopeVar
    printf("staticLocalVar: %d\n", staticLocalVar); // 可以访问 staticLocalVar
    printf("localVar: %d\n", localVar);    // 可以访问 localVar

    // 动态分配内存
    int *dynamicVar = (int*)malloc(sizeof(int));
    if (dynamicVar != NULL) {
        *dynamicVar = 60;
        printf("dynamicVar: %d\n", *dynamicVar); // 可以访问 dynamicVar
        // 释放内存
        free(dynamicVar);
    }

    // staticLocalVar 在下次函数调用时保持其值
    staticLocalVar++;
    printf("Incremented staticLocalVar: %d\n", staticLocalVar);
}

int main() {
    function();
    function(); // 调用第二次以显示 staticLocalVar 的持久性

    // 可以访问 globalVar 和 fileScopeVar，但不能直接访问 localVar、blockVar 和 staticLocalVar（因为它们的作用域不在这里）
    printf("globalVar in main: %d\n", globalVar);
    printf("fileScopeVar in main: %d\n", fileScopeVar);

    return 0;
}

常量

定义

常量是程序中值不能改变的量。常量在声明时必须初始化，并且其值在程序运行过程中不能被修改。

常量类型

1. 整数常量：可以是十进制、八进制（以0开头）或十六进制（以0x或0X开头）表示。

   #include <stdio.h>
   
   int main() {
       const int MAX_USERS = 100; // 整型常量
       printf("最大用户数: %d\n", MAX_USERS);
       // MAX_USERS = 200; // 错误，常量不能被修改
       return 0;
   }

2. 浮点常量：由整数部分、小数点、小数部分和指数部分组成，可以使用小数形式或指数形式表示。

   #include <stdio.h>
   
   int main() {
       const float PI = 3.14159; // 浮点型常量
       printf("圆周率: %f\n", PI);
       // PI = 3.14; // 错误，常量不能被修改
       return 0;
   }

3. 字符常量：用单引号括起来的单个字符，如'A'、'\n'等。

   #include <stdio.h>
   
   int main() {
       const char NEWLINE = '\n'; // 字符型常量
       printf("这是一个字符型常量: %c", NEWLINE);
       // NEWLINE = '\r'; // 错误，常量不能被修改
       return 0;
   }

4. 字符串常量：用双引号括起来的字符序列，如"Hello, World!"。

   #include <stdio.h>
   
   int main() {
       const char* GREETING = "Hello, World!"; // 字符串常量
       printf("%s\n", GREETING);
       // GREETING = "Hi, World!"; // 错误，常量指针的值不能被修改
       return 0;
   }

5. 枚举常量：通过 enum 关键字定义的一组命名的整数常量。

   #include <stdio.h>
   
   enum Weekday { MON, TUE, WED, THU, FRI, SAT, SUN };
   
   int main() {
       const enum Weekday today = MON; // 枚举常量
       printf("今天是: %d\n", today);
       // today = TUE; // 错误，常量不能被修改
       return 0;
   }

常量的定义方法

在C语言中，常量可以通过以下两种方式定义：

1. 使用#define预处理器：
   • #define是预处理命令，用于定义符号常量。
   • 定义形式为：#define 标识符 常量值。
   • 例如：#define PI 3.1416，定义了符号常量PI，其值为3.1416。

     #include <stdio.h>
     
     #define PI 3.1415926  // 定义宏常量PI，表示圆周率
     #define MAX_NUM 100   // 定义宏常量MAX_NUM，表示最大数值
     
     int main() {
         double circle_area = PI * 5 * 5;  // 在代码中使用PI，预处理时会替换为3.1415926
         int num = MAX_NUM;  // 使用MAX_NUM，会替换为100
         printf("用#define定义的常量示例：圆面积 = %lf\n", circle_area);
         printf("最大数值示例： %d\n", num);
         return 0;
     }

2. 使用const关键字：
   • const是C语言中的关键字，用于声明常量。
   • 定义形式为：const 数据类型 变量名 = 常量值。
   • 例如：const int MAX_SIZE = 100，定义了整型常量MAX_SIZE，其值为100。

     #include <stdio.h>
     
     int main() {
         const int num = 10;  // 定义常变量num，初始值为10，后续不能修改其值
         // num = 20;  // 这行代码是错误的，试图修改常变量的值，编译会报错
         printf("用const定义的常量示例： %d\n", num);
         return 0;
     }

总结