CODEWITHSUNDEEP
pointersvectorrust
ideasman42
ideasman42

Reputation: 47978

How to get the index of an element in a vector using pointer arithmetic?

In C you can use the pointer offset to get index of an element within an array, e.g.:

index = element_pointer - &vector[0];

Given a reference to an element in an array, this should be possible in Rust too.

While Rust has the ability to get the memory address from vector elements, convert them to usize, then subtract them - is there a more convenient/idiomatic way to do this in Rust?

Upvotes: 4

Views: 2445

Answers (2)

ubsan
ubsan

Reputation: 70

So, given the issues which people have brought up with the pointers and stuff; the best way, imho, to do this is:

fn index_of_unchecked<T>(slice: &[T], item: &T) -> usize {
    if ::std::mem::size_of::<T>() == 0 {
        return 0; // do what you will with this case
    }
    (item as *const _ as usize - slice.as_ptr() as usize)
    / std::mem::size_of::<T>()
}

// note: for zero sized types here, you
// return Some(0) if item as *const T == slice.as_ptr()
// and None otherwise
fn index_of<T>(slice: &[T], item: &T) -> Option<usize> {
    let ptr = item as *const T;
    if
        slice.as_ptr() < ptr && 
        slice.as_ptr().offset(slice.len()) > ptr
    {
        Some(index_of_unchecked(slice, item))
    } else {
        None
    }
}

although, if you want methods:

trait IndexOfExt<T> {
    fn index_of_unchecked(&self, item: &T) -> usize;
    fn index_of(&self, item: &T) -> Option<usize>;
}

impl<T> IndexOfExt<T> for [T] {
    fn index_of_unchecked(&self, item: &T) -> usize {
        // ...
    }
    fn index_of(&self, item: &T) -> Option<usize> {
        // ...
    }
}

and then you'll be able to use this method for any type that Derefs to [T]

Upvotes: 2

Chris Emerson
Chris Emerson

Reputation: 14021

There isn't a simpler way. I think the reason is that it would be hard to guarantee that any operation or method that gave you that answer only allowed you to use it with the a Vec (or more likely slice) and something inside that collection; Rust wouldn't want to allow you to call it with a reference into a different vector.

More idiomatic would be to avoid needing to do it in the first place. You can't store references into Vec anywhere very permanent away from the Vec anyway due to lifetimes, so you're likely to have the index handy when you've got the reference anyway.

In particular, when iterating, for example, you'd use the enumerate to iterate over pairs (index, &item).

Upvotes: 5

Related Questions