Expand description
A contiguous growable array type, written as Vec<T>
, short for ‘vector’.
Examples
let mut vec = Vec::new();
vec.push(1);
vec.push(2);
assert_eq!(vec.len(), 2);
assert_eq!(vec[0], 1);
assert_eq!(vec.pop(), Some(2));
assert_eq!(vec.len(), 1);
vec[0] = 7;
assert_eq!(vec[0], 7);
vec.extend([1, 2, 3].iter().copied());
for x in &vec {
println!("{x}");
}
assert_eq!(vec, [7, 1, 2, 3]);
RunThe vec!
macro is provided for convenient initialization:
let mut vec1 = vec![1, 2, 3];
vec1.push(4);
let vec2 = Vec::from([1, 2, 3, 4]);
assert_eq!(vec1, vec2);
RunIt can also initialize each element of a Vec<T>
with a given value.
This may be more efficient than performing allocation and initialization
in separate steps, especially when initializing a vector of zeros:
let vec = vec![0; 5];
assert_eq!(vec, [0, 0, 0, 0, 0]);
// The following is equivalent, but potentially slower:
let mut vec = Vec::with_capacity(5);
vec.resize(5, 0);
assert_eq!(vec, [0, 0, 0, 0, 0]);
RunFor more information, see Capacity and Reallocation.
Use a Vec<T>
as an efficient stack:
let mut stack = Vec::new();
stack.push(1);
stack.push(2);
stack.push(3);
while let Some(top) = stack.pop() {
// Prints 3, 2, 1
println!("{top}");
}
RunIndexing
The Vec
type allows to access values by index, because it implements the
Index
trait. An example will be more explicit:
let v = vec![0, 2, 4, 6];
println!("{}", v[1]); // it will display '2'
RunHowever be careful: if you try to access an index which isn’t in the Vec
,
your software will panic! You cannot do this:
let v = vec![0, 2, 4, 6];
println!("{}", v[6]); // it will panic!
RunUse get
and get_mut
if you want to check whether the index is in
the Vec
.
Slicing
A Vec
can be mutable. On the other hand, slices are read-only objects.
To get a slice, use &
. Example:
fn read_slice(slice: &[usize]) {
// ...
}
let v = vec![0, 1];
read_slice(&v);
// ... and that's all!
// you can also do it like this:
let u: &[usize] = &v;
// or like this:
let u: &[_] = &v;
RunIn Rust, it’s more common to pass slices as arguments rather than vectors
when you just want to provide read access. The same goes for String
and
&str
.
Capacity and reallocation
The capacity of a vector is the amount of space allocated for any future elements that will be added onto the vector. This is not to be confused with the length of a vector, which specifies the number of actual elements within the vector. If a vector’s length exceeds its capacity, its capacity will automatically be increased, but its elements will have to be reallocated.
For example, a vector with capacity 10 and length 0 would be an empty vector
with space for 10 more elements. Pushing 10 or fewer elements onto the
vector will not change its capacity or cause reallocation to occur. However,
if the vector’s length is increased to 11, it will have to reallocate, which
can be slow. For this reason, it is recommended to use Vec::with_capacity
whenever possible to specify how big the vector is expected to get.
Guarantees
Due to its incredibly fundamental nature, Vec
makes a lot of guarantees
about its design. This ensures that it’s as low-overhead as possible in
the general case, and can be correctly manipulated in primitive ways
by unsafe code. Note that these guarantees refer to an unqualified Vec<T>
.
If additional type parameters are added (e.g., to support custom allocators),
overriding their defaults may change the behavior.
Most fundamentally, Vec
is and always will be a (pointer, capacity, length)
triplet. No more, no less. The order of these fields is completely
unspecified, and you should use the appropriate methods to modify these.
The pointer will never be null, so this type is null-pointer-optimized.
However, the pointer might not actually point to allocated memory. In particular,
if you construct a Vec
with capacity 0 via Vec::new
, vec![]
,
Vec::with_capacity(0)
, or by calling shrink_to_fit
on an empty Vec, it will not allocate memory. Similarly, if you store zero-sized
types inside a Vec
, it will not allocate space for them. Note that in this case
the Vec
might not report a capacity
of 0. Vec
will allocate if and only
if mem::size_of::<T>() * capacity() > 0
. In general, Vec
’s allocation
details are very subtle — if you intend to allocate memory using a Vec
and use it for something else (either to pass to unsafe code, or to build your
own memory-backed collection), be sure to deallocate this memory by using
from_raw_parts
to recover the Vec
and then dropping it.
If a Vec
has allocated memory, then the memory it points to is on the heap
(as defined by the allocator Rust is configured to use by default), and its
pointer points to len
initialized, contiguous elements in order (what
you would see if you coerced it to a slice), followed by capacity - len
logically uninitialized, contiguous elements.
A vector containing the elements 'a'
and 'b'
with capacity 4 can be
visualized as below. The top part is the Vec
struct, it contains a
pointer to the head of the allocation in the heap, length and capacity.
The bottom part is the allocation on the heap, a contiguous memory block.
ptr len capacity
+--------+--------+--------+
| 0x0123 | 2 | 4 |
+--------+--------+--------+
|
v
Heap +--------+--------+--------+--------+
| 'a' | 'b' | uninit | uninit |
+--------+--------+--------+--------+
- uninit represents memory that is not initialized, see
MaybeUninit
. - Note: the ABI is not stable and
Vec
makes no guarantees about its memory layout (including the order of fields).
Vec
will never perform a “small optimization” where elements are actually
stored on the stack for two reasons:
-
It would make it more difficult for unsafe code to correctly manipulate a
Vec
. The contents of aVec
wouldn’t have a stable address if it were only moved, and it would be more difficult to determine if aVec
had actually allocated memory. -
It would penalize the general case, incurring an additional branch on every access.
Vec
will never automatically shrink itself, even if completely empty. This
ensures no unnecessary allocations or deallocations occur. Emptying a Vec
and then filling it back up to the same len
should incur no calls to
the allocator. If you wish to free up unused memory, use
shrink_to_fit
or shrink_to
.
push
and insert
will never (re)allocate if the reported capacity is
sufficient. push
and insert
will (re)allocate if
len == capacity
. That is, the reported capacity is completely
accurate, and can be relied on. It can even be used to manually free the memory
allocated by a Vec
if desired. Bulk insertion methods may reallocate, even
when not necessary.
Vec
does not guarantee any particular growth strategy when reallocating
when full, nor when reserve
is called. The current strategy is basic
and it may prove desirable to use a non-constant growth factor. Whatever
strategy is used will of course guarantee O(1) amortized push
.
vec![x; n]
, vec![a, b, c, d]
, and
Vec::with_capacity(n)
, will all produce a Vec
with exactly the requested capacity. If len == capacity
,
(as is the case for the vec!
macro), then a Vec<T>
can be converted to
and from a Box<[T]>
without reallocating or moving the elements.
Vec
will not specifically overwrite any data that is removed from it,
but also won’t specifically preserve it. Its uninitialized memory is
scratch space that it may use however it wants. It will generally just do
whatever is most efficient or otherwise easy to implement. Do not rely on
removed data to be erased for security purposes. Even if you drop a Vec
, its
buffer may simply be reused by another allocation. Even if you zero a Vec
’s memory
first, that might not actually happen because the optimizer does not consider
this a side-effect that must be preserved. There is one case which we will
not break, however: using unsafe
code to write to the excess capacity,
and then increasing the length to match, is always valid.
Currently, Vec
does not guarantee the order in which elements are dropped.
The order has changed in the past and may change again.
Implementations
sourceimpl<T> Vec<T>
impl<T> Vec<T>
sourcepub fn with_capacity(capacity: usize) -> Self
pub fn with_capacity(capacity: usize) -> Self
Constructs a new, empty Vec<T>
with the specified capacity.
The vector will be able to hold exactly capacity
elements without
reallocating. If capacity
is 0, the vector will not allocate.
It is important to note that although the returned vector has the capacity specified, the vector will have a zero length. For an explanation of the difference between length and capacity, see Capacity and reallocation.
Panics
Panics if the new capacity exceeds isize::MAX
bytes.
Examples
let mut vec = Vec::with_capacity(10);
// The vector contains no items, even though it has capacity for more
assert_eq!(vec.len(), 0);
assert_eq!(vec.capacity(), 10);
// These are all done without reallocating...
for i in 0..10 {
vec.push(i);
}
assert_eq!(vec.len(), 10);
assert_eq!(vec.capacity(), 10);
// ...but this may make the vector reallocate
vec.push(11);
assert_eq!(vec.len(), 11);
assert!(vec.capacity() >= 11);
Runsourcepub unsafe fn from_raw_parts(
ptr: *mut T,
length: usize,
capacity: usize
) -> Self
pub unsafe fn from_raw_parts(
ptr: *mut T,
length: usize,
capacity: usize
) -> Self
Creates a Vec<T>
directly from the raw components of another vector.
Safety
This is highly unsafe, due to the number of invariants that aren’t checked:
ptr
needs to have been previously allocated viaString
/Vec<T>
(at least, it’s highly likely to be incorrect if it wasn’t).T
needs to have the same alignment as whatptr
was allocated with. (T
having a less strict alignment is not sufficient, the alignment really needs to be equal to satisfy thedealloc
requirement that memory must be allocated and deallocated with the same layout.)- The size of
T
times thecapacity
(ie. the allocated size in bytes) needs to be the same size as the pointer was allocated with. (Because similar to alignment,dealloc
must be called with the same layoutsize
.) length
needs to be less than or equal tocapacity
.
Violating these may cause problems like corrupting the allocator’s
internal data structures. For example it is not safe
to build a Vec<u8>
from a pointer to a C char
array with length size_t
.
It’s also not safe to build one from a Vec<u16>
and its length, because
the allocator cares about the alignment, and these two types have different
alignments. The buffer was allocated with alignment 2 (for u16
), but after
turning it into a Vec<u8>
it’ll be deallocated with alignment 1. To avoid
these issues, it is often preferable to do casting/transmuting using
slice::from_raw_parts
instead.
The ownership of ptr
is effectively transferred to the
Vec<T>
which may then deallocate, reallocate or change the
contents of memory pointed to by the pointer at will. Ensure
that nothing else uses the pointer after calling this
function.
Examples
use std::ptr;
use std::mem;
let v = vec![1, 2, 3];
// Prevent running `v`'s destructor so we are in complete control
// of the allocation.
let mut v = mem::ManuallyDrop::new(v);
// Pull out the various important pieces of information about `v`
let p = v.as_mut_ptr();
let len = v.len();
let cap = v.capacity();
unsafe {
// Overwrite memory with 4, 5, 6
for i in 0..len as isize {
ptr::write(p.offset(i), 4 + i);
}
// Put everything back together into a Vec
let rebuilt = Vec::from_raw_parts(p, len, cap);
assert_eq!(rebuilt, [4, 5, 6]);
}
Runsourceimpl<T, A: Allocator> Vec<T, A>
impl<T, A: Allocator> Vec<T, A>
sourcepub fn with_capacity_in(capacity: usize, alloc: A) -> Self
pub fn with_capacity_in(capacity: usize, alloc: A) -> Self
Constructs a new, empty Vec<T, A>
with the specified capacity with the provided
allocator.
The vector will be able to hold exactly capacity
elements without
reallocating. If capacity
is 0, the vector will not allocate.
It is important to note that although the returned vector has the capacity specified, the vector will have a zero length. For an explanation of the difference between length and capacity, see Capacity and reallocation.
Panics
Panics if the new capacity exceeds isize::MAX
bytes.
Examples
#![feature(allocator_api)]
use std::alloc::System;
let mut vec = Vec::with_capacity_in(10, System);
// The vector contains no items, even though it has capacity for more
assert_eq!(vec.len(), 0);
assert_eq!(vec.capacity(), 10);
// These are all done without reallocating...
for i in 0..10 {
vec.push(i);
}
assert_eq!(vec.len(), 10);
assert_eq!(vec.capacity(), 10);
// ...but this may make the vector reallocate
vec.push(11);
assert_eq!(vec.len(), 11);
assert!(vec.capacity() >= 11);
Runsourcepub unsafe fn from_raw_parts_in(
ptr: *mut T,
length: usize,
capacity: usize,
alloc: A
) -> Self
pub unsafe fn from_raw_parts_in(
ptr: *mut T,
length: usize,
capacity: usize,
alloc: A
) -> Self
Creates a Vec<T, A>
directly from the raw components of another vector.
Safety
This is highly unsafe, due to the number of invariants that aren’t checked:
ptr
needs to have been previously allocated viaString
/Vec<T>
(at least, it’s highly likely to be incorrect if it wasn’t).T
needs to have the same size and alignment as whatptr
was allocated with. (T
having a less strict alignment is not sufficient, the alignment really needs to be equal to satisfy thedealloc
requirement that memory must be allocated and deallocated with the same layout.)length
needs to be less than or equal tocapacity
.capacity
needs to be the capacity that the pointer was allocated with.
Violating these may cause problems like corrupting the allocator’s
internal data structures. For example it is not safe
to build a Vec<u8>
from a pointer to a C char
array with length size_t
.
It’s also not safe to build one from a Vec<u16>
and its length, because
the allocator cares about the alignment, and these two types have different
alignments. The buffer was allocated with alignment 2 (for u16
), but after
turning it into a Vec<u8>
it’ll be deallocated with alignment 1.
The ownership of ptr
is effectively transferred to the
Vec<T>
which may then deallocate, reallocate or change the
contents of memory pointed to by the pointer at will. Ensure
that nothing else uses the pointer after calling this
function.
Examples
#![feature(allocator_api)]
use std::alloc::System;
use std::ptr;
use std::mem;
let mut v = Vec::with_capacity_in(3, System);
v.push(1);
v.push(2);
v.push(3);
// Prevent running `v`'s destructor so we are in complete control
// of the allocation.
let mut v = mem::ManuallyDrop::new(v);
// Pull out the various important pieces of information about `v`
let p = v.as_mut_ptr();
let len = v.len();
let cap = v.capacity();
let alloc = v.allocator();
unsafe {
// Overwrite memory with 4, 5, 6
for i in 0..len as isize {
ptr::write(p.offset(i), 4 + i);
}
// Put everything back together into a Vec
let rebuilt = Vec::from_raw_parts_in(p, len, cap, alloc.clone());
assert_eq!(rebuilt, [4, 5, 6]);
}
Runsourcepub fn into_raw_parts(self) -> (*mut T, usize, usize)
pub fn into_raw_parts(self) -> (*mut T, usize, usize)
Decomposes a Vec<T>
into its raw components.
Returns the raw pointer to the underlying data, the length of
the vector (in elements), and the allocated capacity of the
data (in elements). These are the same arguments in the same
order as the arguments to from_raw_parts
.
After calling this function, the caller is responsible for the
memory previously managed by the Vec
. The only way to do
this is to convert the raw pointer, length, and capacity back
into a Vec
with the from_raw_parts
function, allowing
the destructor to perform the cleanup.
Examples
#![feature(vec_into_raw_parts)]
let v: Vec<i32> = vec![-1, 0, 1];
let (ptr, len, cap) = v.into_raw_parts();
let rebuilt = unsafe {
// We can now make changes to the components, such as
// transmuting the raw pointer to a compatible type.
let ptr = ptr as *mut u32;
Vec::from_raw_parts(ptr, len, cap)
};
assert_eq!(rebuilt, [4294967295, 0, 1]);
Runsourcepub fn into_raw_parts_with_alloc(self) -> (*mut T, usize, usize, A)
pub fn into_raw_parts_with_alloc(self) -> (*mut T, usize, usize, A)
Decomposes a Vec<T>
into its raw components.
Returns the raw pointer to the underlying data, the length of the vector (in elements),
the allocated capacity of the data (in elements), and the allocator. These are the same
arguments in the same order as the arguments to from_raw_parts_in
.
After calling this function, the caller is responsible for the
memory previously managed by the Vec
. The only way to do
this is to convert the raw pointer, length, and capacity back
into a Vec
with the from_raw_parts_in
function, allowing
the destructor to perform the cleanup.
Examples
#![feature(allocator_api, vec_into_raw_parts)]
use std::alloc::System;
let mut v: Vec<i32, System> = Vec::new_in(System);
v.push(-1);
v.push(0);
v.push(1);
let (ptr, len, cap, alloc) = v.into_raw_parts_with_alloc();
let rebuilt = unsafe {
// We can now make changes to the components, such as
// transmuting the raw pointer to a compatible type.
let ptr = ptr as *mut u32;
Vec::from_raw_parts_in(ptr, len, cap, alloc)
};
assert_eq!(rebuilt, [4294967295, 0, 1]);
Runsourcepub fn reserve(&mut self, additional: usize)
pub fn reserve(&mut self, additional: usize)
Reserves capacity for at least additional
more elements to be inserted
in the given Vec<T>
. The collection may reserve more space to avoid
frequent reallocations. After calling reserve
, capacity will be
greater than or equal to self.len() + additional
. Does nothing if
capacity is already sufficient.
Panics
Panics if the new capacity exceeds isize::MAX
bytes.
Examples
let mut vec = vec![1];
vec.reserve(10);
assert!(vec.capacity() >= 11);
Runsourcepub fn reserve_exact(&mut self, additional: usize)
pub fn reserve_exact(&mut self, additional: usize)
Reserves the minimum capacity for exactly additional
more elements to
be inserted in the given Vec<T>
. After calling reserve_exact
,
capacity will be greater than or equal to self.len() + additional
.
Does nothing if the capacity is already sufficient.
Note that the allocator may give the collection more space than it
requests. Therefore, capacity can not be relied upon to be precisely
minimal. Prefer reserve
if future insertions are expected.
Panics
Panics if the new capacity exceeds isize::MAX
bytes.
Examples
let mut vec = vec![1];
vec.reserve_exact(10);
assert!(vec.capacity() >= 11);
Run1.57.0 · sourcepub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>
pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>
Tries to reserve capacity for at least additional
more elements to be inserted
in the given Vec<T>
. The collection may reserve more space to avoid
frequent reallocations. After calling try_reserve
, capacity will be
greater than or equal to self.len() + additional
. Does nothing if
capacity is already sufficient.
Errors
If the capacity overflows, or the allocator reports a failure, then an error is returned.
Examples
use std::collections::TryReserveError;
fn process_data(data: &[u32]) -> Result<Vec<u32>, TryReserveError> {
let mut output = Vec::new();
// Pre-reserve the memory, exiting if we can't
output.try_reserve(data.len())?;
// Now we know this can't OOM in the middle of our complex work
output.extend(data.iter().map(|&val| {
val * 2 + 5 // very complicated
}));
Ok(output)
}
Run1.57.0 · sourcepub fn try_reserve_exact(
&mut self,
additional: usize
) -> Result<(), TryReserveError>
pub fn try_reserve_exact(
&mut self,
additional: usize
) -> Result<(), TryReserveError>
Tries to reserve the minimum capacity for exactly additional
elements to be inserted in the given Vec<T>
. After calling
try_reserve_exact
, capacity will be greater than or equal to
self.len() + additional
if it returns Ok(())
.
Does nothing if the capacity is already sufficient.
Note that the allocator may give the collection more space than it
requests. Therefore, capacity can not be relied upon to be precisely
minimal. Prefer try_reserve
if future insertions are expected.
Errors
If the capacity overflows, or the allocator reports a failure, then an error is returned.
Examples
use std::collections::TryReserveError;
fn process_data(data: &[u32]) -> Result<Vec<u32>, TryReserveError> {
let mut output = Vec::new();
// Pre-reserve the memory, exiting if we can't
output.try_reserve_exact(data.len())?;
// Now we know this can't OOM in the middle of our complex work
output.extend(data.iter().map(|&val| {
val * 2 + 5 // very complicated
}));
Ok(output)
}
Runsourcepub fn shrink_to_fit(&mut self)
pub fn shrink_to_fit(&mut self)
Shrinks the capacity of the vector as much as possible.
It will drop down as close as possible to the length but the allocator may still inform the vector that there is space for a few more elements.
Examples
let mut vec = Vec::with_capacity(10);
vec.extend([1, 2, 3]);
assert_eq!(vec.capacity(), 10);
vec.shrink_to_fit();
assert!(vec.capacity() >= 3);
Run1.56.0 · sourcepub fn shrink_to(&mut self, min_capacity: usize)
pub fn shrink_to(&mut self, min_capacity: usize)
Shrinks the capacity of the vector with a lower bound.
The capacity will remain at least as large as both the length and the supplied value.
If the current capacity is less than the lower limit, this is a no-op.
Examples
let mut vec = Vec::with_capacity(10);
vec.extend([1, 2, 3]);
assert_eq!(vec.capacity(), 10);
vec.shrink_to(4);
assert!(vec.capacity() >= 4);
vec.shrink_to(0);
assert!(vec.capacity() >= 3);
Runsourcepub fn into_boxed_slice(self) -> Box<[T], A>ⓘNotable traits for Box<I, A>impl<I: Iterator + ?Sized, A: Allocator> Iterator for Box<I, A> type Item = I::Item;impl<F: ?Sized + Future + Unpin, A: Allocator> Future for Box<F, A> where
A: 'static, type Output = F::Output;
pub fn into_boxed_slice(self) -> Box<[T], A>ⓘNotable traits for Box<I, A>impl<I: Iterator + ?Sized, A: Allocator> Iterator for Box<I, A> type Item = I::Item;impl<F: ?Sized + Future + Unpin, A: Allocator> Future for Box<F, A> where
A: 'static, type Output = F::Output;
A: 'static, type Output = F::Output;
Converts the vector into Box<[T]>
.
Note that this will drop any excess capacity.
Examples
let v = vec![1, 2, 3];
let slice = v.into_boxed_slice();
RunAny excess capacity is removed:
let mut vec = Vec::with_capacity(10);
vec.extend([1, 2, 3]);
assert_eq!(vec.capacity(), 10);
let slice = vec.into_boxed_slice();
assert_eq!(slice.into_vec().capacity(), 3);
Runsourcepub fn truncate(&mut self, len: usize)
pub fn truncate(&mut self, len: usize)
Shortens the vector, keeping the first len
elements and dropping
the rest.
If len
is greater than the vector’s current length, this has no
effect.
The drain
method can emulate truncate
, but causes the excess
elements to be returned instead of dropped.
Note that this method has no effect on the allocated capacity of the vector.
Examples
Truncating a five element vector to two elements:
let mut vec = vec![1, 2, 3, 4, 5];
vec.truncate(2);
assert_eq!(vec, [1, 2]);
RunNo truncation occurs when len
is greater than the vector’s current
length:
let mut vec = vec![1, 2, 3];
vec.truncate(8);
assert_eq!(vec, [1, 2, 3]);
RunTruncating when len == 0
is equivalent to calling the clear
method.
let mut vec = vec![1, 2, 3];
vec.truncate(0);
assert_eq!(vec, []);
Run1.7.0 · sourcepub fn as_mut_slice(&mut self) -> &mut [T]
pub fn as_mut_slice(&mut self) -> &mut [T]
1.37.0 · sourcepub fn as_ptr(&self) -> *const T
pub fn as_ptr(&self) -> *const T
Returns a raw pointer to the vector’s buffer.
The caller must ensure that the vector outlives the pointer this function returns, or else it will end up pointing to garbage. Modifying the vector may cause its buffer to be reallocated, which would also make any pointers to it invalid.
The caller must also ensure that the memory the pointer (non-transitively) points to
is never written to (except inside an UnsafeCell
) using this pointer or any pointer
derived from it. If you need to mutate the contents of the slice, use as_mut_ptr
.
Examples
let x = vec![1, 2, 4];
let x_ptr = x.as_ptr();
unsafe {
for i in 0..x.len() {
assert_eq!(*x_ptr.add(i), 1 << i);
}
}
Run1.37.0 · sourcepub fn as_mut_ptr(&mut self) -> *mut T
pub fn as_mut_ptr(&mut self) -> *mut T
Returns an unsafe mutable pointer to the vector’s buffer.
The caller must ensure that the vector outlives the pointer this function returns, or else it will end up pointing to garbage. Modifying the vector may cause its buffer to be reallocated, which would also make any pointers to it invalid.
Examples
// Allocate vector big enough for 4 elements.
let size = 4;
let mut x: Vec<i32> = Vec::with_capacity(size);
let x_ptr = x.as_mut_ptr();
// Initialize elements via raw pointer writes, then set length.
unsafe {
for i in 0..size {
*x_ptr.add(i) = i as i32;
}
x.set_len(size);
}
assert_eq!(&*x, &[0, 1, 2, 3]);
Runsourcepub unsafe fn set_len(&mut self, new_len: usize)
pub unsafe fn set_len(&mut self, new_len: usize)
Forces the length of the vector to new_len
.
This is a low-level operation that maintains none of the normal
invariants of the type. Normally changing the length of a vector
is done using one of the safe operations instead, such as
truncate
, resize
, extend
, or clear
.
Safety
new_len
must be less than or equal tocapacity()
.- The elements at
old_len..new_len
must be initialized.
Examples
This method can be useful for situations in which the vector is serving as a buffer for other code, particularly over FFI:
pub fn get_dictionary(&self) -> Option<Vec<u8>> {
// Per the FFI method's docs, "32768 bytes is always enough".
let mut dict = Vec::with_capacity(32_768);
let mut dict_length = 0;
// SAFETY: When `deflateGetDictionary` returns `Z_OK`, it holds that:
// 1. `dict_length` elements were initialized.
// 2. `dict_length` <= the capacity (32_768)
// which makes `set_len` safe to call.
unsafe {
// Make the FFI call...
let r = deflateGetDictionary(self.strm, dict.as_mut_ptr(), &mut dict_length);
if r == Z_OK {
// ...and update the length to what was initialized.
dict.set_len(dict_length);
Some(dict)
} else {
None
}
}
}
RunWhile the following example is sound, there is a memory leak since
the inner vectors were not freed prior to the set_len
call:
let mut vec = vec![vec![1, 0, 0],
vec![0, 1, 0],
vec![0, 0, 1]];
// SAFETY:
// 1. `old_len..0` is empty so no elements need to be initialized.
// 2. `0 <= capacity` always holds whatever `capacity` is.
unsafe {
vec.set_len(0);
}
RunNormally, here, one would use clear
instead to correctly drop
the contents and thus not leak memory.
sourcepub fn swap_remove(&mut self, index: usize) -> T
pub fn swap_remove(&mut self, index: usize) -> T
Removes an element from the vector and returns it.
The removed element is replaced by the last element of the vector.
This does not preserve ordering, but is O(1).
If you need to preserve the element order, use remove
instead.
Panics
Panics if index
is out of bounds.
Examples
let mut v = vec!["foo", "bar", "baz", "qux"];
assert_eq!(v.swap_remove(1), "bar");
assert_eq!(v, ["foo", "qux", "baz"]);
assert_eq!(v.swap_remove(0), "foo");
assert_eq!(v, ["baz", "qux"]);
Runsourcepub fn remove(&mut self, index: usize) -> T
pub fn remove(&mut self, index: usize) -> T
Removes and returns the element at position index
within the vector,
shifting all elements after it to the left.
Note: Because this shifts over the remaining elements, it has a
worst-case performance of O(n). If you don’t need the order of elements
to be preserved, use swap_remove
instead. If you’d like to remove
elements from the beginning of the Vec
, consider using
VecDeque::pop_front
instead.
Panics
Panics if index
is out of bounds.
Examples
let mut v = vec![1, 2, 3];
assert_eq!(v.remove(1), 2);
assert_eq!(v, [1, 3]);
Runsourcepub fn retain<F>(&mut self, f: F) where
F: FnMut(&T) -> bool,
pub fn retain<F>(&mut self, f: F) where
F: FnMut(&T) -> bool,
Retains only the elements specified by the predicate.
In other words, remove all elements e
for which f(&e)
returns false
.
This method operates in place, visiting each element exactly once in the
original order, and preserves the order of the retained elements.
Examples
let mut vec = vec![1, 2, 3, 4];
vec.retain(|&x| x % 2 == 0);
assert_eq!(vec, [2, 4]);
RunBecause the elements are visited exactly once in the original order, external state may be used to decide which elements to keep.
let mut vec = vec![1, 2, 3, 4, 5];
let keep = [false, true, true, false, true];
let mut iter = keep.iter();
vec.retain(|_| *iter.next().unwrap());
assert_eq!(vec, [2, 3, 5]);
Runsourcepub fn retain_mut<F>(&mut self, f: F) where
F: FnMut(&mut T) -> bool,
pub fn retain_mut<F>(&mut self, f: F) where
F: FnMut(&mut T) -> bool,
Retains only the elements specified by the predicate, passing a mutable reference to it.
In other words, remove all elements e
such that f(&mut e)
returns false
.
This method operates in place, visiting each element exactly once in the
original order, and preserves the order of the retained elements.
Examples
#![feature(vec_retain_mut)]
let mut vec = vec![1, 2, 3, 4];
vec.retain_mut(|x| if *x > 3 {
false
} else {
*x += 1;
true
});
assert_eq!(vec, [2, 3, 4]);
Run1.16.0 · sourcepub fn dedup_by_key<F, K>(&mut self, key: F) where
F: FnMut(&mut T) -> K,
K: PartialEq,
pub fn dedup_by_key<F, K>(&mut self, key: F) where
F: FnMut(&mut T) -> K,
K: PartialEq,
1.16.0 · sourcepub fn dedup_by<F>(&mut self, same_bucket: F) where
F: FnMut(&mut T, &mut T) -> bool,
pub fn dedup_by<F>(&mut self, same_bucket: F) where
F: FnMut(&mut T, &mut T) -> bool,
Removes all but the first of consecutive elements in the vector satisfying a given equality relation.
The same_bucket
function is passed references to two elements from the vector and
must determine if the elements compare equal. The elements are passed in opposite order
from their order in the slice, so if same_bucket(a, b)
returns true
, a
is removed.
If the vector is sorted, this removes all duplicates.
Examples
let mut vec = vec!["foo", "bar", "Bar", "baz", "bar"];
vec.dedup_by(|a, b| a.eq_ignore_ascii_case(b));
assert_eq!(vec, ["foo", "bar", "baz", "bar"]);
Runsourcepub fn pop(&mut self) -> Option<T>
pub fn pop(&mut self) -> Option<T>
Removes the last element from a vector and returns it, or None
if it
is empty.
If you’d like to pop the first element, consider using
VecDeque::pop_front
instead.
Examples
let mut vec = vec![1, 2, 3];
assert_eq!(vec.pop(), Some(3));
assert_eq!(vec, [1, 2]);
Run1.6.0 · sourcepub fn drain<R>(&mut self, range: R) -> Drain<'_, T, A>ⓘNotable traits for Drain<'_, T, A>impl<T, A: Allocator> Iterator for Drain<'_, T, A> type Item = T;
where
R: RangeBounds<usize>,
pub fn drain<R>(&mut self, range: R) -> Drain<'_, T, A>ⓘNotable traits for Drain<'_, T, A>impl<T, A: Allocator> Iterator for Drain<'_, T, A> type Item = T;
where
R: RangeBounds<usize>,
Removes the specified range from the vector in bulk, returning all removed elements as an iterator. If the iterator is dropped before being fully consumed, it drops the remaining removed elements.
The returned iterator keeps a mutable borrow on the vector to optimize its implementation.
Panics
Panics if the starting point is greater than the end point or if the end point is greater than the length of the vector.
Leaking
If the returned iterator goes out of scope without being dropped (due to
mem::forget
, for example), the vector may have lost and leaked
elements arbitrarily, including elements outside the range.
Examples
let mut v = vec![1, 2, 3];
let u: Vec<_> = v.drain(1..).collect();
assert_eq!(v, &[1]);
assert_eq!(u, &[2, 3]);
// A full range clears the vector, like `clear()` does
v.drain(..);
assert_eq!(v, &[]);
Run1.4.0 · sourcepub fn split_off(&mut self, at: usize) -> Self where
A: Clone,
pub fn split_off(&mut self, at: usize) -> Self where
A: Clone,
Splits the collection into two at the given index.
Returns a newly allocated vector containing the elements in the range
[at, len)
. After the call, the original vector will be left containing
the elements [0, at)
with its previous capacity unchanged.
Panics
Panics if at > len
.
Examples
let mut vec = vec![1, 2, 3];
let vec2 = vec.split_off(1);
assert_eq!(vec, [1]);
assert_eq!(vec2, [2, 3]);
Run1.33.0 · sourcepub fn resize_with<F>(&mut self, new_len: usize, f: F) where
F: FnMut() -> T,
pub fn resize_with<F>(&mut self, new_len: usize, f: F) where
F: FnMut() -> T,
Resizes the Vec
in-place so that len
is equal to new_len
.
If new_len
is greater than len
, the Vec
is extended by the
difference, with each additional slot filled with the result of
calling the closure f
. The return values from f
will end up
in the Vec
in the order they have been generated.
If new_len
is less than len
, the Vec
is simply truncated.
This method uses a closure to create new values on every push. If
you’d rather Clone
a given value, use Vec::resize
. If you
want to use the Default
trait to generate values, you can
pass Default::default
as the second argument.
Examples
let mut vec = vec![1, 2, 3];
vec.resize_with(5, Default::default);
assert_eq!(vec, [1, 2, 3, 0, 0]);
let mut vec = vec![];
let mut p = 1;
vec.resize_with(4, || { p *= 2; p });
assert_eq!(vec, [2, 4, 8, 16]);
Run1.47.0 · sourcepub fn leak<'a>(self) -> &'a mut [T] where
A: 'a,
pub fn leak<'a>(self) -> &'a mut [T] where
A: 'a,
Consumes and leaks the Vec
, returning a mutable reference to the contents,
&'a mut [T]
. Note that the type T
must outlive the chosen lifetime
'a
. If the type has only static references, or none at all, then this
may be chosen to be 'static
.
As of Rust 1.57, this method does not reallocate or shrink the Vec
,
so the leaked allocation may include unused capacity that is not part
of the returned slice.
This function is mainly useful for data that lives for the remainder of the program’s life. Dropping the returned reference will cause a memory leak.
Examples
Simple usage:
let x = vec![1, 2, 3];
let static_ref: &'static mut [usize] = x.leak();
static_ref[0] += 1;
assert_eq!(static_ref, &[2, 2, 3]);
Run1.60.0 · sourcepub fn spare_capacity_mut(&mut self) -> &mut [MaybeUninit<T>]
pub fn spare_capacity_mut(&mut self) -> &mut [MaybeUninit<T>]
Returns the remaining spare capacity of the vector as a slice of
MaybeUninit<T>
.
The returned slice can be used to fill the vector with data (e.g. by
reading from a file) before marking the data as initialized using the
set_len
method.
Examples
// Allocate vector big enough for 10 elements.
let mut v = Vec::with_capacity(10);
// Fill in the first 3 elements.
let uninit = v.spare_capacity_mut();
uninit[0].write(0);
uninit[1].write(1);
uninit[2].write(2);
// Mark the first 3 elements of the vector as being initialized.
unsafe {
v.set_len(3);
}
assert_eq!(&v, &[0, 1, 2]);
Runsourcepub fn split_at_spare_mut(&mut self) -> (&mut [T], &mut [MaybeUninit<T>])
pub fn split_at_spare_mut(&mut self) -> (&mut [T], &mut [MaybeUninit<T>])
Returns vector content as a slice of T
, along with the remaining spare
capacity of the vector as a slice of MaybeUninit<T>
.
The returned spare capacity slice can be used to fill the vector with data
(e.g. by reading from a file) before marking the data as initialized using
the set_len
method.
Note that this is a low-level API, which should be used with care for
optimization purposes. If you need to append data to a Vec
you can use push
, extend
, extend_from_slice
,
extend_from_within
, insert
, append
, resize
or
resize_with
, depending on your exact needs.
Examples
#![feature(vec_split_at_spare)]
let mut v = vec![1, 1, 2];
// Reserve additional space big enough for 10 elements.
v.reserve(10);
let (init, uninit) = v.split_at_spare_mut();
let sum = init.iter().copied().sum::<u32>();
// Fill in the next 4 elements.
uninit[0].write(sum);
uninit[1].write(sum * 2);
uninit[2].write(sum * 3);
uninit[3].write(sum * 4);
// Mark the 4 elements of the vector as being initialized.
unsafe {
let len = v.len();
v.set_len(len + 4);
}
assert_eq!(&v, &[1, 1, 2, 4, 8, 12, 16]);
Runsourceimpl<T: Clone, A: Allocator> Vec<T, A>
impl<T: Clone, A: Allocator> Vec<T, A>
1.5.0 · sourcepub fn resize(&mut self, new_len: usize, value: T)
pub fn resize(&mut self, new_len: usize, value: T)
Resizes the Vec
in-place so that len
is equal to new_len
.
If new_len
is greater than len
, the Vec
is extended by the
difference, with each additional slot filled with value
.
If new_len
is less than len
, the Vec
is simply truncated.
This method requires T
to implement Clone
,
in order to be able to clone the passed value.
If you need more flexibility (or want to rely on Default
instead of
Clone
), use Vec::resize_with
.
If you only need to resize to a smaller size, use Vec::truncate
.
Examples
let mut vec = vec!["hello"];
vec.resize(3, "world");
assert_eq!(vec, ["hello", "world", "world"]);
let mut vec = vec![1, 2, 3, 4];
vec.resize(2, 0);
assert_eq!(vec, [1, 2]);
Run1.6.0 · sourcepub fn extend_from_slice(&mut self, other: &[T])
pub fn extend_from_slice(&mut self, other: &[T])
Clones and appends all elements in a slice to the Vec
.
Iterates over the slice other
, clones each element, and then appends
it to this Vec
. The other
slice is traversed in-order.
Note that this function is same as extend
except that it is
specialized to work with slices instead. If and when Rust gets
specialization this function will likely be deprecated (but still
available).
Examples
let mut vec = vec![1];
vec.extend_from_slice(&[2, 3, 4]);
assert_eq!(vec, [1, 2, 3, 4]);
Run1.53.0 · sourcepub fn extend_from_within<R>(&mut self, src: R) where
R: RangeBounds<usize>,
pub fn extend_from_within<R>(&mut self, src: R) where
R: RangeBounds<usize>,
Copies elements from src
range to the end of the vector.
Panics
Panics if the starting point is greater than the end point or if the end point is greater than the length of the vector.
Examples
let mut vec = vec![0, 1, 2, 3, 4];
vec.extend_from_within(2..);
assert_eq!(vec, [0, 1, 2, 3, 4, 2, 3, 4]);
vec.extend_from_within(..2);
assert_eq!(vec, [0, 1, 2, 3, 4, 2, 3, 4, 0, 1]);
vec.extend_from_within(4..8);
assert_eq!(vec, [0, 1, 2, 3, 4, 2, 3, 4, 0, 1, 4, 2, 3, 4]);
Runsourceimpl<T, A: Allocator> Vec<T, A>
impl<T, A: Allocator> Vec<T, A>
1.21.0 · sourcepub fn splice<R, I>(
&mut self,
range: R,
replace_with: I
) -> Splice<'_, I::IntoIter, A>ⓘNotable traits for Splice<'_, I, A>impl<I: Iterator, A: Allocator> Iterator for Splice<'_, I, A> type Item = I::Item;
where
R: RangeBounds<usize>,
I: IntoIterator<Item = T>,
pub fn splice<R, I>(
&mut self,
range: R,
replace_with: I
) -> Splice<'_, I::IntoIter, A>ⓘNotable traits for Splice<'_, I, A>impl<I: Iterator, A: Allocator> Iterator for Splice<'_, I, A> type Item = I::Item;
where
R: RangeBounds<usize>,
I: IntoIterator<Item = T>,
Creates a splicing iterator that replaces the specified range in the vector
with the given replace_with
iterator and yields the removed items.
replace_with
does not need to be the same length as range
.
range
is removed even if the iterator is not consumed until the end.
It is unspecified how many elements are removed from the vector
if the Splice
value is leaked.
The input iterator replace_with
is only consumed when the Splice
value is dropped.
This is optimal if:
- The tail (elements in the vector after
range
) is empty, - or
replace_with
yields fewer or equal elements thanrange
’s length - or the lower bound of its
size_hint()
is exact.
Otherwise, a temporary vector is allocated and the tail is moved twice.
Panics
Panics if the starting point is greater than the end point or if the end point is greater than the length of the vector.
Examples
let mut v = vec![1, 2, 3, 4];
let new = [7, 8, 9];
let u: Vec<_> = v.splice(1..3, new).collect();
assert_eq!(v, &[1, 7, 8, 9, 4]);
assert_eq!(u, &[2, 3]);
Runsourcepub fn drain_filter<F>(&mut self, filter: F) -> DrainFilter<'_, T, F, A>ⓘNotable traits for DrainFilter<'_, T, F, A>impl<T, F, A: Allocator> Iterator for DrainFilter<'_, T, F, A> where
F: FnMut(&mut T) -> bool, type Item = T;
where
F: FnMut(&mut T) -> bool,
pub fn drain_filter<F>(&mut self, filter: F) -> DrainFilter<'_, T, F, A>ⓘNotable traits for DrainFilter<'_, T, F, A>impl<T, F, A: Allocator> Iterator for DrainFilter<'_, T, F, A> where
F: FnMut(&mut T) -> bool, type Item = T;
where
F: FnMut(&mut T) -> bool,
F: FnMut(&mut T) -> bool, type Item = T;
Creates an iterator which uses a closure to determine if an element should be removed.
If the closure returns true, then the element is removed and yielded. If the closure returns false, the element will remain in the vector and will not be yielded by the iterator.
Using this method is equivalent to the following code:
let mut i = 0;
while i < vec.len() {
if some_predicate(&mut vec[i]) {
let val = vec.remove(i);
// your code here
} else {
i += 1;
}
}
RunBut drain_filter
is easier to use. drain_filter
is also more efficient,
because it can backshift the elements of the array in bulk.
Note that drain_filter
also lets you mutate every element in the filter closure,
regardless of whether you choose to keep or remove it.
Examples
Splitting an array into evens and odds, reusing the original allocation:
#![feature(drain_filter)]
let mut numbers = vec![1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15];
let evens = numbers.drain_filter(|x| *x % 2 == 0).collect::<Vec<_>>();
let odds = numbers;
assert_eq!(evens, vec![2, 4, 6, 8, 14]);
assert_eq!(odds, vec![1, 3, 5, 9, 11, 13, 15]);
RunMethods from Deref<Target = [T]>
sourcepub fn sort(&mut self) where
T: Ord,
pub fn sort(&mut self) where
T: Ord,
Sorts the slice.
This sort is stable (i.e., does not reorder equal elements) and O(n * log(n)) worst-case.
When applicable, unstable sorting is preferred because it is generally faster than stable
sorting and it doesn’t allocate auxiliary memory.
See sort_unstable
.
Current implementation
The current algorithm is an adaptive, iterative merge sort inspired by timsort. It is designed to be very fast in cases where the slice is nearly sorted, or consists of two or more sorted sequences concatenated one after another.
Also, it allocates temporary storage half the size of self
, but for short slices a
non-allocating insertion sort is used instead.
Examples
let mut v = [-5, 4, 1, -3, 2];
v.sort();
assert!(v == [-5, -3, 1, 2, 4]);
Runsourcepub fn sort_by<F>(&mut self, compare: F) where
F: FnMut(&T, &T) -> Ordering,
pub fn sort_by<F>(&mut self, compare: F) where
F: FnMut(&T, &T) -> Ordering,
Sorts the slice with a comparator function.
This sort is stable (i.e., does not reorder equal elements) and O(n * log(n)) worst-case.
The comparator function must define a total ordering for the elements in the slice. If
the ordering is not total, the order of the elements is unspecified. An order is a
total order if it is (for all a
, b
and c
):
- total and antisymmetric: exactly one of
a < b
,a == b
ora > b
is true, and - transitive,
a < b
andb < c
impliesa < c
. The same must hold for both==
and>
.
For example, while f64
doesn’t implement Ord
because NaN != NaN
, we can use
partial_cmp
as our sort function when we know the slice doesn’t contain a NaN
.
let mut floats = [5f64, 4.0, 1.0, 3.0, 2.0];
floats.sort_by(|a, b| a.partial_cmp(b).unwrap());
assert_eq!(floats, [1.0, 2.0, 3.0, 4.0, 5.0]);
RunWhen applicable, unstable sorting is preferred because it is generally faster than stable
sorting and it doesn’t allocate auxiliary memory.
See sort_unstable_by
.
Current implementation
The current algorithm is an adaptive, iterative merge sort inspired by timsort. It is designed to be very fast in cases where the slice is nearly sorted, or consists of two or more sorted sequences concatenated one after another.
Also, it allocates temporary storage half the size of self
, but for short slices a
non-allocating insertion sort is used instead.
Examples
let mut v = [5, 4, 1, 3, 2];
v.sort_by(|a, b| a.cmp(b));
assert!(v == [1, 2, 3, 4, 5]);
// reverse sorting
v.sort_by(|a, b| b.cmp(a));
assert!(v == [5, 4, 3, 2, 1]);
Run1.7.0 · sourcepub fn sort_by_key<K, F>(&mut self, f: F) where
F: FnMut(&T) -> K,
K: Ord,
pub fn sort_by_key<K, F>(&mut self, f: F) where
F: FnMut(&T) -> K,
K: Ord,
Sorts the slice with a key extraction function.
This sort is stable (i.e., does not reorder equal elements) and O(m * n * log(n)) worst-case, where the key function is O(m).
For expensive key functions (e.g. functions that are not simple property accesses or
basic operations), sort_by_cached_key
is likely to be
significantly faster, as it does not recompute element keys.
When applicable, unstable sorting is preferred because it is generally faster than stable
sorting and it doesn’t allocate auxiliary memory.
See sort_unstable_by_key
.
Current implementation
The current algorithm is an adaptive, iterative merge sort inspired by timsort. It is designed to be very fast in cases where the slice is nearly sorted, or consists of two or more sorted sequences concatenated one after another.
Also, it allocates temporary storage half the size of self
, but for short slices a
non-allocating insertion sort is used instead.
Examples
let mut v = [-5i32, 4, 1, -3, 2];
v.sort_by_key(|k| k.abs());
assert!(v == [1, 2, -3, 4, -5]);
Run1.34.0 · sourcepub fn sort_by_cached_key<K, F>(&mut self, f: F) where
F: FnMut(&T) -> K,
K: Ord,
pub fn sort_by_cached_key<K, F>(&mut self, f: F) where
F: FnMut(&T) -> K,
K: Ord,
Sorts the slice with a key extraction function.
During sorting, the key function is called at most once per element, by using temporary storage to remember the results of key evaluation. The order of calls to the key function is unspecified and may change in future versions of the standard library.
This sort is stable (i.e., does not reorder equal elements) and O(m * n + n * log(n)) worst-case, where the key function is O(m).
For simple key functions (e.g., functions that are property accesses or
basic operations), sort_by_key
is likely to be
faster.
Current implementation
The current algorithm is based on pattern-defeating quicksort by Orson Peters, which combines the fast average case of randomized quicksort with the fast worst case of heapsort, while achieving linear time on slices with certain patterns. It uses some randomization to avoid degenerate cases, but with a fixed seed to always provide deterministic behavior.
In the worst case, the algorithm allocates temporary storage in a Vec<(K, usize)>
the
length of the slice.
Examples
let mut v = [-5i32, 4, 32, -3, 2];
v.sort_by_cached_key(|k| k.to_string());
assert!(v == [-3, -5, 2, 32, 4]);
Runsourcepub fn concat<Item: ?Sized>(&self) -> <Self as Concat<Item>>::Output where
Self: Concat<Item>,
pub fn concat<Item: ?Sized>(&self) -> <Self as Concat<Item>>::Output where
Self: Concat<Item>,
1.3.0 · sourcepub fn join<Separator>(
&self,
sep: Separator
) -> <Self as Join<Separator>>::Output where
Self: Join<Separator>,
pub fn join<Separator>(
&self,
sep: Separator
) -> <Self as Join<Separator>>::Output where
Self: Join<Separator>,
1.23.0 · sourcepub fn to_ascii_uppercase(&self) -> Vec<u8>
pub fn to_ascii_uppercase(&self) -> Vec<u8>
Returns a vector containing a copy of this slice where each byte is mapped to its ASCII upper case equivalent.
ASCII letters ‘a’ to ‘z’ are mapped to ‘A’ to ‘Z’, but non-ASCII letters are unchanged.
To uppercase the value in-place, use make_ascii_uppercase
.
1.23.0 · sourcepub fn to_ascii_lowercase(&self) -> Vec<u8>
pub fn to_ascii_lowercase(&self) -> Vec<u8>
Returns a vector containing a copy of this slice where each byte is mapped to its ASCII lower case equivalent.
ASCII letters ‘A’ to ‘Z’ are mapped to ‘a’ to ‘z’, but non-ASCII letters are unchanged.
To lowercase the value in-place, use make_ascii_lowercase
.
Trait Implementations
sourceimpl<T> BorrowMut<[T]> for Vec<T>
impl<T> BorrowMut<[T]> for Vec<T>
sourcefn borrow_mut(&mut self) -> &mut [T]
fn borrow_mut(&mut self) -> &mut [T]
Mutably borrows from an owned value. Read more
1.2.0 · sourceimpl<'a, T: Copy + 'a, A: Allocator + 'a> Extend<&'a T> for Vec<T, A>
impl<'a, T: Copy + 'a, A: Allocator + 'a> Extend<&'a T> for Vec<T, A>
Extend implementation that copies elements out of references before pushing them onto the Vec.
This implementation is specialized for slice iterators, where it uses copy_from_slice
to
append the entire slice at once.
sourcefn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I)
fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I)
Extends a collection with the contents of an iterator. Read more
sourcefn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
Reserves capacity in a collection for the given number of additional elements. Read more
sourceimpl<T, A: Allocator> Extend<T> for Vec<T, A>
impl<T, A: Allocator> Extend<T> for Vec<T, A>
sourcefn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)
fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I)
Extends a collection with the contents of an iterator. Read more
sourcefn extend_reserve(&mut self, additional: usize)
fn extend_reserve(&mut self, additional: usize)
Reserves capacity in a collection for the given number of additional elements. Read more
1.19.0 · sourceimpl<T: Clone> From<&'_ mut [T]> for Vec<T>
impl<T: Clone> From<&'_ mut [T]> for Vec<T>
1.5.0 · sourceimpl<T> From<BinaryHeap<T>> for Vec<T>
impl<T> From<BinaryHeap<T>> for Vec<T>
sourcefn from(heap: BinaryHeap<T>) -> Vec<T>
fn from(heap: BinaryHeap<T>) -> Vec<T>
Converts a BinaryHeap<T>
into a Vec<T>
.
This conversion requires no data movement or allocation, and has constant time complexity.
1.14.0 · sourceimpl<'a, T> From<Cow<'a, [T]>> for Vec<T> where
[T]: ToOwned<Owned = Vec<T>>,
impl<'a, T> From<Cow<'a, [T]>> for Vec<T> where
[T]: ToOwned<Owned = Vec<T>>,
sourcefn from(s: Cow<'a, [T]>) -> Vec<T>
fn from(s: Cow<'a, [T]>) -> Vec<T>
Convert a clone-on-write slice into a vector.
If s
already owns a Vec<T>
, it will be returned directly.
If s
is borrowing a slice, a new Vec<T>
will be allocated and
filled by cloning s
’s items into it.
Examples
let o: Cow<[i32]> = Cow::Owned(vec![1, 2, 3]);
let b: Cow<[i32]> = Cow::Borrowed(&[1, 2, 3]);
assert_eq!(Vec::from(o), Vec::from(b));
Run1.10.0 · sourceimpl<T, A: Allocator> From<Vec<T, A>> for VecDeque<T, A>
impl<T, A: Allocator> From<Vec<T, A>> for VecDeque<T, A>
sourcefn from(other: Vec<T, A>) -> Self
fn from(other: Vec<T, A>) -> Self
Turn a Vec<T>
into a VecDeque<T>
.
This avoids reallocating where possible, but the conditions for that are
strict, and subject to change, and so shouldn’t be relied upon unless the
Vec<T>
came from From<VecDeque<T>>
and hasn’t been reallocated.
1.5.0 · sourceimpl<T: Ord> From<Vec<T, Global>> for BinaryHeap<T>
impl<T: Ord> From<Vec<T, Global>> for BinaryHeap<T>
sourcefn from(vec: Vec<T>) -> BinaryHeap<T>
fn from(vec: Vec<T>) -> BinaryHeap<T>
Converts a Vec<T>
into a BinaryHeap<T>
.
This conversion happens in-place, and has O(n) time complexity.
1.10.0 · sourceimpl<T, A: Allocator> From<VecDeque<T, A>> for Vec<T, A>
impl<T, A: Allocator> From<VecDeque<T, A>> for Vec<T, A>
sourcefn from(other: VecDeque<T, A>) -> Self
fn from(other: VecDeque<T, A>) -> Self
Turn a VecDeque<T>
into a Vec<T>
.
This never needs to re-allocate, but does need to do O(n) data movement if the circular buffer doesn’t happen to be at the beginning of the allocation.
Examples
use std::collections::VecDeque;
// This one is *O*(1).
let deque: VecDeque<_> = (1..5).collect();
let ptr = deque.as_slices().0.as_ptr();
let vec = Vec::from(deque);
assert_eq!(vec, [1, 2, 3, 4]);
assert_eq!(vec.as_ptr(), ptr);
// This one needs data rearranging.
let mut deque: VecDeque<_> = (1..5).collect();
deque.push_front(9);
deque.push_front(8);
let ptr = deque.as_slices().1.as_ptr();
let vec = Vec::from(deque);
assert_eq!(vec, [8, 9, 1, 2, 3, 4]);
assert_eq!(vec.as_ptr(), ptr);
Runsourceimpl<T> FromIterator<T> for Vec<T>
impl<T> FromIterator<T> for Vec<T>
sourcefn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Vec<T>
fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Vec<T>
Creates a value from an iterator. Read more
sourceimpl<T: Hash, A: Allocator> Hash for Vec<T, A>
impl<T: Hash, A: Allocator> Hash for Vec<T, A>
The hash of a vector is the same as that of the corresponding slice,
as required by the core::borrow::Borrow
implementation.
#![feature(build_hasher_simple_hash_one)]
use std::hash::BuildHasher;
let b = std::collections::hash_map::RandomState::new();
let v: Vec<u8> = vec![0xa8, 0x3c, 0x09];
let s: &[u8] = &[0xa8, 0x3c, 0x09];
assert_eq!(b.hash_one(v), b.hash_one(s));
Runsourceimpl<T, A: Allocator> IntoIterator for Vec<T, A>
impl<T, A: Allocator> IntoIterator for Vec<T, A>
sourceimpl<'a, T, A: Allocator> IntoIterator for &'a Vec<T, A>
impl<'a, T, A: Allocator> IntoIterator for &'a Vec<T, A>
sourceimpl<'a, T, A: Allocator> IntoIterator for &'a mut Vec<T, A>
impl<'a, T, A: Allocator> IntoIterator for &'a mut Vec<T, A>
sourceimpl<T: Ord, A: Allocator> Ord for Vec<T, A>
impl<T: Ord, A: Allocator> Ord for Vec<T, A>
Implements ordering of vectors, lexicographically.
sourceimpl<T, U, A: Allocator, const N: usize> PartialEq<&'_ [U; N]> for Vec<T, A> where
T: PartialEq<U>,
impl<T, U, A: Allocator, const N: usize> PartialEq<&'_ [U; N]> for Vec<T, A> where
T: PartialEq<U>,
sourceimpl<T, U, A: Allocator, const N: usize> PartialEq<[U; N]> for Vec<T, A> where
T: PartialEq<U>,
impl<T, U, A: Allocator, const N: usize> PartialEq<[U; N]> for Vec<T, A> where
T: PartialEq<U>,
1.17.0 · sourceimpl<T, U, A: Allocator> PartialEq<Vec<U, A>> for VecDeque<T, A> where
T: PartialEq<U>,
impl<T, U, A: Allocator> PartialEq<Vec<U, A>> for VecDeque<T, A> where
T: PartialEq<U>,
sourceimpl<T, U, A: Allocator> PartialEq<Vec<U, A>> for Cow<'_, [T]> where
T: PartialEq<U>,
T: Clone,
impl<T, U, A: Allocator> PartialEq<Vec<U, A>> for Cow<'_, [T]> where
T: PartialEq<U>,
T: Clone,
sourceimpl<T, U, A1: Allocator, A2: Allocator> PartialEq<Vec<U, A2>> for Vec<T, A1> where
T: PartialEq<U>,
impl<T, U, A1: Allocator, A2: Allocator> PartialEq<Vec<U, A2>> for Vec<T, A1> where
T: PartialEq<U>,
sourceimpl<T: PartialOrd, A: Allocator> PartialOrd<Vec<T, A>> for Vec<T, A>
impl<T: PartialOrd, A: Allocator> PartialOrd<Vec<T, A>> for Vec<T, A>
Implements comparison of vectors, lexicographically.
sourcefn partial_cmp(&self, other: &Self) -> Option<Ordering>
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
1.48.0 · sourceimpl<T, A: Allocator, const N: usize> TryFrom<Vec<T, A>> for [T; N]
impl<T, A: Allocator, const N: usize> TryFrom<Vec<T, A>> for [T; N]
sourcefn try_from(vec: Vec<T, A>) -> Result<[T; N], Vec<T, A>>
fn try_from(vec: Vec<T, A>) -> Result<[T; N], Vec<T, A>>
Gets the entire contents of the Vec<T>
as an array,
if its size exactly matches that of the requested array.
Examples
assert_eq!(vec![1, 2, 3].try_into(), Ok([1, 2, 3]));
assert_eq!(<Vec<i32>>::new().try_into(), Ok([]));
RunIf the length doesn’t match, the input comes back in Err
:
let r: Result<[i32; 4], _> = (0..10).collect::<Vec<_>>().try_into();
assert_eq!(r, Err(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));
RunIf you’re fine with just getting a prefix of the Vec<T>
,
you can call .truncate(N)
first.
let mut v = String::from("hello world").into_bytes();
v.sort();
v.truncate(2);
let [a, b]: [_; 2] = v.try_into().unwrap();
assert_eq!(a, b' ');
assert_eq!(b, b'd');
Runimpl<T: Eq, A: Allocator> Eq for Vec<T, A>
Auto Trait Implementations
impl<T, A> RefUnwindSafe for Vec<T, A> where
A: RefUnwindSafe,
T: RefUnwindSafe,
impl<T, A> Send for Vec<T, A> where
A: Send,
T: Send,
impl<T, A> Sync for Vec<T, A> where
A: Sync,
T: Sync,
impl<T, A> Unpin for Vec<T, A> where
A: Unpin,
T: Unpin,
impl<T, A> UnwindSafe for Vec<T, A> where
A: UnwindSafe,
T: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
Uses borrowed data to replace owned data, usually by cloning. Read more