Question

我正在编写一个使用迭代器的算法函数。这个函数应该适用于普通和常量迭代器，重要的是这些迭代器来自的类不是模板，我事先就知道了。

有没有办法在下面的定义中强制执行迭代器来自特定的类？

// This is an example, A could be any other class with exposed iterators.
using A = std::vector<int>;

// How to enforce that Iterator is an iterator from A?
template <typename Iterator>
Iterator foo(Iterator begin, Iterator end);

...

A a;
auto it = foo(a.begin(), a.end());
*it = 4; // Must compile

// --------

const A a;
auto it = foo(a.begin(), a.end());
*it = 4; // Must not compile

// --------

B b;
auto it = foo(b.begin(), b.end()); // Should not compile.

在这种情况下，foo不会直接修改提供的范围，但如果提供的范围可以在第一时间修改，则允许修改结果迭代器。如果可以在不复制代码的情况下完成，那将是很好的。

Answer 1

不要使用模板：

A::iterator foo(A::iterator begin, A::iterator end);

Answer 2

您可以使用std :: enable_if：

#include <type_traits>
#include <vector>

class X : public std::vector<int> {};
class Y : public std::vector<double> {};

template <typename Iterator>
typename std::enable_if<std::is_same<Iterator, X::iterator>()
    || std::is_same<Iterator, X::const_iterator>(),
    Iterator>::type
foo(Iterator begin, Iterator end) {
    return begin;
}

int main() {
    X x0;
    auto i0 = foo(x0.begin(), x0.end());
    *i0 = 4; // Must compile

    const X x1;
    auto i1 = foo(x1.begin(), x1.end());
    // error: assignment of read-only location
    //*i1 = 4; // Must not compile

    Y y;
    // error: no type named ‘type’ in ‘struct std::enable_if ...
    //auto i2 = foo(y.begin(), y.end()); // Should not compile
}

或者static_assert是一个更好的选择：

template <typename Iterator>
Iterator foo(Iterator begin, Iterator end) {
    static_assert(std::is_same<Iterator, X::iterator>()
        || std::is_same<Iterator, X::const_iterator>(),
        "No X::iteator or X::const_iterator");
    return begin;
}

Answer 3

您可以使用函数重载检查：

inline void check_must_be_iterator_from_A(A::iterator) {}
inline void check_must_be_iterator_from_A(A::const_iterator) {}

template <typename I>
I foo(I a, I b) {
   typedef void (*must_be_iterator_from_A)(I);
   must_be_iterator_from_A c = &check_must_be_iterator_from_A;
   //...
}

另一种选择是使用模板特化来创建一个约束，这使得函数内的代码更加严格，并且无论编译器如何都绝对没有运行时损失：

template <typename I> struct is_iterator_from_A;
template <> struct is_iterator_from_A<A::iterator>{ enum {ok}; };
template <> struct is_iterator_from_A<A::const_iterator>{ enum {ok}; };

template <typename I>
I bar(I a, I b) {
    is_iterator_from_A<I>::ok;
    return a;
}

Answer 4

我首先为const迭代器编写函数，然后为non_const情况编写一个包装器：

A::const_iterator foo(A::const_iterator start, A::const_iterator end)  {
    std::cout << " Called foo with const iterators " << std::endl;
    return start;
}

A::iterator foo(A::iterator start, A::iterator end) {
    std::cout << " Called foo with non_const iterators " << std::endl;  
    auto it = foo(static_cast<A::const_iterator>(start), static_cast<A::const_iterator>(end));
    return start + std::distance(static_cast<A::const_iterator>(start), it);
}

如果你内联包装函数，你应该得到零（或几乎为零）的开销。

编辑：如果您的容器没有提供随机访问，则迭代器distance具有线性复杂性，您必须使用std::advance而不是＆＃34; +＆＃34; -operator，因此取决于您的性能要求可能不适合您。

返回基于参数类的模板迭代器

4 个答案: