C++ 中的变量与数据类型

C++C++Beginner
立即练习

💡 本教程由 AI 辅助翻译自英文原版。如需查看原文,您可以 切换至英文原版

介绍

在本实验中,你将学习如何在 C++ 中使用变量和数据类型。你将探索不同大小的整数变量,初始化浮点数和双精度变量,声明字符和字符串变量,执行类型转换,定义常量,使用布尔变量,并检查各种数据类型的内存大小。此外,你还将学习如何处理整数溢出的情况。通过动手实践,你将为在 C++ 编程项目中管理数据打下坚实的基础。


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL cpp(("`C++`")) -.-> cpp/BasicsGroup(["`Basics`"]) cpp(("`C++`")) -.-> cpp/ControlFlowGroup(["`Control Flow`"]) cpp(("`C++`")) -.-> cpp/IOandFileHandlingGroup(["`I/O and File Handling`"]) cpp(("`C++`")) -.-> cpp/StandardLibraryGroup(["`Standard Library`"]) cpp/BasicsGroup -.-> cpp/variables("`Variables`") cpp/BasicsGroup -.-> cpp/data_types("`Data Types`") cpp/BasicsGroup -.-> cpp/operators("`Operators`") cpp/BasicsGroup -.-> cpp/booleans("`Booleans`") cpp/BasicsGroup -.-> cpp/strings("`Strings`") cpp/ControlFlowGroup -.-> cpp/conditions("`Conditions`") cpp/ControlFlowGroup -.-> cpp/if_else("`If...Else`") cpp/IOandFileHandlingGroup -.-> cpp/output("`Output`") cpp/StandardLibraryGroup -.-> cpp/string_manipulation("`String Manipulation`") subgraph Lab Skills cpp/variables -.-> lab-446078{{"`C++ 中的变量与数据类型`"}} cpp/data_types -.-> lab-446078{{"`C++ 中的变量与数据类型`"}} cpp/operators -.-> lab-446078{{"`C++ 中的变量与数据类型`"}} cpp/booleans -.-> lab-446078{{"`C++ 中的变量与数据类型`"}} cpp/strings -.-> lab-446078{{"`C++ 中的变量与数据类型`"}} cpp/conditions -.-> lab-446078{{"`C++ 中的变量与数据类型`"}} cpp/if_else -.-> lab-446078{{"`C++ 中的变量与数据类型`"}} cpp/output -.-> lab-446078{{"`C++ 中的变量与数据类型`"}} cpp/string_manipulation -.-> lab-446078{{"`C++ 中的变量与数据类型`"}} end

声明不同大小的整数变量(short、int、long)

在这一步中,你将学习 C++ 中的不同整数变量类型,以及如何声明具有不同内存大小的变量。C++ 提供了多种整数类型,以帮助你为数据选择最合适的存储方式。

打开 WebIDE,在 ~/project 目录下创建一个名为 integer_variables.cpp 的新文件:

touch ~/project/integer_variables.cpp

将以下代码添加到 integer_variables.cpp 文件中:

#include <iostream>

int main() {
    // 声明短整型(通常为 2 字节)
    short smallNumber = 32767;

    // 声明标准整型(通常为 4 字节)
    int regularNumber = 2147483647;

    // 声明长整型(通常为 4 或 8 字节)
    long largeNumber = 9223372036854775807L;

    // 打印不同整数类型的值
    std::cout << "Short Integer: " << smallNumber << std::endl;
    std::cout << "Regular Integer: " << regularNumber << std::endl;
    std::cout << "Long Integer: " << largeNumber << std::endl;

    return 0;
}

让我们分解这些整数类型:

  1. short

    • 最小的整数类型
    • 通常使用 2 字节内存
    • 范围:-32,768 到 32,767
  2. int

    • 标准整数类型
    • 通常使用 4 字节内存
    • 范围:-2,147,483,648 到 2,147,483,647
  3. long

    • 更大的整数类型
    • 根据系统不同,可能为 4 或 8 字节
    • 范围:-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807

编译并运行程序:

g++ integer_variables.cpp -o integer_variables
./integer_variables

