How to allocate space for a Vec in Rust?

Question

I want to create a Vec<T> and make some room for it, but I don't know how to do it, and, to my surprise, there is almost nothing in the official documentation about this basic type.

let mut v: Vec<i32> = Vec<i32>(SIZE); // How do I do this ?

for i in 0..SIZE {
    v[i] = i;
}

I know I can create an empty Vec<T> and fill it with pushes, but I don't want to do that since I don't always know, when writing a value at index i, if a value was already inserted there yet. I don't want to write, for obvious performance reasons, something like :

if i >= len(v) {
    v.push(x);
} else {
    v[i] = x;
}

And, of course, I can't use the vec! syntax either.

If you're creating a new vector you *will* know if a value exists. Note that quite a few answers here assume you're creating a new vector, if this isn't the case *(from the second part of the question seems its not)* it would be good to make that more clear in the question. The answer for a new compared to an existing vector are quite different. — ideasman42, Jan 09 '17 at 07:08

score 55 · Answer 1 · edited Jan 09 '17 at 19:09

While vec![elem; count] from the accepted answer is sufficient to create a vector with all elements equal to the same value, there are other convenience functions.

Vec::with_capacity() creates a vector with the given capacity but with zero length. It means that until this capacity is reached, push() calls won't reallocate the vector, making push() essentially free:

fn main() {
    let mut v = Vec::with_capacity(10);
    for i in 0..10 {
        v.push(i);
    }
    println!("{:?}", v);
}

You can also easily collect() a vector from an iterator. Example:

fn main() {
    let v: Vec<_> = (1..10).collect();
    println!("{:?}", v);
}

And finally, sometimes your vector contains values of primitive type and is supposed to be used as a buffer (e.g. in network communication). In this case you can use Vec::with_capacity() + set_len() unsafe method:

fn main() {
    let mut v = Vec::with_capacity(10);
    unsafe { v.set_len(10); }
    for i in 0..10 {
        v[i] = i;
    }
    println!("{:?}", v);
}

Note that you have to be extra careful if your vector contains values with destructors or references - it's easy to get a destructor run over a uninitialized piece of memory or to get an invalid reference this way. It will also work right if you only use initialized part of the vector (you have to track it yourself now). To read about all the possible dangers of uninitialized memory, you can read the documentation of mem::uninitialized().

`set_len` *can* work correctly with non-`Copy` types: you just have to be careful. And it can be broken with `Copy` types, e.g. `&int` is `Copy` but it's highly likely that the random uninitialised memory will not be a valid `&int`. (It's very dangerous!) — huon, Nov 28 '14 at 02:11
@dbaupp, yeah, I probably did not formulate it right. Thanks! — Vladimir Matveev, Nov 28 '14 at 06:21
Probably better to iterate over the vector with enum, so every assignment doesn't need to be bounds checked. (possibly bounds checks will be optimized out - but it depends on the complexity of the loop) — ideasman42, Jan 09 '17 at 06:29

score 18 · Accepted Answer · edited Jan 09 '17 at 18:59

18

You can use the first syntax of the vec! macro, specifically vec![elem; count]. For example:

vec![1; 10]

will create a Vec<_> containing 10 1s (the type _ will be determined later or default to i32). The elem given to the macro must implement Clone. The count can be a variable, too.

edited Jan 09 '17 at 18:59

Lukas Kalbertodt

79,749
26
255
305

answered Nov 27 '14 at 17:02

Dogbert

212,659
41
396
397

Thank you. Well, it was in the documentation. I couldn't find it when I searched for it, though. – Fabien Nov 27 '14 at 17:12
2

This no longer works, that method appears to have been removed. – Amandasaurus Dec 08 '16 at 15:26
1

@Rory Runs with 1.0 now – Lukas Kalbertodt Jan 09 '17 at 19:13
This is easier to remember than ::with_capacity(); .. vec![0; 10]; it works in latest Rust 1.4.4 – Charlie 木匠 Jun 19 '20 at 05:33

score 3 · Answer 3 · edited Jan 09 '17 at 18:24

3

There is the Vec::resize method:

fn resize(&mut self, new_len: usize, value: T)

This code resizes an empty vector to 1024 elements by filling with the value 7:

let mut vec: Vec<i32> = Vec::new();
vec.resize(1024, 7);

edited Jan 09 '17 at 18:24

Shepmaster

388,571
95
1,107
1,366

answered May 02 '15 at 19:26

Denis Kreshikhin

8,856
9
52
84

1

While worth noting, this only works if you're assigning the same value - the OP assigns increasing indices. – ideasman42 Jan 09 '17 at 06:31

How to allocate space for a Vec in Rust?

3 Answers3

Linked

Related