源滚滚Rust全栈班v1.02 整数类型初探

🦀 深入学习 Rust 中的有符号整数类型：i8, i16, i32, i64

📖 项目概述

本项目是 Rust 基础数据类型实战 Cookbook 的第一个案例，专门介绍 Rust 中的有符号整数类型。通过详细的示例代码和中文注释，帮助初学者全面理解整数类型的基本概念和实际应用。

🎯 学习目标

通过本项目，你将学会：

1. 理解整数类型的基本概念：掌握 i8、i16、i32、i64 四种有符号整数类型的特点
2. 掌握内存占用和数值范围：了解每种类型的存储大小和能表示的数值范围
3. 学会类型声明和赋值：掌握显式类型注解和类型推断的使用方法
4. 了解实际应用场景：学习在什么情况下选择合适的整数类型
5. 掌握数字字面量：学会使用十进制、十六进制、八进制、二进制表示数字
6. 理解基本数学运算：掌握整数的加减乘除和取余运算

📊 整数类型一览表

🚀 快速开始

运行项目

# 进入项目目录
cd c01_hello_integers

# 运行程序
cargo run

预期输出

程序将展示六个部分的内容：

1. 基本整数类型声明 - 展示各类型的变量声明和内存占用
2. 类型推断与默认类型 - 演示 Rust 的类型推断机制
3. 整数类型的范围展示 - 显示各类型的最小值和最大值
4. 实际应用场景 - 展示每种类型的典型使用场景
5. 数字字面量的表示方法 - 演示不同进制的数字表示
6. 基本数学运算 - 展示整数的基本运算操作

💡 核心知识点

1. 类型选择原则

• i32：默认选择，适合大多数场景
• i8：节省内存，适合小范围数值
• i16：中等范围，平衡性能和内存
• i64：大数值计算，高精度要求

2. 类型注解方式

// 显式类型注解
let age: i8 = 25;

// 类型推断（默认 i32）
let count = 100;

// 后缀指定类型
let big_number = 1000000000i64;

3. 数字字面量

let decimal = 1000;        // 十进制
let hex = 0xff;           // 十六进制
let octal = 0o77;         // 八进制  
let binary = 0b1111_0000; // 二进制

🔧 代码结构

c01_hello_integers/
├── Cargo.toml          # 项目配置文件
├── README.md           # 项目文档（本文件）
└── src/
    └── main.rs         # 主程序文件（包含详细注释）

cargo.toml

[package]
name = "c01_hello_integers"
version = "0.1.0"
edition = "2021"
authors = ["Rust学习者"]
description = "整数类型初探：深入学习Rust中的i8, i16, i32, i64整数类型"

[dependencies]

src/main.rs

/*
 * Rust 整数类型初探 - i8, i16, i32, i64
 * 
 * 本程序详细介绍了Rust中的有符号整数类型，包括：
 * - i8:  8位有符号整数  （-128 到 127）
 * - i16: 16位有符号整数 （-32,768 到 32,767）  
 * - i32: 32位有符号整数 （-2,147,483,648 到 2,147,483,647）
 * - i64: 64位有符号整数 （-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807）
 * 
 * 学习目标：
 * 1. 理解不同整数类型的存储大小和范围
 * 2. 掌握整数变量的声明和赋值
 * 3. 了解类型推断和显式类型注解
 * 4. 学习各种整数类型的实际应用场景
 */

