将 const 容器引用作为参数传递时如何逃脱 const_iterator 陷阱

Question

我通常更喜欢 constness，但最近遇到了 const 迭代器的难题，它动摇了我的 const 态度 让我对它们感到恼火：

MyList::const_iterator find( const MyList & list, int identifier )
{
    // do some stuff to find identifier
    return retConstItor; // has to be const_iterator because list is const
}

当然，我在这里试图表达的想法是，传入的list 不能/不会更改，但是一旦我将列表引用设置为 const，我就必须使用 'const_iterator'，这会阻止我 做任何事情 修改结果（这是有道理的）。

那么，解决方案是放弃将传入的容器引用设为常量，还是我错过了另一种可能性？

这一直是我对 const 的秘密保留：即使你正确使用它，它也会在没有好的/干净的解决方案的情况下产生不应该出现的问题，尽管我认识到更具体地说，这是 const 和 const 之间的问题迭代器概念。

编辑：我非常清楚为什么你不能也不应该为 const 容器返回一个非常量迭代器。我的问题是，虽然我想要对通过引用传入的容器进行编译时检查，但我仍然想找到一种方法来传回某些内容的位置，并使用它来修改列表的非常量版本。正如其中一个答案中提到的，可以通过“提前”提取位置的概念，但很混乱/效率低下。

Answer 1

如果我正确理解您的意思，您正在尝试使用 const 向调用者表明您的函数不会修改集合，但您希望调用者（可能有一个非对集合的 const 引用），以便能够使用返回的迭代器修改集合。如果是这样，我认为没有一个干净的解决方案，除非容器提供一种将 const 交互器转换为非 const 交互器的机制（我是不知道有一个容器可以做到这一点）。您最好的选择可能是让您的函数采用非 const 引用。您还可以对函数进行 2 个重载，一个 const 和一个非 const，这样在调用者只有一个 的情况下const 引用，他们仍然能够使用你的函数。

Answer 2

这不是一个陷阱；而是一个陷阱。这是一个功能。 (:-)

一般来说，您不能从 const 方法返回非常量“句柄”到数据。例如，下面的代码是非法的。

class Foo
   {
      public:
         int& getX() const {return x;}
      private:
         int x;
   };

如果它是合法的，那么你可以做这样的事情......

   int main()
   {
      const Foo f;
      f.getX() = 3; // changed value of const object
   }

STL 的设计者遵循常量迭代器的这一约定。

---

就您而言， const 会给您带来在 const 集合上调用它的能力。在这种情况下，您不希望返回的迭代器是可修改的。但如果集合是非常量，您确实希望允许它可修改。因此，您可能需要两个接口：

MyList::const_iterator find( const MyList & list, int identifier )
{
    // do some stuff to find identifier
    return retConstItor; // has to be const_iterator because list is const
}

MyList::iterator find( MyList & list, int identifier )
{
    // do some stuff to find identifier
    return retItor; 
}

或者，您可以使用一个模板函数完成所有操作。

template<typename T>    
T find(T start, T end, int identifier);

如果输入迭代器是非常量，它将返回一个非常量迭代器，如果输入迭代器是常量，它将返回一个 const_iterator。

Answer 3

我对包装标准算法所做的工作是有一个元对象来确定容器的类型：

namespace detail
{
    template <class Range>
    struct Iterator
    {
        typedef typename Range::iterator type;
    };

    template <class Range>
    struct Iterator<const Range>
    {
        typedef typename Range::const_iterator type;
    };
}

这允许提供单个实现，例如查找：

template <class Range, class Type>
typename detail::Iterator<Range>::type find(Range& range, const Type& value)
{
    return std::find(range.begin(), range.end(), value);
}

但是，这不允许使用临时变量调用它（我想我可以生活与它）。

无论如何，要返回对容器的可修改引用，显然您无法保证您的函数对容器做什么或不做什么。所以这个崇高的原则确实失效了：不要教条主义。

我认为 const 正确性更多的是为函数的调用者提供服务，而不是一些旨在确保您的简单查找函数正确的保姆措施。

---

另一个问题是：如果我定义了以下谓词，然后滥用标准 find_if 算法将所有值增加到第一个值 >= 3，你会有什么感觉：

bool inc_if_less_than_3(int& a)
{
    return a++ < 3;
}

（GCC 不会阻止我，但我无法告诉如果迂腐地说有一些未定义的行为。）

1）容器属于用户。由于允许通过谓词进行修改不会以任何方式损害算法，因此应该由调用者决定如何使用它。

2）这太可怕了！更好地实现 find_if 像这样，以避免这个噩梦（最好的办法，因为，显然，你不能选择迭代器是否是 const ）：

template <class Iter, class Pred>
Iter my_find_if(Iter first, Iter last, Pred fun)
{
    while (first != last 
       && !fun( const_cast<const typename std::iterator_traits<Iter>::value_type &>(*first)))
        ++first;
    return first;
}

Answer 4

虽然我认为你的设计有点令人困惑（因为其他人指出迭代器允许在容器中进行更改，所以我不认为你的函数真的是 const），但有一种方法可以从 const_iterator 中获取迭代器。效率取决于迭代器的类型。

#include <list>

int main()
{
  typedef std::list<int> IntList;
  typedef IntList::iterator Iter;
  typedef IntList::const_iterator ConstIter;

  IntList theList;
  ConstIter cit = function_returning_const_iter(theList);

  //Make non-const iter point to the same as the const iter.
  Iter it(theList.begin());
  std::advance(it, std::distance<ConstIter>(it, cit));

  return 0;
}

Answer 5

在这种情况下，最好使用后置条件来保证列表，而不是尝试使用 const 关键字来保证列表不会被更改。换句话说，通过注释告诉用户该列表不会更改。

更好的是使用可以为迭代器或 const_iterators 实例化的模板：

template <typename II> // II models InputIterator
II find(II first, int identifier) {
  // do stuff
  return iterator;
}

当然，如果您要遇到那么多麻烦，您也可以将 MyList 的迭代器公开给用户并使用 std::find。

Answer 6

如果您要更改迭代器指示的数据，那么您就是在更改列表。

当然，我在这里试图表达的想法是，传入的列表不能/不会被更改，但是一旦我将列表引用设置为常量，我就必须使用“cons_iterator”，这会阻止我这样做任何结果。

什么是“东什么”？修改数据？那就是改变列表，这与你的初衷相矛盾。如果列表是常量，则它（并且“它”包括其数据）是常量。

如果你的函数要返回一个非常量迭代器，它将创建一种修改列表的方法，因此该列表不会是常量的。

Answer 7

您以错误的方式思考您的设计。不要使用 const 参数来指示函数的作用 - 使用它们来描述参数。在这种情况下，find() 不更改列表并不重要。重要的是 find() 旨在与可修改列表一起使用。

如果您希望 find() 函数返回非常量迭代器，那么它允许调用者修改容器。它接受 const 容器是错误，因为这将为调用者提供一种删除容器 const 性的隐藏方法。

考虑一下：

// Your function
MyList::iterator find(const MyList& list, int identifier);

// Caller has a const list.
const MyList list = ...
// but your function lets them modify it.
*( find(list,3) ) = 5;

所以，你的函数应该接受一个非常量参数：

MyList::iterator find(MyList& list, int identifier);

现在，当调用者尝试使用你的函数来修改她的常量列表时，她会得到一个编译错误。这是一个更好的结果。

Answer 8

如果要向容器返回非常量访问器，请将该函数也设为非常量。您承认容器可能会因副作用而改变。

这是标准算法采用迭代器而不是容器的一个很好的理由，因此它们可以避免这个问题。