Standart genel tür parametresi genel tür parametresi için varsayılan bir değer tanımlamak isteyen zaman ancak sorun düşüyorum,

Question

ben bir egzersiz olarak Bit Vektör kitaplığını uygulamak çalışıyorum anlaşılmaktadır edilemez.

Bu

kodunun bir alıntıdır ben:

extern crate num; 

use std::cmp::Eq; 
use std::ops::{BitAnd,BitOrAssign,Index,Shl}; 
use num::{One,Zero,Unsigned,NumCast}; 

pub trait BitStorage: Sized + 
    BitAnd<Self, Output = Self> + 
    BitOrAssign<Self> + 
    Shl<Self, Output = Self> + 
    Eq + Zero + One + Unsigned + NumCast + Copy {} 

impl<S> BitStorage for S where S: Sized + 
    BitAnd<S, Output = S> + 
    BitOrAssign<S> + 
    Shl<S, Output = S> + 
    Eq + Zero + One + Unsigned + NumCast + Copy {} 

pub struct BitVector<S: BitStorage = usize> { 
    data: Vec<S>, 
    capacity: usize 
} 

impl<S: BitStorage> BitVector<S> { 
    pub fn with_capacity(capacity: usize) -> BitVector<S> { 
     let len = (capacity/(std::mem::size_of::<S>() * 8)) + 1; 
     BitVector { data: vec![S::zero(); len], capacity: capacity } 
    } 

    //... 
} 

Ve şöyle onu kullanmak istiyorum:

lib.rs:225:24: 225:48 error: unable to infer enough type information about _ ; type annotations or generic parameter binding required [E0282]
lib.rs:225 let vec_1000 = BitVector::with_capacity(1000);
^~~~~~~~~~~~~~~~~~~~~~~~
lib.rs:225:24: 225:48 help: run rustc --explain E0282 to see a detailed explanation

: Bir derleyici hatası alıyorum Ancak

let vec = BitVector::with_capacity(1024); 

Kod için biraz daha fazla bağlam vermek için, şu anda geçerli olan BitStorage için geçerli olan türler (bunlarla sınırlı değildir) * u8, u16, u32, u64 ve usize.

(*) Bunu türü için tüm özellikleri uygulamak eğer bir özel u128 uygulanmasını (sadece örnek olarak) yazabilirsiniz düşünüyorum.

Sorun hakkında daha sonra, be stable yet görünmeyen RFC 213 numarasını buldum. Ancak diğer yandan HashMap, şu anda kararlı olan varsayılan değerleri kullanıyor, bu yüzden çalışıyor olmalı, değil mi?

Answer 1

varsayılan tür parametreleri için destek hala sınırlıdır, ancak bazı durumlarda kullanılabilir. ,

// the type of vec is BitVector<usize>, so the type of 
// BitVector::with_capacity(1024) is correctly inferred 
let vec: BitVector = BitVector::with_capacity(1024); 

However on the other hand HashMap currently on stable is using default values, so it should be working, right?

HashMap kaynak kodu baktığımızda yapabilirsiniz: Varsayılan tür parametresi olan bir struct Bir değişkenin türünü belirtmek için kullanılır, varsayılan türü parametre değişkeninin türünü tanımlamak için kullanılır yöntemler new ve with_capacityS parametre için RandomState ile uygulanır ve HashMap varsayılan tipi parametresine bağlı olmadığını görüyoruz. Diğer tüm yöntemler, with_hasher gibi diğer "yapıcı" yöntemleri de dahil olmak üzere, S üzerinde genel olarak uygulanır.

Sen benzer bir şey yazabilirsiniz:

impl BitVector<usize> { 
    pub fn default_with_capacity(capacity: usize) -> BitVector<usize> { 
     // type is inferred 
     Self::with_capacity(capacity) 
    } 
} 

impl<S: BitStorage> BitVector<S> { 
    pub fn with_capacity(capacity: usize) -> BitVector<S> { 
     let len = (capacity/(std::mem::size_of::<S>() * 8)) + 1; 
     BitVector { 
      data: vec![S::zero(); len], 
      capacity: capacity, 
     } 
    } 

    // ... 
} 

// create with "default" BitStore 
let vec = BitVector::default_with_capacity(1024); 
// specify BitStore 
let vec = BitVector::<u32>::with_capacity(1024);