70

我在全局范围内有一个 myObjects 向量。我有一种方法，它使用 astd::vector<myObject>::const_iterator来遍历向量，并进行一些比较以找到特定元素。一旦我找到了所需的元素，我希望能够返回一个指向它的指针（向量存在于全局范围内）。

如果我 return &iterator，我是返回迭代器的地址还是迭代器指向的地址？

我是否需要将const_iteratorback 转换为 myObject，然后返回它的地址？

4

9 回答 9

103

返回迭代器指向的事物的地址：

&(*iterator)

编辑：为了消除一些混乱：

vector <int> vec;          // a global vector of ints

void f() {
   vec.push_back( 1 );    // add to the global vector
   vector <int>::iterator it = vec.begin();
   * it = 2;              // change what was 1 to 2
   int * p = &(*it);      // get pointer to first element
   * p = 3;               // change what was 2 to 3
}

不需要指针向量或动态分配。

于 2009-03-13T09:01:33.517 回答
15

返回 &iterator 将返回迭代器的地址。如果您想返回一种引用元素的方式，请返回迭代器本身。

请注意，您不需要将向量设为全局才能返回迭代器/指针，但向量中的操作可能会使迭代器无效。例如，如果新的 size() 大于保留的内存，则向向量添加元素可以将向量元素移动到不同的位置。从向量中删除给定项之前的元素将使迭代器引用不同的元素。

在这两种情况下，根据 STL 实现，可能很难调试，只是随机错误经常发生。

评论后编辑：'是的，我不想返回迭代器 a）因为它的 const 和 b）肯定它只是一个本地的临时迭代器？——克拉科斯

迭代器不比任何其他变量更多或更少是本地或临时的，它们是可复制的。您可以返回它，编译器将为您制作副本，就像使用指针一样。

现在有了常量。如果调用者想要通过返回的元素（无论是指针还是迭代器）执行修改，那么您应该使用非常量迭代器。（只需从迭代器的定义中删除“const_”）。

于 2009-03-13T09:03:54.150 回答
6

您可以使用向量的数据函数：

返回指向向量中第一个元素的指针。

如果不想要指向第一个元素的指针，而是通过索引，那么您可以尝试，例如：

//the index to the element that you want to receive its pointer:
int i = n; //(n is whatever integer you want)

std::vector<myObject> vec;
myObject* ptr_to_first = vec.data();

//or

std::vector<myObject>* vec;
myObject* ptr_to_first = vec->data();

//then

myObject element = ptr_to_first[i]; //element at index i
myObject* ptr_to_element = &element;
于 2014-09-05T19:41:38.137 回答
3

返回迭代器不是一个好主意。当对向量（inversion\deletion）进行修改时，迭代器变得无效。此外，迭代器是在堆栈上创建的本地对象，因此返回相同的地址根本不安全。我建议您使用 myObject 而不是矢量迭代器。

编辑： 如果对象是轻量级的，那么最好返回对象本身。否则返回指向存储在向量中的 myObject 的指针。

于 2009-03-13T09:02:21.033 回答
3

只要您的向量保持在全局范围内，您就可以返回：

&(*iterator)

我会提醒你，这通常是非常危险的。如果您的向量曾经移出全局范围并被破坏，则任何指向 myObject 的指针都将变为无效。如果您将这些函数编写为较大项目的一部分，则返回非常量指针可能会导致某人删除返回值。这将对应用程序产生不确定的和灾难性的影响。

我将其重写为：

myObject myFunction(const vector<myObject>& objects)
{
    // find the object in question and return a copy
    return *iterator;
}

如果您需要修改返回的 myObject，请将您的值存储为指针并在堆上分配它们：

myObject* myFunction(const vector<myObject*>& objects)
{
    return *iterator;
}

这样你就可以控制它们何时被破坏。

这样的事情会破坏你的应用程序：

g_vector<tmpClass> myVector;

    tmpClass t;
    t.i = 30;
    myVector.push_back(t);

    // my function returns a pointer to a value in myVector
    std::auto_ptr<tmpClass> t2(myFunction());
于 2009-03-13T12:34:01.413 回答
0

说，您有以下内容：

std::vector<myObject>::const_iterator first = vObj.begin();

那么向量中的第一个对象是：*first。要获取地址，请使用：&(*first)。

但是，为了与 STL 设计保持一致，如果您打算稍后将它传递给 STL 算法，我建议您返回一个迭代器。

于 2009-03-13T09:02:46.197 回答
0

您将 myObject 的副本存储在向量中。所以我相信复制 myObject 的实例并不是一项昂贵的操作。然后我认为最安全的方法是从您的函数中返回 myObject 的副本。

于 2009-03-13T10:21:48.330 回答
0

参考 dirkgently 和 anon 的答案，您可以调用front函数而不是begin函数，因此您不必编写，*而只需编写&.

代码示例：

vector<myObject> vec; //You have a vector of your objects
myObject first = vec.front(); //returns reference, not iterator, to the first object in the vector so you had only to write the data type in the generic of your vector, i.e. myObject, and not all the iterator stuff and the vector again and :: of course
myObject* pointer_to_first_object = &first; //* between & and first is not there anymore, first is already the first object, not iterator to it.
于 2014-09-05T20:29:25.880 回答
0

我不确定是否需要返回迭代器指向的东西的地址。您所需要的只是指针本身。您将看到 STL 的迭代器类本身为此目的实现了 _Ptr 的使用。因此，只需执行以下操作：

return iterator._Ptr;
于 2014-11-29T17:12:02.790 回答