示例输出:

Short Integer: 32767
Regular Integer: 2147483647
Long Integer: 9223372036854775807

需要记住的关键点:

  • 根据需要存储的数值范围选择合适的整数类型
  • 长整型的 L 后缀确保正确的类型解释
  • 不同系统可能对这些类型的内存大小略有不同

理解整数类型及其范围是 C++ 编程的基础。这些类型提供了不同的内存分配方式,以高效存储各种范围的整数。让我们通过以下图表可视化这些类型在 C++ 类型系统中的位置:

graph LR A[C++ 数据类型] --> B[基本类型] A --> C[派生类型] B --> D[整数类型] B --> E[浮点类型] B --> F[字符类型] B --> G[布尔类型] D --> D1[short] D --> D2[int] D --> D3[long] D --> D4[long long] E --> E1[float] E --> E2[double] E --> E3[long double] F --> F1[char] F --> F2[wchar_t] C --> H[数组] C --> I[指针] C --> J[引用] C --> K[std::string] style A fill:#f9f,stroke:#333,stroke-width:2px style B fill:#bbf,stroke:#333 style C fill:#bbf,stroke:#333

我们将在接下来的步骤中学习浮点类型、字符类型和布尔类型。

初始化带小数点的浮点数和双精度变量

在这一步中,你将学习 C++ 中的浮点变量,特别是 floatdouble 类型,它们允许你处理带小数的数字。这些类型对于表示带有小数部分的数字至关重要。

打开 WebIDE,在 ~/project 目录下创建一个名为 floating_point.cpp 的新文件:

touch ~/project/floating_point.cpp

将以下代码添加到 floating_point.cpp 文件中:

#include <iostream>
#include <iomanip>

int main() {
    // 声明并初始化 float 变量
    float smallDecimal = 3.14f;  // 'f' 后缀表示 float
    float scientificNotation = 2.5e3f;  // 2.5 × 10^3 = 2500.0

    // 声明并初始化 double 变量
    double preciseDecimal = 3.14159265359;
    double largeDecimal = 1.23456789e10;  // 12,345,678,900.0

    // 设置小数输出的精度
    std::cout << std::fixed << std::setprecision(4);

    // 打印 float 值
    std::cout << "Float Values:" << std::endl;
    std::cout << "Small Decimal: " << smallDecimal << std::endl;
    std::cout << "Scientific Notation: " << scientificNotation << std::endl;

    // 打印 double 值
    std::cout << "\nDouble Values:" << std::endl;
    std::cout << "Precise Decimal: " << preciseDecimal << std::endl;
    std::cout << "Large Decimal: " << largeDecimal << std::endl;

    return 0;
}

让我们分解这些浮点类型:

  1. float

    • 单精度浮点类型
    • 通常使用 4 字节内存
    • 精度较低,适合基本的十进制计算
    • 初始化时使用 'f' 后缀
  2. double

    • 双精度浮点类型
    • 通常使用 8 字节内存
    • 精度更高,适合大多数十进制计算
    • 可以表示更大且更精确的十进制数

编译并运行程序:

g++ floating_point.cpp -o floating_point
./floating_point

示例输出:

Float Values:
Small Decimal: 3.1416
Scientific Notation: 2500.0000

Double Values:
Precise Decimal: 3.1416
Large Decimal: 12345678900.0000

需要记住的关键点:

  • 使用 float 处理较小且精度要求不高的十进制数
  • 使用 double 进行更精确的计算
  • 'f' 后缀对于 float 字面量非常重要
  • 科学计数法允许表示非常大或非常小的数字
  • std::fixedstd::setprecision() 帮助控制小数输出

使用单引号声明和初始化字符变量

在这一步中,你将学习 C++ 中的字符变量,它们用于存储单个字符,并使用单引号声明。字符是表示单个字母、数字或符号的基本数据类型。

打开 WebIDE,在 ~/project 目录下创建一个名为 character_variables.cpp 的新文件:

touch ~/project/character_variables.cpp

将以下代码添加到 character_variables.cpp 文件中:

#include <iostream>

