变量与基本数据类型

变量：数据的容器

在C++编程中，变量是我们存储和操作数据的基本工具。你可以把变量想象成一个贴有标签的盒子，里面可以存放各种类型的数据。

1.1 变量的声明与初始化

在C++中，使用变量前需要先声明它，告诉编译器变量的名称和类型：

基础语法示例

1. 变量和数据类型

int age;          // 声明一个整型变量age
double price;     // 声明一个双精度浮点型变量price
char grade;       // 声明一个字符型变量grade
bool isPassed;    // 声明一个布尔型变量isPassed

变量声明后可以立即初始化（赋予初始值）：

int score = 100;              // 声明并初始化
double temperature = 36.5;    // 声明并初始化
char initial = 'A';           // 字符使用单引号
std::string name = "Alice";   // 字符串使用双引号

C++11引入了更简洁的初始化方式：

int count{10};          // 使用花括号初始化
double pi{3.14159};     // 这种方式可以防止窄化转换

2. 变量的命名规则

只能包含字母、数字和下划线 不能以数字开头 不能使用C++关键字（如int, class等） 区分大小写 建议使用有意义的名称（如studentCount而非sc）

3. 变量的作用域

变量的作用域决定了它在程序中的可见范围：

#include <iostream>

int globalVar = 10;  // 全局变量，整个程序可见

int main() {
    int localVar = 20;  // 局部变量，只在main函数内可见

    {
        int blockVar = 30;  // 块作用域变量，只在这个代码块内可见
        std::cout << blockVar << std::endl;
    }

    // std::cout << blockVar << std::endl;  // 错误：blockVar在此不可见
    std::cout << globalVar << std::endl;    // 正确
    std::cout << localVar << std::endl;     // 正确

    return 0;
}

变量的存储位置：栈与堆

栈(stack)：自动管理的内存区域，存储局部变量和函数调用信息。当变量超出作用域时自动释放。 堆(heap)：动态分配的内存区域，需要手动管理（分配和释放）。

#include <iostream>

int main() {
    // 栈上分配的变量
    int stackVar = 10;

    // 堆上分配的变量（使用new）
    int* heapVar = new int(20);

    std::cout << "栈变量: " << stackVar << std::endl;
    std::cout << "堆变量: " << *heapVar << std::endl;

    // 必须手动释放堆内存
    delete heapVar;

    return 0;
}

基本数据类型

C++提供了多种基本数据类型，它们的主要区别在于存储大小和表示的数值范围。

2.1 整型类型

类型 大小(通常) 范围(通常)
char 1字节 -128到127或0到255
short 2字节 -32,768到32,767
int 4字节 -2,147,483,648到2,147,483,647
long 4或8字节 取决于平台
long long 8字节 -9,223,372,036,854,775,808到9,223,372,036,854,775,807

示例：

#include <iostream>
#include <climits>  // 包含各种数据类型的极限值

int main() {
    char smallNumber = 100;
    short mediumNumber = 30000;
    int largeNumber = 2000000000;
    long long veryLargeNumber = 9000000000000000000LL;

    std::cout << "char范围: " << CHAR_MIN << " 到 " << CHAR_MAX << std::endl;
    std::cout << "int范围: " << INT_MIN << " 到 " << INT_MAX << std::endl;

    return 0;
}

浮点型类型

类型 大小(通常) 精度 范围(通常) float 4字节 约7位有效数字 ±1.18×10^-38到±3.4×10^38 double 8字节 约15-16位有效数字 ±2.23×10^-308到±1.80×10^308

示例：

#include <iostream>
#include <iomanip>  // 用于控制输出格式

int main() {
    float piFloat = 3.14159265358979323846f;
    double piDouble = 3.14159265358979323846;

    std::cout << "float PI: " << std::setprecision(10) << piFloat << std::endl;
    std::cout << "double PI: " << std::setprecision(10) << piDouble << std::endl;

    return 0;
}

2.3 布尔类型

bool类型只有两个值：true(1)和false(0)。

#include <iostream>

int main() {
    bool isCppFun = true;
    bool isFishy = false;

    std::cout << "C++有趣吗？ " << isCppFun << std::endl;
    std::cout << "这可疑吗？ " << isFishy << std::endl;

    // 布尔值在条件语句中最有用
    if (isCppFun) {
        std::cout << "让我们继续学习C++!" << std::endl;
    }

    return 0;
}

3. sizeof操作符

sizeof操作符用于确定数据类型或变量占用的内存大小（以字节为单位）。

#include <iostream>

int main() {
    std::cout << "数据类型大小（字节）:" << std::endl;
    std::cout << "char: " << sizeof(char) << std::endl;
    std::cout << "short: " << sizeof(short) << std::endl;
    std::cout << "int: " << sizeof(int) << std::endl;
    std::cout << "long: " << sizeof(long) << std::endl;
    std::cout << "long long: " << sizeof(long long) << std::endl;
    std::cout << "float: " << sizeof(float) << std::endl;
    std::cout << "double: " << sizeof(double) << std::endl;
    std::cout << "bool: " << sizeof(bool) << std::endl;

    // 也可以用于变量
    int x = 0;
    std::cout << "变量x的大小: " << sizeof(x) << std::endl;

    return 0;
}

注意：sizeof的结果可能因编译器和平台而异。例如，在32位和64位系统上，某些数据类型的大小可能不同。

4. 类型修饰符

C++提供了类型修饰符来改变基本类型的含义：

  • signed：有符号类型（默认）
  • unsigned：无符号类型（仅非负数）
  • short：短整型
  • long：长整型
#include <iostream>

int main() {
    unsigned int positiveOnly = 4000000000;  // 更大的正数范围
    signed int normalInt = -2000000000;      // 可以包含负数

    short int smallNumber = 30000;           // 节省空间
    long int bigNumber = 2000000000;         // 更大的范围

    std::cout << "无符号整数: " << positiveOnly << std::endl;
    std::cout << "有符号整数: " << normalInt << std::endl;

    return 0;
}

5. 类型转换

C++中有时需要将一种类型转换为另一种类型：

5.1 隐式类型转换

int i = 42;
double d = i;  // 隐式将int转换为double

5.2 显式类型转换（C风格）

double pi = 3.14159;
int approxPi = (int)pi;  // 显式转换，丢失小数部分

5.3 C++风格的类型转换

double pi = 3.14159;
int approxPi = static_cast<int>(pi);  // 更安全的C++风格转换

6. 常量

使用const关键字声明不可修改的变量：

const double PI = 3.141592653589793;
const int MAX_STUDENTS = 100;

// PI = 3.14;  // 错误：不能修改常量

C++11引入了constexpr，表示编译时常量：

7. auto关键字（C++11）

auto让编译器自动推断变量类型：

auto x = 5;        // x是int
auto y = 3.14;     // y是double
auto z = "Hello";  // z是const char*

// 特别适用于复杂类型
std::vector<std::string> names = {"Alice", "Bob"};
auto it = names.begin();  // it的类型是std::vector<std::string>::iterator

总结

本章介绍了C++中的变量和基本数据类型，包括：

变量的声明、初始化和作用域 基本数据类型：整型、浮点型和布尔型 使用sizeof操作符获取类型大小 类型修饰符和类型转换 常量的使用 C++11的auto关键字 理解这些基础概念对于后续学习C++编程至关重要。在下一章中，我们将探讨运算符和表达式，这是操作这些变量的基本工具。