Sabit olmayan uzunlukta bir vektör oluşturma

Question

Bir vektör oluşturmak istiyorum, ancak yalnızca vektörün çalışma zamanında olmasını istediğiniz boyutu biliyorum. Bu benim (yani boş, değişken vektörü oluşturma ve buna vektörleri ekleyerek) Şimdi yapıyorum nasıl:

fn add_pairs(pairs: ~[int]) -> ~[int] { 
    let mut result : ~[int] = ~[]; 
    let mut i = 0; 
    while i < pairs.len() { 
     result += ~[pairs[i] + pairs[i + 1]]; 
     i += 2; 
    } 
    return result; 
} 

Ben böyle (yapmak istiyorum nasıl yani vektör yaratmak ve her şeyi koyarak bunun yerine, onu) birlikte vektörlerin sürü ekleme:

error: expected constant expr for vector length: Non-constant path in constant expr 
let result: ~[int, ..number_of_pairs]; 
      ^~~~~~~~~~~~~~~~~~~~~~~~ 

Ben vektörler boyutları derleme t tanıyoruz zorunda olduğu izlenimini alıyorum: Maalesef

fn add_pairs(pairs: ~[int]) -> ~[int] { 
    let number_of_pairs = pairs.len()/2; 
    let result : ~[int, ..number_of_pairs]; 
    let mut i = 0; 
    while i < pairs.len() { 
     result[i] = pairs[2 * i] + pairs[2 * i + 1]; 
     i += 1; 
    } 
    return result; 
} 

yapıyor yukarıda bana şöyle veriyor ime (ve böylece boyutlarını sabit olarak ayarlamanız gerekir). Java arkaplanından geliyor, kafam karıştı! Boyutu yalnızca sizin çalışma zamanında bildiğiniz bir vektör yaratmanın bir yolu var mı?

Pas 0.6 kullanıyorum.

Answer 1

Çalışma zamanında belirlenen uzunluk ile sabit uzunlukta bir vektör oluşturmanın bir yolu yoktur, sadece derleme zamanı sabit uzunluk vektörlerine izin verilir, böylece (varyasyonları) ~[int] ile ilk yönteminiz desteklenen tek yoldur. Doğru boyutta bir vektör oluşturmak ve ikinci parçayı kullanmak için vec::from_elem(number_of_pairs, 0)'u kullanabilirsiniz. (Çok nadir olmalıdır while doğrudan Rust kullanarak) ne yapmaya çalışıyoruz için birçok yardımcı fonksiyon vardır

---

şunlardır:

fn add_pairs(pairs: &[int]) -> ~[int] { 
    let mut result = ~[]; 
    for i in uint::range(0, pairs.len()/2) { 
     result.push(pairs[2*i] + pairs[2*i+1]) 
    } 
    result 
} 

Hatta

fn add_pairs(pairs: &[int]) -> ~[int] { 
    pairs.chunks(2).filter(|x| x.len() == 2).map(|x| x[0] + x[1]).collect() 
} 

Dokümanlar: chunks, filter, map, collect. push mutlaka bunu ve çok daha hızlıdır etmese de,

(Ayrıca unutmayın iki vektörleri ekleyerek yepyeni bir ayırır (ve .collect (filterchunks son elemanı uzunluğu 1. olabilir sırf olduğu) benzerdir.) 0)

Answer 2

Pas'ın sonraki sürümlerinde (0.9 kullanıyorum), bu senaryoyu işleyen std::vec numaralı with_capacity() işlevi bulunmaktadır.

Örnek kodu: let mut my_vec = Vec::new(); ile growable vektör örneğini böylece

use std::vec; 

// ... 

let n = 44; // pretend determined at run time 
let mut v = vec::with_capacity::<f64>(n); 
v.push(6.26); 
println("{:?}", v);    // prints ~[6.26f64] 
println("{:?}", v.len());  // prints 1u 
println("{:?}", v.capacity()); // prints 44u 

Answer 3

Pas sürümde bunlar stabil std::vec:Vec kamu yapısını yaptık 1.0.0 Ayrıca şöyle vec! makro kullanabilirsiniz: let mut another_vec = vec![1isize, 2isize, 3isize]; Dikkat edilmesi gereken, her iki durumda da atamak istediğiniz değişkenin değişebilir olması gerektiğidir.

Bu vektörlerle, öğeleri (sabit) my_vec.push(num); veya vektörün sonuna öğeleri eklemek için another_vec.push_all(["list", "of", "objects"]); (kararsız) için çağırabilirsiniz.

Yani Özgül sorun, size (ı kabul neyi) tamsayı çifti yuvalanmış vektör oldu nereye Sen eylem here Bu görebileceğiniz bu

fn add_pairs(pairs: Vec<(Vec<isize>)>) -> Vec<isize> { 
    let mut result = Vec::new(); 
    for pair in pairs.iter() { 
     result.push(pair[0]); 
     result.push(pair[1]); 
    } 
    return result 
} 

gibi bir şey yapabilirdi.