Question

在Rust社区的慷慨帮助下，我设法获得了使用托管指针组装的拓扑数据结构的基础。这很好地结合在一起，我对Rust一般感到非常兴奋。然后我读了这个post（这似乎是一个合理的计划），它激励我回溯并尝试使用自有指针重新组装它，如果可能的话。

这是使用托管指针的工作版本：

struct Dart<T> {
    alpha: ~[@mut Dart<T>],
    embed: ~[@mut T],
   tagged: bool
}

impl<T> Dart<T> {
    pub fn new(dim: uint) -> @mut Dart<T> {
        let mut dart = @mut Dart{alpha: ~[], embed: ~[], tagged: false};        
        dart.alpha = vec::from_elem(dim, dart);              
        return dart;
    }
    pub fn get_dim(&self) -> uint {
        return self.alpha.len();
    }   
    pub fn traverse(@mut self, invs: &[uint], f: &fn(&Dart<T>)) {
        let dim = self.get_dim();
        for invs.each |i| {if *i >= dim {return}}; //test bounds on invs vec
        if invs.len() == 2 {
            let spread:int = int::abs(invs[1] as int - invs[0] as int);
            if spread == 1 { //simple loop
                let mut dart = self;
                let mut i = invs[0];
                while !dart.tagged {
                    dart.tagged = true; 
                    f(dart);
                    dart = dart.alpha[i];
                    if i == invs[0] {i = invs[1];}
                    else {i == invs[0];}
            }   }           
            // else if spread == 2 { // max 4 cells traversed

            // }
        }
        else {
            let mut stack = ~[self];
            self.tagged = true;     
            while !stack.is_empty() {
                let mut dart = stack.pop();
                f(dart);  
                for invs.each |i| {
                    if !dart.alpha[*i].tagged {
                        dart.alpha[*i].tagged = true;
                        stack.push(dart);
}   }   }   }   }   }

经过几个小时的追逐终生错误后，我得出的结论是，由于循环性质，这可能甚至不可能由于拥有指针（没有像我warned那样打结）。我对此的微弱尝试如下。我的问题是，这种结构是否可以在不借助托管指针的情况下实现？如果没有，上面的代码是否被认为是“生锈的”？（惯用的锈）。谢谢。

struct GMap<'self,T> {
    dim: uint,
    darts: ~[~Dart<'self,T>]
}   

struct Dart<'self,T> { 
    alpha: ~[&'self mut Dart<'self, T>], 
    embed: ~[&'self mut T], 
    tagged: bool 
}

impl<'self, T> GMap<'self, T> {
    pub fn new_dart(&'self mut self) {
        let mut dart = ~Dart{alpha: ~[], embed: ~[], tagged: false};
        let dartRef: &'self mut Dart<'self, T> = dart;  
        dartRef.alpha = vec::from_elem(self.dim, copy dartRef);
        self.darts.push(dart);              
    }
}

Answer 1

我很确定使用&mut指针是不可能的，因为一次只能存在一个这样的指针，例如：

fn main() {
    let mut i = 0;
    let a = &mut i;
    let b = &mut i;
}

and-mut.rs:4:12: 4:18 error: cannot borrow `i` as mutable more than once at at a time
and-mut.rs:4     let b = &mut i;
                         ^~~~~~
and-mut.rs:3:12: 3:18 note: second borrow of `i` as mutable occurs here
and-mut.rs:3     let a = &mut i;
                         ^~~~~~
error: aborting due to previous error

通过将不安全指针存储到内存（ptr::to_mut_unsafe_ptr）或将索引存储到darts成员GMap中，可以不安全地绕过借用检查器。基本上，将单个引用存储到内存中（在self.darts中）并且所有操作都必须通过它。

这可能如下所示：

impl<'self, T> GMap<'self, T> {
    pub fn new_dart(&'self mut self) {
        let ind = self.darts.len();
        self.darts.push(~Dart{alpha: vec::from_elem(self.dim, ind), embed: ~[], tagged: false});
    }
}

traverse需要更改为GMap上的方法（例如fn(&mut self, node_ind: uint, invs: &[uint], f: &fn(&Dart<T>))），或至少采用GMap类型。

（在完全不同的注释上，有external iterators的库支持，它比内部迭代器（采用闭包的那些）更具组合性。 traverse的这些可能（或可能不会）更好地使用它。）

图形结构中的拥有指针

1 个答案: