主页 / user-5923666

Raz Luvaton's questions

Martin Hope
Raz Luvaton
Asked: 2024-09-03 02:18:21 +0800 CST
  • 5

如何使用在编译时已知大小的泛型Sized作为基于其大小的结构数组长度

我有以下错误：

error: generic parameters may not be used in const operations
 --> src/lib.rs:4:43
  |
4 |     arr: [Key; 1024 / std::mem::size_of::<Key>()]
  |                                           ^^^ cannot perform const operation using `Key`
  |
  = note: type parameters may not be used in const expressions

对于以下代码

Rust 游乐场

type SomeKey = u64;

// This does not work
struct NotWorking<Key: Sized> {
    arr: [Key; 1024 / std::mem::size_of::<Key>()]
}

struct Working {
    arr: [SomeKey; 1024 / std::mem::size_of::<SomeKey>()]
}
generics
Martin Hope
Raz Luvaton
Asked: 2024-08-09 02:32:51 +0800 CST
  • 5

我有一个带函数的结构remove，并且我希望remove函数在实际删除时返回新实例或相同的引用

但我Cannot move尝试的时候return *self

是否可以？

从错误来看我不这么认为，但是怎么Cow可能呢？

代码：

use std::collections::HashMap;

#[derive(Clone)]
struct Something {
    data: HashMap<char, u16>,
}

impl Something {
    fn new() -> Self {
        return Something {
            data: HashMap::new()
        }
    }

    fn get(&self, c: char) -> Option<&u16> {

        return self.data.get(&c);
    }

    fn add(&self, c: char, value: u16) -> Self {
        let mut n = self.clone();

        n.data.insert(c, value);

        return n;
    }

    fn remove(&self, c: char) -> Self {
        if !self.data.contains_key(&c) {
            return *self; // <-- error[E0507]: cannot move out of `*self` which is behind a shared reference
        }

        let mut n = self.clone();
        n.data.remove(&c);

        return n;
    }
}

fn main() {
    let s = Something::new();

    let s = s.add('a', 1);
    let s = s.add('b', 2);

    let s = s.remove('a');

    // Should return the same instance as c is missing
    let s = s.remove('c');
}

但是如果我将remove函数改为返回&Self，那么我就无法返回对函数中声明的变量的引用：

    fn remove(&self, c: char) -> &Self {
        if !self.data.contains_key(&c) {
            return self;
        }

        let mut n = self.clone();
        n.data.remove(&c);

        return &n;  // <--- error[E0515]: cannot return reference to local variable `n`
    }

我知道我可以避免借用something但我不想转移所有权：

    // <--- self and not &self
    fn remove(self, c: char) -> Self {
        if !self.data.contains_key(&c) {
            return self;  
        }

        let mut n = self.clone();
        n.data.remove(&c);

        return n;
    }

因为接下来的操作将会失败：

fn main() {
    let s = Something::new();

    let s = s.add('a', 1);
    let s = s.add('b', 2);

    let s1 = s.remove('a');
    let s2 = s.remove('a'); // <-- error[E0382]: use of moved value: `s`
}
rust