分配std :: shared_ptr的集合以进行缓存

Question

I have a list of elements std::vector<Foo> which I need to transform into a list of std::shared_ptr<Foo> 's:

auto make_shared(const std::vector<Foo>& foos)
{
    std::vector<std::shared_ptr<Foo>> result(foos.size());
    std::transform(std::begin(foos), std::cend(foos), std::begin(result), 
                   [] (const Foo& foo) { return std::make_shared<Foo>(foo); });
    return result;
}

I later use the addresses of the pointed to elements in a cache using a std::unordered_map . I've found accessing the map to be expensive, and was wondering if I could replace it with a std::vector given that I know the addresses of all the elements before the first cache lookup:

auto complex_calculation(const Foo& foo)
{
    const auto idx = std::distance(first_foo_ptr_, std::addressof(foo));
    // lookup idx in std::vector...
}

As far as I'm aware, there are two problems with doing this:

1. The elements may not be located close to each other in memory, meaning the size of the std::vector could be very large. Is this possible
2. operator< (or std::less ) are not suitable for calculating offsets bases on address order.

Is it possible to use a custom allocator in this situation to resolve both issues?

Answer 1

As you note, std::vector doesn't save you anything (as a fixed-time lookup), because the size of the vector would need to be the size of the entire addressable memory space (or at least the heap).

I'd focus on the use-case: are you trying to find the address of the shared_ptr instance which contains a Foo, or something else? In the former case, I'd look into shared_from_this, for a possible trivial solution. In the latter case, you'd need to consider other design options (eg: if you're looking up the shared_ptr for an "equivalent" Foo, consider an ID method, and std::map lookup, or equivalent).