C++ 变量类型

变量是用于存储数据的命名位置。在 C++ 中，每个变量都有一个特定的类型，决定了它可以存储什么类型的数据以及如何存储这些数据。

1. 变量的声明和初始化

1.1 变量声明

变量声明告诉编译器变量的名称和类型：

int age;           // 声明一个整型变量
float salary;      // 声明一个浮点型变量
char grade;        // 声明一个字符型变量
bool is_valid;     // 声明一个布尔型变量

1.2 变量初始化

变量初始化是在声明时给变量赋初值：

int age = 20;              // 初始化为 20
float salary = 5000.50f;   // 初始化为 5000.50
char grade = 'A';           // 初始化为 'A'
bool is_valid = true;      // 初始化为 true

1.3 列表初始化（C++11）

C++11 引入了列表初始化，使用花括号{}：

int age{20};               // 列表初始化
float salary{5000.50f};     // 列表初始化
char grade{'A'};            // 列表初始化
bool is_valid{true};       // 列表初始化

列表初始化的优点是可以防止窄化转换：

int x = 3.14;      // 允许，但会丢失小数部分
// int y{3.14};    // 错误，防止窄化转换

2. 变量的命名规则

变量名（标识符）必须遵循以下规则：

1. 只能包含字母、数字和下划线（_）
2. 不能以数字开头
3. 区分大小写（age和Age是不同的变量）
4. 不能使用 C++ 的关键字
5. 应该具有描述性，能够清楚地表达变量的用途

2.1 合法的变量名

int age;
int student_age;
int _count;
int MAX_SIZE;

2.2 非法的变量名

int 2nd_number;    // 错误：以数字开头
int student-age;   // 错误：包含连字符
int int;           // 错误：使用关键字
int my name;       // 错误：包含空格

2.3 命名规范

虽然 C++ 没有强制要求，但通常遵循以下命名规范：

• 变量名：使用小写字母，单词之间用下划线分隔（如student_age）
• 常量名：使用大写字母，单词之间用下划线分隔（如MAX_SIZE）
• 类名：使用大驼峰命名法（如Student）

3. 变量的作用域

变量的作用域是指变量在程序中可以被访问的区域。C++ 中有三种主要的作用域：

3.1 局部变量

在函数或代码块内部声明的变量，只能在声明它的函数或代码块中访问：

void function() {
    int local_var = 10;  // 局部变量
    std::cout << local_var << std::endl;  // 可以访问
}

int main() {
    // std::cout << local_var << std::endl;  // 错误：无法访问
    return 0;
}

3.2 全局变量

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

int global_var = 100;  // 全局变量

void function() {
    std::cout << global_var << std::endl;  // 可以访问
}

int main() {
    std::cout << global_var << std::endl;  // 可以访问
    return 0;
}

3.3 静态局部变量

使用static关键字声明的局部变量，只在第一次声明时初始化，之后保持其值：

void counter() {
    static int count = 0;  // 静态局部变量
    count++;
    std::cout << "Count: " << count << std::endl;
}

int main() {
    counter();  // 输出: Count: 1
    counter();  // 输出: Count: 2
    counter();  // 输出: Count: 3
    return 0;
}

4. 变量的存储类

存储类决定了变量的生命周期、可见性和存储位置。C++ 中有以下存储类：

4.1 auto

自动存储类，是局部变量的默认存储类：

int main() {
    auto int x = 10;  // 等同于 int x = 10;
    return 0;
}

4.2 register

寄存器存储类，建议编译器将变量存储在寄存器中以提高访问速度：

int main() {
    register int counter = 0;  // 建议存储在寄存器中
    return 0;
}

4.3 static

静态存储类，变量在程序的整个执行期间都存在：

int main() {
    static int count = 0;  // 静态变量
    return 0;
}

4.4 extern

外部存储类，用于声明在其他文件中定义的全局变量：

// file1.cpp
int global_var = 100;

// file2.cpp
extern int global_var;  // 声明在 file1.cpp 中定义的变量

4.5 mutable

可变存储类，允许在 const 成员函数中修改成员变量：

class Example {
private:
    mutable int count;  // 可变成员变量

public:
    void increment() const {
        count++;  // 允许修改
    }
};

5. 常量

常量是其值不能被修改的变量。可以使用const关键字定义常量：

const int MAX_SIZE = 100;  // 常量
// MAX_SIZE = 200;          // 错误：不能修改常量

6. 变量的类型推导

C++11 引入了auto关键字，可以自动推导变量类型：

auto i = 10;           // 推导为 int
auto d = 3.14;         // 推导为 double
auto str = "hello";    // 推导为 const char*

7. 变量的声明和定义

在 C++ 中，声明和定义是不同的概念：

• 声明：告诉编译器变量的名称和类型
• 定义：为变量分配内存空间

extern int x;  // 声明
int x = 10;    // 定义

8. 示例：综合运用

现在，让我们看一个综合运用各种变量类型的例子：

#include <iostream>

// 全局变量
int global_var = 100;
const int MAX_STUDENTS = 50;

// 函数声明
void demonstrate_local_variables();
void demonstrate_static_variables();

int main() {
    // 局部变量
    int age = 20;
    float salary = 5000.50f;
    char grade = 'A';
    bool is_student = true;
    
    // 列表初始化
    int score{95};
    double average{88.5};
    
    // auto 类型推导
    auto count = 10;
    auto pi = 3.14159;
    
    // 输出变量值
    std::cout << "年龄: " << age << std::endl;
    std::cout << "工资: " << salary << std::endl;
    std::cout << "成绩: " << grade << std::endl;
    std::cout << "是学生: " << (is_student ? "是" : "否") << std::endl;
    std::cout << "分数: " << score << std::endl;
    std::cout << "平均分: " << average << std::endl;
    std::cout << "计数: " << count << std::endl;
    std::cout << "圆周率: " << pi << std::endl;
    std::cout << "全局变量: " << global_var << std::endl;
    std::cout << "最大学生数: " << MAX_STUDENTS << std::endl;
    
    // 调用函数演示局部变量
    demonstrate_local_variables();
    
    // 调用函数演示静态变量
    demonstrate_static_variables();
    demonstrate_static_variables();
    demonstrate_static_variables();
    
    return 0;
}

void demonstrate_local_variables() {
    int local_var = 10;
    std::cout << "局部变量: " << local_var << std::endl;
}

void demonstrate_static_variables() {
    static int static_count = 0;
    static_count++;
    std::cout << "静态计数: " << static_count << std::endl;
}

小结

C++ 变量类型包括：

1. 变量的声明和初始化：

   • 声明：告诉编译器变量的名称和类型
   • 初始化：给变量赋初值
   • 列表初始化：使用花括号{}

2. 变量的命名规则：

   • 只能包含字母、数字和下划线
   • 不能以数字开头
   • 区分大小写
   • 不能使用关键字

3. 变量的作用域：

   • 局部变量：在函数或代码块内部声明
   • 全局变量：在所有函数外部声明
   • 静态局部变量：使用static关键字声明

4. 变量的存储类：

   • auto：自动存储类
   • register：寄存器存储类
   • static：静态存储类
   • extern：外部存储类
   • mutable：可变存储类

5. 常量：使用const关键字定义，值不能被修改

6. 变量的类型推导：使用auto关键字自动推导类型

掌握变量类型是学习 C++ 的基础，在后续章节中，我们将学习 C++ 的运算符和控制流。