int main() {
    // 声明并初始化字符变量
    char letter = 'A';
    char number = '7';
    char symbol = '$';

    // 打印字符值
    std::cout << "Letter: " << letter << std::endl;
    std::cout << "Number: " << number << std::endl;
    std::cout << "Symbol: " << symbol << std::endl;

    // 演示字符算术运算
    char nextLetter = letter + 1;
    std::cout << "Next Letter: " << nextLetter << std::endl;

    // 字符的 ASCII 值
    std::cout << "ASCII value of 'A': " << (int)letter << std::endl;

    return 0;
}

让我们分解字符变量:

  1. 声明:

    • 使用 char 关键字
    • 始终使用单引号 '' 初始化
    • 可以存储单个字符
  2. 字符类型:

    • 字母:'A', 'b', 'Z'
    • 数字:'0', '7', '9'
    • 符号:'$', '@', '#'
  3. 字符算术运算:

    • 可以使用整数操作对字符进行操作
    • 每个字符都有一个底层的 ASCII 值

编译并运行程序:

g++ character_variables.cpp -o character_variables
./character_variables

示例输出:

Letter: A
Number: 7
Symbol: $
Next Letter: B
ASCII value of 'A': 65

需要记住的关键点:

  • 使用单引号 '' 表示字符字面量
  • 字符以数值形式存储(ASCII)
  • 可以对字符进行算术运算
  • 每个字符占用 1 字节内存

使用 std::string 创建字符串变量

在这一步中,你将学习如何使用 C++ 中的 std::string 类创建和操作字符串变量。字符串是字符序列,与字符数组相比,它使你能够更轻松地处理文本。

打开 WebIDE,在 ~/project 目录下创建一个名为 string_variables.cpp 的新文件:

touch ~/project/string_variables.cpp

将以下代码添加到 string_variables.cpp 文件中:

#include <iostream>
#include <string>

int main() {
    // 声明并初始化字符串变量
    std::string greeting = "Hello, World!";
    std::string name = "John Doe";
    std::string empty_string;

    // 打印字符串变量
    std::cout << "Greeting: " << greeting << std::endl;
    std::cout << "Name: " << name << std::endl;

    // 字符串拼接
    std::string welcome = greeting + " Welcome, " + name;
    std::cout << "Welcome Message: " << welcome << std::endl;

    // 字符串长度
    std::cout << "Greeting length: " << greeting.length() << std::endl;

    // 访问单个字符
    std::cout << "First character of name: " << name[0] << std::endl;

    // 修改字符串
    name = "Jane Smith";
    std::cout << "Updated Name: " << name << std::endl;

    return 0;
}

让我们分解字符串操作:

  1. 声明:

    • 使用 #include <string> 访问字符串功能
    • 使用 std::string 关键字声明
    • 可以用文本初始化或留空
  2. 字符串操作:

    • 使用 + 运算符进行拼接
    • 使用 .length() 方法获取长度
    • 使用 [] 索引访问字符

编译并运行程序:

g++ string_variables.cpp -o string_variables
./string_variables

示例输出:

Greeting: Hello, World!
Name: John Doe
Welcome Message: Hello, World! Welcome, John Doe
Greeting length: 13
First character of name: J
Updated Name: Jane Smith

需要记住的关键点:

  • std::string 比字符数组更灵活
  • 字符串可以轻松修改和操作
  • 使用 .length() 获取字符串大小
  • 可以使用 + 运算符拼接字符串

使用类型转换在不同数值类型之间转换

在这一步中,你将学习 C++ 中的类型转换(Type Casting),它允许你在不同数值类型之间转换值。当你需要更改变量的数据类型而不丢失原始值时,类型转换是必不可少的。

打开 WebIDE,在 ~/project 目录下创建一个名为 type_casting.cpp 的新文件:

touch ~/project/type_casting.cpp

将以下代码添加到 type_casting.cpp 文件中:

#include <iostream>

