Rust中如何高效存储含非f64类型的大型Vec<f64>？

针对你提到的枚举实现会额外占用8字节标签导致空间浪费的问题，这里有两种更高效的方案，适用于不同场景：

方案一：分离存储（推荐，实现简单） #

把正常的f64数据和非数值数据分开存储，用索引映射对应关系。这种方式下，绝大多数元素还是保持8字节的f64，只有少数非数值数据额外存在哈希表中，大幅节省空间。

代码示例 #

use std::collections::HashMap;

// 定义非数值类型，根据你的需求扩展
enum NonNumber {
    String(String),
    Bool(bool),
    CustomData(Vec<u8>),
}

struct MixedNumberStore {
    numbers: Vec<f64>,
    non_number_map: HashMap<usize, NonNumber>,
}

impl MixedNumberStore {
    // 获取指定位置的值：成功返回f64，失败返回非数值数据
    fn get(&self, index: usize) -> Result<&f64, &NonNumber> {
        self.non_number_map
            .get(&index)
            .map(Err)
            .unwrap_or_else(|| Ok(&self.numbers[index]))
    }

    // 设置指定位置的值，自动处理数值和非数值的存储
    fn set(&mut self, index: usize, value: impl Into<MixedValue>) {
        let value = value.into();
        match value {
            MixedValue::Number(f) => {
                self.non_number_map.remove(&index);
                // 若索引超出当前长度，扩容并填充默认值（可根据需求调整）
                if index >= self.numbers.len() {
                    self.numbers.resize(index + 1, 0.0);
                }
                self.numbers[index] = f;
            }
            MixedValue::NonNumber(nn) => {
                if index >= self.numbers.len() {
                    self.numbers.resize(index + 1, 0.0);
                }
                self.non_number_map.insert(index, nn);
            }
        }
    }
}

// 辅助枚举，用于统一数值和非数值的输入类型
enum MixedValue {
    Number(f64),
    NonNumber(NonNumber),
}

impl From<f64> for MixedValue {
    fn from(f: f64) -> Self {
        MixedValue::Number(f)
    }
}

impl From<NonNumber> for MixedValue {
    fn from(nn: NonNumber) -> Self {
        MixedValue::NonNumber(nn)
    }
}

优缺点 #

• 优点：逻辑清晰，实现简单，访问开销仅为哈希表的平均O(1)查询，适合非数值数据占比低的场景。
• 缺点：需要维护两个数据结构，插入/删除时要同步处理；若索引跨度大，numbers会存在填充的默认值，可能浪费少量空间。

方案二：复用f64的NaN位（极致空间优化） #

f64的NaN值有大量未使用的位（指数位全1，尾数不全0），可以把非数值数据的唯一标识存在NaN的尾数中，再用全局存储映射标识到具体的非数值数据。这种方式下，所有元素都保持8字节，完全无额外空间开销。

代码示例 #

use std::collections::HashMap;
use std::sync::Mutex;

enum NonNumber {
    String(String),
    Bool(bool),
}

// 全局存储非数值数据，用Mutex保证线程安全
static NON_NUMBER_STORAGE: Mutex<HashMap<u64, NonNumber>> = Mutex::new(HashMap::new());
// 生成唯一ID的计数器（单线程场景可去掉Mutex简化实现）
static mut NEXT_ID: u64 = 0;

fn generate_id() -> u64 {
    unsafe {
        let id = NEXT_ID;
        NEXT_ID += 1;
        id
    }
}

// 将非数值数据转换为特殊标记的NaN
fn non_number_to_f64(nn: NonNumber) -> f64 {
    let id = generate_id();
    NON_NUMBER_STORAGE.lock().unwrap().insert(id, nn);
    // 构造特殊NaN：指数位全1，尾数低48位存ID（f64尾数共52位，足够容纳ID）
    let nan_base = 0x7FF0000000000000u64;
    let bits = nan_base | (id & 0xFFFFFFFFFFFF);
    f64::from_bits(bits)
}

// 将f64转换为可能的数值或非数值数据
fn parse_f64(f: f64) -> Result<f64, &'static NonNumber> {
    let bits = f.to_bits();
    // 判断是否是我们标记的特殊NaN
    if (bits & 0x7FF0000000000000) == 0x7FF0000000000000 {
        let id = bits & 0xFFFFFFFFFFFF;
        match NON_NUMBER_STORAGE.lock().unwrap().get(&id) {
            Some(nn) => Err(nn),
            None => Ok(f), // 普通NaN，按数值处理（可根据需求调整）
        }
    } else {
        Ok(f)
    }
}

优缺点 #

• 优点：完全无额外空间开销，所有元素都是8字节，适合对空间要求极高的场景。
• 缺点：实现复杂，需要处理NaN的位编码；全局存储存在线程安全开销；无法区分普通NaN和自定义标记的NaN（若业务中需要保留普通NaN，需调整位编码规则）。

内容的提问来源于stack exchange，提问作者Test