fn main() {
    println!("🦀 欢迎学习 Rust 整数类型！");
    println!("{}", "=".repeat(50));
    
    // ===== 第一部分：基本整数类型声明 =====
    println!("\n📌 第一部分：基本整数类型声明");
    
    // i8: 8位有符号整数，占用1个字节
    // 范围：-128 到 127
    let small_number: i8 = 42;
    let negative_small: i8 = -100;
    
    println!("i8 类型示例：");
    println!("  正数: {} (占用 {} 字节)", small_number, std::mem::size_of::<i8>());
    println!("  负数: {} (占用 {} 字节)", negative_small, std::mem::size_of::<i8>());
    
    // i16: 16位有符号整数，占用2个字节  
    // 范围：-32,768 到 32,767
    let medium_number: i16 = 30000;
    let negative_medium: i16 = -25000;
    
    println!("\ni16 类型示例：");
    println!("  正数: {} (占用 {} 字节)", medium_number, std::mem::size_of::<i16>());
    println!("  负数: {} (占用 {} 字节)", negative_medium, std::mem::size_of::<i16>());
    
    // i32: 32位有符号整数，占用4个字节
    // 这是Rust中整数的默认类型！
    // 范围：-2,147,483,648 到 2,147,483,647
    let large_number: i32 = 2_000_000;  // 可以用下划线分隔数字，增强可读性
    let negative_large: i32 = -1_500_000;
    
    println!("\ni32 类型示例（默认整数类型）：");
    println!("  正数: {} (占用 {} 字节)", large_number, std::mem::size_of::<i32>());
    println!("  负数: {} (占用 {} 字节)", negative_large, std::mem::size_of::<i32>());
    
    // i64: 64位有符号整数，占用8个字节
    // 范围：-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
    let huge_number: i64 = 9_000_000_000_000;
    let negative_huge: i64 = -5_000_000_000_000;
    
    println!("\ni64 类型示例：");
    println!("  正数: {} (占用 {} 字节)", huge_number, std::mem::size_of::<i64>());
    println!("  负数: {} (占用 {} 字节)", negative_huge, std::mem::size_of::<i64>());
    
    // ===== 第二部分：类型推断与默认类型 =====
    println!("\n📌 第二部分：类型推断与默认类型");
    
    // Rust 可以自动推断类型
    let auto_inferred = 100;  // 默认推断为 i32 类型
    println!("自动推断的整数类型: {} (默认为 i32，占用 {} 字节)", 
             auto_inferred, std::mem::size_of_val(&auto_inferred));
    
    // 可以通过后缀明确指定类型
    let explicit_i8 = 50i8;
    let explicit_i16 = 1000i16; 
    let explicit_i32 = 100000i32;
    let explicit_i64 = 10000000000i64;
    
    println!("\n使用后缀明确指定类型：");
    println!("  50i8 = {}", explicit_i8);
    println!("  1000i16 = {}", explicit_i16);
    println!("  100000i32 = {}", explicit_i32);
    println!("  10000000000i64 = {}", explicit_i64);
    
    // ===== 第三部分：整数类型的范围展示 =====
    println!("\n📌 第三部分：各整数类型的数值范围");
    
    println!("i8  范围: {} 到 {}", i8::MIN, i8::MAX);
    println!("i16 范围: {} 到 {}", i16::MIN, i16::MAX);
    println!("i32 范围: {} 到 {}", i32::MIN, i32::MAX);
    println!("i64 范围: {} 到 {}", i64::MIN, i64::MAX);
    
    // ===== 第四部分：实际应用场景 =====
    println!("\n📌 第四部分：实际应用场景");
    
    // i8: 适用于小范围数值，如年龄、评分等
    let age: i8 = 25;
    let temperature: i8 = -10;  // 摄氏温度
    println!("i8 应用场景 - 年龄: {}岁, 温度: {}°C", age, temperature);
    
    // i16: 适用于中等范围，如端口号、小型计数器
    let port: i16 = 8080;
    let altitude: i16 = 2500;  // 海拔高度（米）
    println!("i16 应用场景 - 端口号: {}, 海拔: {}米", port, altitude);
    
    // i32: 最常用的整数类型，适用于大多数情况
    let population: i32 = 1_400_000_000;  // 人口数量
    let distance: i32 = 384_400;  // 地球到月球距离（千米）
    println!("i32 应用场景 - 人口: {}, 地月距离: {}千米", population, distance);
    
    // i64: 适用于非常大的数值，如时间戳、大数据计算
    let timestamp: i64 = 1694000000;  // Unix时间戳
    let national_debt: i64 = 31_000_000_000_000;  // 国债（美元）
    println!("i64 应用场景 - 时间戳: {}, 国债: {}美元", timestamp, national_debt);
    
    // ===== 第五部分：数字字面量的不同写法 =====
    println!("\n📌 第五部分：数字字面量的表示方法");
    
    let decimal = 1000;        // 十进制
    let hex = 0xff;           // 十六进制（255）
    let octal = 0o77;         // 八进制（63）
    let binary = 0b1111_0000; // 二进制（240）
    
    println!("不同进制的表示：");
    println!("  十进制: {}", decimal);
    println!("  十六进制 0xff: {}", hex);
    println!("  八进制 0o77: {}", octal);
    println!("  二进制 0b1111_0000: {}", binary);
    
    // ===== 第六部分：简单的数学运算 =====
    println!("\n📌 第六部分：基本数学运算");
    
    let a: i32 = 10;
    let b: i32 = 3;
    
    println!("数学运算示例 (a = {}, b = {})：", a, b);
    println!("  加法: {} + {} = {}", a, b, a + b);
    println!("  减法: {} - {} = {}", a, b, a - b);
    println!("  乘法: {} * {} = {}", a, b, a * b);
    println!("  除法: {} / {} = {}", a, b, a / b);  // 整数除法，结果为3
    println!("  取余: {} % {} = {}", a, b, a % b);
    
    // ===== 总结 =====
    println!("\n🎯 学习总结：");
    println!("1. Rust 提供了4种有符号整数类型：i8, i16, i32, i64");
    println!("2. i32 是默认的整数类型，适合大多数场景");
    println!("3. 选择合适的类型可以优化内存使用");
    println!("4. 可以使用下划线分隔数字增强可读性");
    println!("5. 支持十进制、十六进制、八进制、二进制字面量");
    
    println!("\n🚀 恭喜！你已经掌握了 Rust 整数类型的基础知识！");
}

📚 扩展学习

学完本项目后，建议继续学习：

• c02_unsigned_integers - 无符号整数类型
• c03_integer_literals - 整数字面量深入
• c04_integer_operations - 整数运算详解
• c05_integer_conversion - 整数类型转换

❓ 常见问题

Q: 为什么 Rust 有这么多整数类型？
A: 不同类型占用不同的内存空间，可以根据实际需求选择合适的类型来优化性能和内存使用。

Q: 什么时候使用 i64 而不是 i32？
A: 当需要存储超过 i32 范围的大数值时，如时间戳、大数据计算等场景。

Q: 可以在运行时改变变量的类型吗？
A: 不可以。Rust 是静态类型语言，变量的类型在编译时确定，运行时不能改变。

🤝 贡献

欢迎提交 Issue 和 Pull Request 来完善这个学习项目！

📄 许可证

MIT License