Come inizializzare una struttura contenente un array in Rust?

Question

Qual è il modo consigliato per dichiarare una struttura che contiene una matrice e quindi creare un'istanza inizializzata a zero?

Ecco la struct:

use std::default::Default; 
use std::num; 

#[deriving(Default)] 
struct Histogram { 
    sum: u32, 
    bins: [u32, ..256], 
} 

e l'errore del compilatore:

src/lib.rs:17:5: 17:23 error: the trait `core::default::Default` is not implemented for the type `[u32, ..256]` 
src/lib.rs:17  bins: [u32, ..256], 
        ^~~~~~~~~~~~~~~~~~ 
note: in expansion of #[deriving] 
src/lib.rs:14:1: 14:21 note: expansion site 
src/lib.rs:17:5: 17:23 note: the trait `core::default::Default` must be implemented because it is required by `core::default::Default::default` 
src/lib.rs:17  bins: [u32, ..256], 
        ^~~~~~~~~~~~~~~~~~ 
note: in expansion of #[deriving] 
src/lib.rs:14:1: 14:21 note: expansion site 
error: aborting due to previous error 

Se tento di aggiungere l'inizializzazione mancante per l'array uint8:

impl Default for [u32,..256] { 
    fn default() -> [u32,..255]{ 
     [0u8,..256] 
    } 
} 

ottengo :

src/lib.rs:20:1: 24:2 error: cannot provide an extension implementation where both trait and type are not defined in this crate [E0117] 
src/lib.rs:20 impl Default for [u32,..256] { 
src/lib.rs:21  fn default() -> [u32,..255]{ 
src/lib.rs:22   [0u8,..256] 
src/lib.rs:23  } 
src/lib.rs:24 } 

Sto facendo qualcosa di sbagliato, o vengo morso da churn nella libreria standard per i tipi numerici sulla strada verso 1.0?

$ rustc --version 
rustc 0.13.0-nightly 

Answer 1

ruggine non attuare Default per tutte le matrici perché non ha non polimorfismo tipo, come tale Default è attuabile solo per una manciata di formati.

È possibile, tuttavia, implementare un predefinito per vostro tipo:

impl Default for Histogram { 
    fn default() -> Histogram { 
     Histogram { 
      sum: 0, 
      bins: [0u32, ..256], 
     } 
    } 
} 

Nota: Vorrei sostenere che implementano Default per u32 è pesce per cominciare, perché 0 e non 1? o 42? Non c'è una buona risposta, quindi nessun default ovvio davvero.

Answer 2

ho paura non si può fare questo, è necessario implementare Default per la vostra struttura di te stesso:

struct Histogram { 
    sum: u32, 
    bins: [u32, ..256], 
} 

impl Default for Histogram { 
    #[inline] 
    fn default() -> Histogram { 
     Histogram { sum: 0, bins: [0, ..256] } 
    } 
} 

tipi numerici non hanno nulla a che fare con questo caso, è più come problemi con fisso -Misaglie di dimensioni. Hanno ancora bisogno di letterali numerici generici per supportare questo tipo di cose in modo nativo.

Answer 3

Infatti, al momento della scrittura, il supporto per gli array a lunghezza fissa è ancora in fase di hash nella libreria standard:

https://github.com/rust-lang/rust/issues/7622

Answer 4

Se siete sicuri di inizializzare ogni campo con zero, funzionerebbe:

impl Default for Histogram { 
    fn default() -> Histogram { unsafe { std::mem::zeroed() } } 
}