元组 Tuple 定义 ​

什么是元组 ​

元组(Tuple)是 Rust 中把多个不同类型的值组合成一个复合类型的方式。元组有固定的长度——一旦声明,里面有几个元素就是几个,不能增加也不能减少。元组中每个位置的元素可以是不同的类型,这是它和数组最大的区别。

元组用小括号 () 包裹,元素之间用逗号分隔。

rust
fn main() {
    // 一个包含三个不同类型元素的元组
    // 类型是 (i32, f64, &str)
    let person = (25, 175.5, "张三");
    println!("{:?}", person);  // (25, 175.5, "张三")

    // 显式标注类型
    let point: (f64, f64) = (3.5, 7.2);
    println!("{:?}", point);

    // 元组可以包含各种类型
    let mixed: (i32, bool, char, String) = (
        42,
        true,
        'R',
        String::from("hello"),
    );
    println!("{:?}", mixed);
}

元组的类型 ​

元组的类型由其中每个元素的类型和顺序共同决定。(i32, f64) 和 (f64, i32) 是不同的类型,即使元素类型相同但顺序不同也不行。

rust
fn main() {
    let a: (i32, f64) = (1, 2.0);
    let b: (f64, i32) = (2.0, 1);

    // a 和 b 的类型不同,不能互相赋值
    // let c: (i32, f64) = b;  // 编译错误:expected (i32, f64), found (f64, i32)

    // 元素个数不同也是不同类型
    let d: (i32, i32) = (1, 2);
    let e: (i32, i32, i32) = (1, 2, 3);
    // d 和 e 的类型不同

    println!("{:?}, {:?}, {:?}, {:?}", a, b, d, e);
}

创建元组的方式 ​

rust
fn main() {
    // 方式一:直接用字面量
    let t1 = (1, 2.0, "hello");

    // 方式二:带类型标注
    let t2: (u8, u8, u8) = (255, 128, 0);  // RGB 颜色值

    // 方式三:从函数返回
    fn get_user() -> (String, u32) {
        (String::from("张三"), 25)
    }
    let t3 = get_user();

    // 方式四:单元素元组(注意末尾逗号)
    let t4 = (42,);     // 这是一个元组,类型是 (i32,)
    let t5 = (42);      // 这不是元组!这只是一个带括号的 i32
    println!("单元素元组:{:?}", t4);   // (42,)
    println!("不是元组:{}", t5);        // 42

    // 方式五:嵌套元组
    let nested = ((1, 2), (3, 4));
    println!("嵌套元组:{:?}", nested);

    println!("{:?}, {:?}, {:?}", t1, t2, t3);
}

元组的大小限制 ​

Rust 的元组在理论上没有严格的元素个数上限,但标准库为最多 12 个元素的元组实现了 Debug、Clone、PartialEq 等常用 trait。超过 12 个元素的元组不能直接用 {:?} 打印。实际代码中,如果元组超过 3-4 个元素,通常应该改用结构体来提高可读性。

rust
fn main() {
    // 12 个元素的元组可以正常打印
    let big = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
    println!("{:?}", big);

    // 超过 12 个就不能用 {:?} 了
    // let too_big = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);
    // println!("{:?}", too_big);  // 编译错误:没有实现 Debug

    // 元素多了应该用结构体替代
    // 这样每个字段都有名字,更容易理解
}

基本示例 ​

用元组从函数返回多个值:

rust
// 计算一组数字的统计信息
// 返回元组包含:(最小值, 最大值, 平均值)
fn statistics(data: &[f64]) -> (f64, f64, f64) {
    if data.is_empty() {
        return (0.0, 0.0, 0.0);
    }

    let mut min = data[0];
    let mut max = data[0];
    let mut sum = 0.0;

    for &val in data {
        if val < min { min = val; }
        if val > max { max = val; }
        sum += val;
    }

    let avg = sum / data.len() as f64;
    (min, max, avg)
}

fn main() {
    let scores = [85.5, 92.0, 78.3, 95.7, 88.1];
    let (min, max, avg) = statistics(&scores);
    println!("最低分:{:.1}", min);
    println!("最高分:{:.1}", max);
    println!("平均分:{:.1}", avg);
}

常见问题 ​

问题一:元组和数组有什么区别?

对比项元组 Tuple数组 Array
元素类型可以不同必须相同
长度编译期固定编译期固定
访问方式.0、.1 索引或解构[0]、[1] 索引
类型表示(T1, T2, T3)[T; N]
遍历不能直接遍历可以用 for 遍历
适用场景返回多个不同类型的值存储一组相同类型的值

问题二:什么时候用元组,什么时候用结构体?

元组适合临时组合少量值的场景,比如函数返回多个值。如果这组值有明确的业务含义(比如"用户"有名字和年龄),或者元素超过 3 个,用结构体更好——每个字段都有名字,代码可读性更高。

问题三:元组可以修改吗?

声明为 mut 的元组可以修改元素值,但不能改变元素的类型。

rust
fn main() {
    let mut pair = (1, 2);
    pair.0 = 10;
    pair.1 = 20;
    println!("{:?}", pair);  // (10, 20)
}

适用场景 ​

  • 函数返回多个值:比如同时返回结果和状态码
  • 临时分组:需要把几个值捆在一起传递,但不值得为此定义一个结构体
  • 模式匹配的中间结果:在 match 或 if let 中解构多个值
  • HashMap 的复合键:HashMap<(i32, i32), String> 用坐标作为键
  • 交换两个变量的值:let (a, b) = (b, a);

注意事项 ​

  • 单元素元组需要在元素后面加逗号:(42,) 是元组,(42) 只是带括号的数字
  • 元组超过 12 个元素时很多标准 trait 不可用,实际上不建议超过 3-4 个
  • 元组不能被 for 循环遍历,因为每个元素类型可能不同
  • 元组的元素只能通过数字索引或解构访问,没有名字
  • 空元组 () 是一个特殊类型,叫单元类型(Unit Type),下一节会详细介绍
  • 元组实现 Copy 的前提是所有元素都实现了 Copy

总结 ​

元组是 Rust 中把多个不同类型的值组合成一个值的基本方式。它用小括号创建,长度固定,每个位置的类型可以不同。元组最常见的用途是函数返回多个值和临时组合少量数据。元素通过 .0、.1 等数字索引访问,或者通过解构绑定到变量上。如果需要组合的值超过 3-4 个,或者这组值有明确的业务含义,应该用结构体代替元组。