int main() {
    // 隐式类型转换(自动转换)
    int intValue = 10;
    double doubleValue = intValue;  // 自动将 int 转换为 double
    std::cout << "Implicit Conversion (int to double): " << doubleValue << std::endl;

    // 显式类型转换(手动转换)
    double pi = 3.14159;
    int truncatedPi = (int)pi;  // C 风格转换,截断小数部分
    std::cout << "Explicit Conversion (double to int): " << truncatedPi << std::endl;

    // 使用 static_cast 进行类型转换
    float floatValue = 7.5f;
    int roundedValue = static_cast<int>(floatValue);
    std::cout << "Static Cast (float to int): " << roundedValue << std::endl;

    // 数值类型之间的转换(可能导致数据丢失)
    long largeNumber = 1000000;
    short smallNumber = static_cast<short>(largeNumber);
    std::cout << "Large to Small Type Conversion: " << smallNumber << std::endl;

    // 在计算中混合不同的数值类型
    int a = 5;
    double b = 2.5;
    double result = a + b;  // 隐式将 int 转换为 double
    std::cout << "Mixed Type Calculation: " << result << std::endl;

    return 0;
}

让我们分解类型转换:

  1. 隐式转换:

    • 在兼容类型之间自动转换
    • 无需程序员干预
    • 在转换为更大类型时通常是安全的
  2. 显式转换:

    • 手动类型转换
    • 使用 static_cast<>() 或 C 风格的 (type) 语法
    • 可能导致数据丢失或意外结果

编译并运行程序:

g++ type_casting.cpp -o type_casting
./type_casting

示例输出:

Implicit Conversion (int to double): 10
Explicit Conversion (double to int): 3
Static Cast (float to int): 7
Large to Small Type Conversion: 16960
Mixed Type Calculation: 7.5

需要记住的关键点:

  • 在转换为较小类型时要小心
  • 使用 static_cast<>() 进行更安全、更明确的转换
  • 了解转换过程中可能的数据丢失
  • 隐式转换可以在计算中自动发生

使用 const 关键字定义常量

在这一步中,你将学习如何使用 C++ 中的 const 关键字定义常量。常量是在初始化后无法更改的值,它提供了一种创建不可变变量的方法,从而保护数据免受意外修改。

打开 WebIDE,在 ~/project 目录下创建一个名为 constants.cpp 的新文件:

touch ~/project/constants.cpp

将以下代码添加到 constants.cpp 文件中:

#include <iostream>

int main() {
    // 使用 const 关键字定义常量
    const int MAX_USERS = 100;
    const double PI = 3.14159;
    const char GRADE_SEPARATOR = '-';

    // 演示常量的使用
    std::cout << "Maximum Users: " << MAX_USERS << std::endl;
    std::cout << "Value of PI: " << PI << std::endl;
    std::cout << "Grade Separator: " << GRADE_SEPARATOR << std::endl;

    // 命名约定:常量通常使用大写字母
    const int DAYS_IN_WEEK = 7;
    const std::string WELCOME_MESSAGE = "Welcome to C++ Programming!";

    std::cout << "Days in a Week: " << DAYS_IN_WEEK << std::endl;
    std::cout << "Welcome Message: " << WELCOME_MESSAGE << std::endl;

    // 尝试修改常量(会导致编译错误)
    // 取消注释下一行以查看错误
    // MAX_USERS = 200;  // 这将导致编译时错误

    return 0;
}

让我们分解常量的定义:

  1. 声明:

    • 在类型前使用 const 关键字
    • 必须在声明时初始化
    • 初始化后无法修改
  2. 最佳实践:

    • 常量名称通常使用大写字母
    • 适用于所有数据类型
    • 有助于防止意外修改

编译并运行程序:

g++ constants.cpp -o constants
./constants

示例输出:

Maximum Users: 100
Value of PI: 3.14159
Grade Separator: -
Days in a Week: 7
Welcome Message: Welcome to C++ Programming!

需要记住的关键点:

  • const 创建不可变变量
  • 常量必须在声明时初始化
  • 使代码更具可读性和安全性
  • 防止对重要值的意外更改

使用布尔变量表示真/假条件

在这一步中,你将学习 C++ 中的布尔变量,它用于表示真(true)或假(false)的值。布尔变量是创建条件逻辑和程序决策的基础。

打开 WebIDE,在 ~/project 目录下创建一个名为 boolean_variables.cpp 的新文件:

touch ~/project/boolean_variables.cpp
#include <iostream>

int main() {
    // 声明布尔变量
    bool isStudent = true;
    bool hasPassedExam = false;

    // 打印布尔值
    std::cout << "Is Student: " << std::boolalpha << isStudent << std::endl;
    std::cout << "Passed Exam: " << hasPassedExam << std::endl;

    // 比较操作,结果为布尔值
    int age = 20;
    bool isAdult = (age >= 18);
    std::cout << "Is Adult: " << isAdult << std::endl;

    // 逻辑操作
    bool hasScholarship = true;
    bool canEnroll = isStudent && isAdult;
    std::cout << "Can Enroll: " << canEnroll << std::endl;

    // 取反操作
    bool isUnemployed = !hasPassedExam;
    std::cout << "Is Unemployed: " << isUnemployed << std::endl;

    // 使用布尔变量的条件语句
    if (isStudent && hasPassedExam) {
        std::cout << "Congratulations! You can proceed to the next level." << std::endl;
    } else {
        std::cout << "You need to improve your academic performance." << std::endl;
    }

    return 0;
}

让我们分解布尔变量:

  1. 声明:

    • 使用 bool 关键字
    • 只能为 truefalse
    • 适用于条件逻辑
  2. 操作:

    • 比较运算符生成布尔结果
    • 逻辑与 &&
    • 逻辑或 ||
    • 取反 !

编译并运行程序:

g++ boolean_variables.cpp -o boolean_variables
./boolean_variables

示例输出:

Is Student: true
Passed Exam: false
Is Adult: true
Can Enroll: true
Is Unemployed: true
You need to improve your academic performance.

需要记住的关键点:

  • 布尔变量表示真/假条件
  • 用于比较和逻辑操作
  • 是程序决策的基础
  • std::boolalpha 打印 "true"/"false" 而不是 1/0

使用 sizeof() 检查不同数据类型的内存大小

在这一步中,你将学习 C++ 中的 sizeof() 运算符,它允许你确定不同数据类型的内存大小。理解内存分配对于高效编程和内存管理至关重要。

打开 WebIDE,在 ~/project 目录下创建一个名为 sizeof_operator.cpp 的新文件:

touch ~/project/sizeof_operator.cpp
#include <iostream>

int main() {
    // 检查整数类型的内存大小
    std::cout << "Integer Types Memory Size:" << std::endl;
    std::cout << "short: " << sizeof(short) << " bytes" << std::endl;
    std::cout << "int: " << sizeof(int) << " bytes" << std::endl;
    std::cout << "long: " << sizeof(long) << " bytes" << std::endl;
    std::cout << "long long: " << sizeof(long long) << " bytes" << std::endl;

    // 检查浮点类型的内存大小
    std::cout << "\nFloating-Point Types Memory Size:" << std::endl;
    std::cout << "float: " << sizeof(float) << " bytes" << std::endl;
    std::cout << "double: " << sizeof(double) << " bytes" << std::endl;
    std::cout << "long double: " << sizeof(long double) << " bytes" << std::endl;

    // 检查字符和布尔类型的内存大小
    std::cout << "\nOther Types Memory Size:" << std::endl;
    std::cout << "char: " << sizeof(char) << " bytes" << std::endl;
    std::cout << "bool: " << sizeof(bool) << " bytes" << std::endl;

    // 检查特定变量的内存大小
    int intVar = 42;
    double doubleVar = 3.14;
    char charVar = 'A';

    std::cout << "\nVariable Memory Size:" << std::endl;
    std::cout << "intVar: " << sizeof(intVar) << " bytes" << std::endl;
    std::cout << "doubleVar: " << sizeof(doubleVar) << " bytes" << std::endl;
    std::cout << "charVar: " << sizeof(charVar) << " bytes" << std::endl;

    return 0;
}

让我们分解 sizeof() 运算符:

  1. 用途:

    • 确定数据类型的内存大小
    • 返回以字节为单位的大小
    • 有助于理解内存分配
  2. 用法:

    • 可用于数据类型
    • 可用于变量
    • 帮助理解内存需求

编译并运行程序:

g++ sizeof_operator.cpp -o sizeof_operator
./sizeof_operator

示例输出:

Integer Types Memory Size:
short: 2 bytes
int: 4 bytes
long: 8 bytes
long long: 8 bytes

Floating-Point Types Memory Size:
float: 4 bytes
double: 8 bytes
long double: 16 bytes

Other Types Memory Size:
char: 1 bytes
bool: 1 bytes

Variable Memory Size:
intVar: 4 bytes
doubleVar: 8 bytes
charVar: 1 bytes

需要记住的关键点:

  • sizeof() 返回以字节为单位的内存大小
  • 内存大小可能因系统而异
  • 有助于理解数据类型的内存需求
  • 适用于低级内存管理

处理整数溢出情况

在这一步中,你将学习整数溢出(Integer Overflow),这种情况发生在计算结果超出整数类型的最大值限制时。理解并防止溢出对于编写健壮且可靠的 C++ 程序至关重要。

打开 WebIDE,在 ~/project 目录下创建一个名为 integer_overflow.cpp 的新文件:

touch ~/project/integer_overflow.cpp
#include <iostream>
#include <limits>

int main() {
    // 演示 short int 的整数溢出
    short smallInt = 32767;  // short 的最大值
    std::cout << "Original Value: " << smallInt << std::endl;

    // 当超过最大值时发生溢出
    smallInt++;
    std::cout << "After Overflow: " << smallInt << std::endl;

    // 使用无符号整数防止负溢出
    unsigned int positiveOnly = 0;
    std::cout << "Unsigned Integer Start: " << positiveOnly << std::endl;

    // 无符号整数递减会导致回绕
    positiveOnly--;
    std::cout << "Unsigned Integer Wrap-around: " << positiveOnly << std::endl;

    // 检查整数限制
    std::cout << "\nInteger Type Limits:" << std::endl;
    std::cout << "Short Max: " << std::numeric_limits<short>::max() << std::endl;
    std::cout << "Short Min: " << std::numeric_limits<short>::min() << std::endl;

    // 安全的递增方法
    try {
        if (smallInt < std::numeric_limits<short>::max()) {
            smallInt++;
            std::cout << "Safe Increment: " << smallInt << std::endl;
        } else {
            std::cout << "Cannot increment further" << std::endl;
        }
    } catch (const std::overflow_error& e) {
        std::cout << "Overflow Error: " << e.what() << std::endl;
    }

    return 0;
}

让我们分解整数溢出:

  1. 溢出特性:

    • 当值超过类型的最大值限制时发生
    • 可能导致意外结果
    • 有符号和无符号类型的行为不同
  2. 预防策略:

    • 在计算前检查限制
    • 使用更大的整数类型
    • 对非负值使用无符号类型
    • 实现范围检查

编译并运行程序:

g++ integer_overflow.cpp -o integer_overflow
./integer_overflow

示例输出:

Original Value: 32767
After Overflow: -32768
Unsigned Integer Start: 0
Unsigned Integer Wrap-around: 4294967295

Integer Type Limits:
Short Max: 32767
Short Min: -32768
Safe Increment: -32767

需要记住的关键点:

  • 整数溢出可能导致意外结果
  • 不同类型有不同的溢出行为
  • 在计算前始终检查值范围
  • 为计算选择合适的数据类型

总结

在本实验中,你学习了 C++ 中的不同数据类型以及如何使用它们。你首先声明了不同大小的整数变量,包括 shortintlong,并探索了它们各自的范围。接下来,你使用带小数点的值初始化了浮点变量,例如 floatdouble。你还学习了如何使用单引号声明和初始化字符变量,以及使用 std::string 类创建字符串变量。此外,你探索了类型转换以在不同数值类型之间进行转换,使用 const 关键字定义常量,并使用布尔变量处理真/假条件。最后,你使用 sizeof() 运算符检查了各种数据类型的内存大小,并处理了整数溢出的情况。

您可能感兴趣的其他 C++ 教程