Wie kann ich ein Array mit einer Funktion initialisieren?

Question

Ich möchte ein Array von 10 leere Vektoren in Rust erstellen, aber [Vec::new(); 10] funktioniert nicht, da VecCopy nicht implementiert. Wie kann ich das tun, und allgemein gesagt, wie kann ich ein Array durch wiederholtes Aufrufen einer Funktion initialisieren?

Answer 1

Das ist wirklich eine interessante Frage.

Die einzige sichere Lösung, die ich denken kann, ist ein Makro wie dieser

Ich sehe zwei mögliche Ansätze

Erste

Eine einfache Lösung Makro

macro_rules! array { 
    ($v: expr; 1) => ([$v]); 
    ($v: expr; 2) => ([$v, $v]); 
    ($v: expr; 3) => ([$v, $v, $v]); 
    ($v: expr; 4) => ([$v, $v, $v, $v]); 
    ($v: expr; 5) => ([$v, $v, $v, $v, $v]); 
    // until 32 
} 

let a = array![Vec::new(); 3]; 

Es ist ein bisschen ausführlich, aber auch die standard lib verwenden diese Art von Konstrukt.

Zweite

Nach einem Zusammenhang zwischen dieser Frage zu realisieren und other, die ich vorher geantwortet hatte, ich diese Lösung nodrop

extern crate nodrop; 

macro_rules! array { 
    ($e: expr; $n:expr) => (
     { 
      use std::mem; 
      use std::ptr; 
      use nodrop::NoDrop; 

      struct ArrayBuilder<T> { 
       len: usize, 
       data: *mut T, 
      } 

      impl<T> Drop for ArrayBuilder<T> { 
       fn drop(&mut self) { 
        unsafe { 
         while self.len > 0 { 
          let offset = (self.len as isize) - 1; 
          self.len -= 1; 
          ptr::drop_in_place(self.data.offset(offset)); 
         } 
        } 
       } 
      } 

      let mut v: NoDrop<[_; $n]> = NoDrop::new(unsafe { 
       mem::uninitialized() 
      }); 
      // helps type inference for v 
      if false { v[0] = $e; } 
      let mut builder = ArrayBuilder { 
       len: 0, 
       data: (&mut *v as *mut _) as *mut _ 
      }; 
      unsafe { 
       for i in 0..$n { 
        ptr::write(builder.data.offset(i as isize), $e); 
        builder.len = i + 1; 
       } 
      } 
      builder.len = 0; 
      v.into_inner() 
     } 
    ) 
} 

let a = array![Vec::new(); 3]; 

Und einen Test, die zeigt mit schrieb, dass es nicht Leckspeicher

#[test] 
fn test() { 
    static mut COUNT: usize = 0; 

    #[derive(Debug)] 
    struct X(usize); 

    impl Drop for X { 
     fn drop(&mut self) { 
      println!("drop {:?}", self.0); 
     } 
    } 

    impl X { 
     fn new() -> X { 
      unsafe { 
       if COUNT == 3 { 
        panic!(); 
       } 
       let x = X(COUNT); 
       COUNT += 1; 
       x 
      } 
     } 
    } 

    array![X::new(); 6]; 
} 

Bei diesem Test gerät die Methode X::new in Panik, wenn X(3) erstellt wird, also müssen X(0), X(1), X(2) gelöscht werden.

Andere

Es ist eine unsichere Lösung here.