Rust数组操作库array-concat的使用，高效合并数组与简化集合操作

Rust数组操作库array-concat的使用，高效合并数组与简化集合操作

Current Crates.io Version docs-rs

介绍

array-concat 是一个用于数组拼接和分割的Rust宏库。

在Cargo.toml中添加依赖：

array-concat = "0.5.5"

示例

use array_concat::*;

const A: [u32; 3] = [1, 2, 3];
const B: [u32; 2] = [4, 5];
const C: [u32; concat_arrays_size!(A, B)] = concat_arrays!(A, B);

// Non-Copy struct
#[derive(Debug, PartialEq)]
struct S(bool);
const D: [S; 1] = [S(true)];
const E: [S; 1] = [S(false)];
const F: [S; concat_arrays_size!(D, E)] = concat_arrays!(D, E);

fn main() {
    let c = concat_arrays!(A, B);
    assert_eq!([1, 2, 3, 4, 5], C);
    assert_eq!([1, 2, 3, 4, 5], c);
    assert_eq!([S(true), S(false)], F);

    // Split the array into three parts with lengths: 1, 3, and 1
    assert_eq!(([1], [2, 3, 4], [5]), split_array!(c, 1, 3, 1));

    let a = [1, 2, 3];
    let b = [4, 5];
    let c = concat_arrays!(a, b); // Size is inferred by the assert below
    assert_eq!([1, 2, 3, 4, 5], c);
}

完整示例代码

// 引入array-concat库
use array_concat::*;

fn main() {
    // 示例1: 合并基本类型数组
    let arr1 = [1, 2, 3];
    let arr2 = [4, 5];
    let combined = concat_arrays!(arr1, arr2);
    println!("Combined array: {:?}", combined); // 输出: [1, 2, 3, 4, 5]

    // 示例2: 合并自定义结构体数组
    #[derive(Debug)]
    struct Point {
        x: i32,
        y: i32,
    }
    
    let points1 = [Point { x: 1, y: 2 }];
    let points2 = [Point { x: 3, y: 4 }];
    let all_points = concat_arrays!(points1, points2);
    println!("All points: {:?}", all_points); // 输出: [Point { x: 1, y: 2 }, Point { x: 3, y: 4 }]

    // 示例3: 分割数组
    let large_array = [1, 2, 3, 4, 5, 6, 7, 8];
    let (first, middle, last) = split_array!(large_array, 2, 4, 2);
    println!("First: {:?}", first);   // 输出: [1, 2]
    println!("Middle: {:?}", middle); // 输出: [3, 4, 5, 6]
    println!("Last: {:?}", last);     // 输出: [7, 8]

    // 示例4: 编译时数组合并
    const NUMBERS: [i32; 5] = concat_arrays!([1, 2], [3, 4, 5]);
    println!("Const array: {:?}", NUMBERS); // 输出: [1, 2, 3, 4, 5]
}

特性

  1. 数组合并：使用concat_arrays!宏可以轻松合并多个数组
  2. 数组分割：使用split_array!宏可以将数组分割为多个部分
  3. 编译时支持：可以在const上下文中使用
  4. 非Copy类型支持：支持合并自定义结构体等非Copy类型
  5. 大小推断：提供concat_arrays_size!宏用于计算合并后数组的大小

array-concat库特别适合需要高效处理数组合并和分割的场景，它提供了简洁的宏语法来简化这些常见操作。


1 回复

Rust数组操作库array-concat的使用：高效合并数组与简化集合操作

array-concat是Rust中一个专注于数组操作的实用库，特别适合需要高效合并数组或进行集合操作的场景。它提供了比标准库更简洁的API来处理数组连接操作。

安装

在Cargo.toml中添加依赖：

[dependencies]
array-concat = "0.1"

主要功能

1. 合并数组

use array_concat::concat;

fn main() {
    let arr1 = [1, 2, 3];
    let arr2 = [4, 5, 6];
    let combined = concat!(arr1, arr2);
    
    assert_eq!(combined, [1, 2, 3, 4, 5, 6]);
}

2. 合并多个数组

use array_concat::concat;

fn main() {
    let arr1 = [1, 2];
    let arr2 = [3, 4];
    let arr3 = [5, 6];
    let combined = concat!(arr1, arr2, arr3);
    
    assert_eq!(combined, [1, 2, 3, 4, 5, 6]);
}

3. 数组扁平化

use array_concat::concat_arrays;

fn main() {
    let arrays = [[1, 2], [3, 4], [5, 6]];
    let flattened = concat_arrays!(arrays);
    
    assert_eq!(flattened, [1, 2, 3, 4, 5, 6]);
}

4. 集合操作（去重合并）

use array_concat::concat_uniq;

fn main() {
    let arr1 = [1, 2, 3];
    let arr2 = [3, 4, 5];
    let unique_combined = concat_uniq!(arr1, arr2);
    
    assert_eq!(unique_combined, [1, 2, 3, 4, 5]);
}

性能特点

array-concat在编译时确定数组大小，避免了动态分配的开销：

  • 所有操作都是零成本抽象
  • 结果数组大小在编译时确定
  • 无运行时检查或panic

高级用法

合并不同类型数组（需实现From trait）

use array_concat::concat;

fn main() {
    let arr1 = [1u8, 2, 3];
    let arr2 = [4u16, 5, 6];
    let combined: [u16; 6] = concat!(arr1, arr2);
    
    assert_eq!(combined, [1, 2, 3, 4, 5, 6]);
}

与const fn结合使用

use array_concat::concat;

const fn create_array() -> [i32; 6] {
    concat!([1, 2, 3], [4, 5, 6])
}

fn main() {
    const ARR: [i32; 6] = create_array();
    assert_eq!(ARR, [1, 2, 3, 4, 5, 6]);
}

完整示例DEMO

下面是一个综合使用array-concat各种功能的完整示例：

// 引入array-concat库的所有宏
use array_concat::{concat, concat_arrays, concat_uniq};

fn main() {
    // 示例1: 基本数组合并
    let numbers1 = [1, 2, 3];
    let numbers2 = [4, 5, 6];
    let merged_numbers = concat!(numbers1, numbers2);
    println!("合并后的数组: {:?}", merged_numbers); // [1, 2, 3, 4, 5, 6]

    // 示例2: 多数组扁平化
    let nested_arrays = [[1, 2], [3, 4], [5, 6]];
    let flat_array = concat_arrays!(nested_arrays);
    println!("扁平化后的数组: {:?}", flat_array); // [1, 2, 3, 4, 5, 6]

    // 示例3: 去重合并
    let set1 = [1, 2, 3, 3];
    let set2 = [3, 4, 5];
    let unique_set = concat_uniq!(set1, set2);
    println!("去重合并后的数组: {:?}", unique_set); // [1, 2, 3, 4, 5]

    // 示例4: 混合类型合并(需要From trait支持)
    let u8_array = [1u8, 2, 3];
    let u16_array = [4u16, 5, 6];
    let mixed_array: [u16; 6] = concat!(u8_array, u16_array);
    println!("混合类型合并: {:?}", mixed_array); // [1, 2, 3, 4, 5, 6]

    // 示例5: 在常量上下文中使用
    const COMBINED: [i32; 6] = concat!([1, 2, 3], [4, 5, 6]);
    println!("常量合并数组: {:?}", COMBINED); // [1, 2, 3, 4, 5, 6]
}

array-concat是处理固定大小数组连接的理想选择，特别适合嵌入式开发或性能敏感场景。

回到顶部