如何获得std :: list ::来自该列表元素的iterator？

Question

给出一个std :: list

std::list< int > myList

以及该列表中元素的引用（或指针）

int& myElement    |     int* pElement

所以，基本上我知道那个元素的地址

如何有效地获得std::list<int>::iterator到该元素？

一个缓慢但有效的例子是

const_iterator it
for( it = myList.begin(); it != &myElement; ++it)
{
    // do nothing, for loop terminates if "it" points to "myElem"
}

有更快的方法吗？喜欢

const_iterator it = magicToIteratorConverter( myList, myElem )

矢量的情况（但我需要清单）：

对于矢量，您可以执行以下操作：

const int* pStart = &myVector[0] // address of first element
const int* pElement = &myElem; // address of my element
const idx = static_cast< int >( pElement- pStart ); // no need to divide by size of an elem

std::vector< int >::iterator it = myVector.begin() + idx;

std :: list的案例：

Answer 1

这实际上是一个很好的问题，恕我直言，没有什么标准的方法来做OP所要求的。如果您了解列表节点看起来基本上是这样的

struct list_node {
    list_node* prev;
    list_node* next;
    T yourType;
}

如果你有一个指向yourType的指针而不搜索整个容器，那么没有默认的方法来到节点（迭代器是指向节点的指针）是很糟糕的。

---

由于标准没有帮助你必须弄脏你的手：

#include <list>
#include <iostream>

//This is essentially what you are looking for:
std::list<int>::iterator pointerToIter (int* myPointer) {
    //Calculates the distance in bytes from an iterator itself
    //to the actual type that is stored at the position the
    //iterator is pointing to.
    size_t iterOffset = (size_t)&(*((std::list<void*>::iterator)nullptr));
    //Subtract the offset from the passed pointer and make an
    //iterator out of it
    std::list<int>::iterator iter;
    *(intptr_t*)&iter = (intptr_t)myPointer - iterOffset;
    //You are done
    return iter;
}

int main () {
    std::list<int> intList;
    intList.push_back (10);
    int* i1 = &intList.back ();
    intList.push_back (20);
    intList.push_back (30);
    int* i3 = &intList.back ();
    intList.push_back (40);
    intList.push_back (50);
    int* i5 = &intList.back ();

    std::cout << "Size: " << intList.size () << " | Content: ";
    for (const int& value : intList)
        std::cout << value << " ";
    std::cout << std::endl;

    intList.erase (pointerToIter (i1));
    intList.erase (pointerToIter (i3));
    intList.erase (pointerToIter (i5));

    std::cout << "Size: " << intList.size () << " | Content: ";
    for (const int& value : intList)
        std::cout << value << " ";
    std::cout << std::endl;
    return 0;
}

输出（以证明它按预期工作）：

大小：5 |内容：10 20 30 40 50 尺寸：2 |内容：20 40

即使std :: list的实现将为列表节点使用不同的布局或向其添加更多成员，这也可以完美地工作。我还包括生成的汇编程序代码，以查看该函数实际上已减少到myPointer - 0x10，这是64位机器上2个指针的大小。

汇编程序（至少-O1）：

std::list<int>::iterator pointerToIter (int* myPointer) {
   0:   48 8d 47 f0             lea    rax,[rdi-0x10]
}
   4:   c3                      ret    

Answer 2

一个std::list<int>::iterator不是int*，你需要访问迭代器中的元素并获取其地址。此外，std::find_if为您处理大部分样板。

auto iter = std:find_if(myList.begin(), myList.end(),
                        [&myElement](const int & listElement)
                        { return &myElement == &listElement; });

自己编写循环看起来像：

auto iter = myList.end();

for(auto i = myList.begin(); i != myList.end(); ++i)
    if(&*i == &myElement)
    {
        iter = i;
        break;
    }

Answer 3

给定一个列表，你只能从一端开始走过它，确保你不会超越结束。

const_iterator it, end;
for( it = myList.begin(), end = myList.end(); it!=end && it != &myElement; ++it)
{
    // do nothing, for loop terminates if "it" points to "myElem"
      // or if we don't find your element.
}

当然，您可以使用标准算法，如std::find来查找它。

或者，您可以在插入时保持迭代器的持久性，并且在许多条件下它将在以后仍然有效。

如果你想要查找速度，你应该使用除列表之外的东西。

---

如果你有类似的东西

int x = 42;
int * this_might_be_handy = &x;
myList.insert(x);

myList现在有一个COPY数字 - 它的值为42，但位于不同的内存位置。

如果您在列表中保留指向int的指针，则会有所不同。从列表的front获取值并查看地址将不会提供与x相同的地址。

但你必须聪明地管理它们。