我可以直接从 C++ 中向量元素的指针获取索引吗？

Question

我有一个大型矢量容器，可容纳大约 300.000 个对象。我也有指向这些对象的指针。

有没有使用指针快速获取向量中对象索引的方法？

Answer 1

由于向量是按顺序组织的，因此可以通过从指向元素的指针中减去指向初始元素的指针来获得索引：

std::vector<MyObject> vect;
MyObject *ptrX = ... // Pointer to element in question
ptrdiff_t index = ptrX - &vect[0];

Answer 2

Iterator header 在这种情况下应该很有用。

假设你有类似的东西：

using Vector = std::vector<Foo>;
using Iterator = Vector::iterator;

Vector big_vector;

现在你有了一个对象的迭代器：

Iterator p_obj = get_Theobj(big_vector);

使用distance可以轻松获取索引：

auto index = std::distance(big_vector.begin(), p_obj);
// Note: index's type is a `difference_type` aka ptrdiff_t (usually signed integer).

使用这种方法的强大之处在于其多功能性。事实上，它也适用于“类 C 向量”、std::array、std::list。

Answer 3

您可以使用std::distance

 std::vector<Object> objects = /*..*/;
 const Object *p = /* object[i] */;
 std::ptrdiff_t index = std::distance(objects.data(), p);
 // Now index == i.

Answer 4

这里有很多很好的答案。将它们组合在一起，这是一个小型库套件，它允许通过指针或引用计算项目的索引。

作为额外的好处，调用者可以选择提供一个策略对象，如果元素不在容器中，则执行该对象。

#include <stdexcept>
#include <cassert>
#include <vector>


struct exception_policy
{
    [[noreturn]]
    std::size_t out_of_range() const
    {
        throw std::out_of_range("index_of_element");
    }
};

struct assertion_policy
{
    std::size_t out_of_range() const
    {
        assert(!"out of range");
        return _fallback.out_of_range();
    }

    exception_policy _fallback {};
};

struct zero_policy
{
    std::size_t out_of_range() const
    {
        return 0;
    }
};

template<class T, class A, class Policy = exception_policy>
std::size_t index_of_element(std::vector<T, A> const& vec,
                             typename std::vector<T, A>::const_pointer pitem,
                             Policy policy = Policy{})
{
    auto pbegin = vec.data();
    auto pend = pbegin + vec.size();
    if (pitem < pbegin or pitem >= pend)
    {
        return policy.out_of_range();
    }
    else
    {
        return std::distance(pbegin, pitem);
    }
}

template<class T, class A, class Policy = exception_policy>
std::size_t index_of_element(std::vector<T, A> const& vec,
                      typename std::vector<T, A>::const_reference item, Policy policy = Policy{})
{
    return index_of_element(vec, std::addressof(item), policy);
}

int main()
{
    std::vector<int> v = { 1, 2, 3, 4, 5, 6, 7, 8 };
    auto px = std::addressof(v[5]);
    auto& rx = *px;

    try {
        // use default policy of throwing out_of_range...
        auto i = index_of_element(v, rx);
        assert(i == 5);
    }
    catch(...)
    {
        assert(!"should not throw");
    }

    try {
        auto i = index_of_element(v, px);
        assert(i == 5);
    }
    catch(...)
    {
        assert(!"should not throw");
    }

    auto py = v.data() + 1000;  // out of bounds
    try {
        auto i = index_of_element(v, py);
        assert(!"should have thrown");
    }
    catch(std::out_of_range const& e)
    {
        // success
    }
    catch(...)
    {
        assert(!"should not throw this");
    }

    // specify a custom policy
    auto i = index_of_element(v, ry, zero_policy());
    assert(i == 0);    
}

Answer 5

int getIndex(Object* pObject) {return pObject - &(my_vewctor[0]);}

Answer 6

假设至少 C++11：

你有一些class Myclass;（希望是一个相当小的，因为你有很多实例）。

你有一些变量std::vector<Myclass> bigvec;，它足够大，可以有大约一百万个对象。

您有一些有效的指针 Myclass* ptr;，它可以指向来自 bigvec 的对象内部。

您可能会在int ix;（或更好的是size_t ix;）中使用

获得其索引在bigvec

if (ptr >= bigvec.data() && ptr < bigvec.data() + bigvec.size())
  ix = ptr - bigvec.data();

但是，请注意，您可以制作Myclass 的副本（例如，通过赋值、按值传递某个参数等...），然后获得指向此类副本的指针不要在bigvec