是否可以测试两个迭代器是否指向同一个对象？

Question

假设我正在创建一个函数来复制一个值：

template<class ItInput, class ItOutput>
void copy(ItInput i, ItOutput o) { *o = *i; }

如果i 和o 指向同一个对象，我想避免分配，因为这样分配就没有意义了。

显然，我不能说if (i != o) { ... }，因为i 和o 可能属于不同类型，并且因为它们可能指向不同的容器（因此无法比较）。不太明显的是，我也不能使用重载的函数模板，因为迭代器可能属于不同的容器，即使它们具有相同的类型。

我最初的解决方案是：

template<class ItInput, class ItOutput>
void copy(ItInput i, ItOutput o)
{
    if (&*o != static_cast<void const *>(&*i))
        *o = *i;
}

但我不确定这是否有效。如果*o 或*i 实际上返回一个对象而不是引用呢？

一般有没有办法做到这一点？

Answer 1

我不认为这真的有必要：如果赋值很昂贵，该类型应该定义一个赋值运算符来执行（相对便宜的）自赋值检查，以防止做不必要的工作。但是，这是一个有趣的问题，有很多陷阱，所以我会尝试回答它。

如果我们要组装一个适用于输入和输出迭代器的通用解决方案，我们必须注意几个陷阱：

• 输入迭代器是单遍迭代器：每个元素只能通过迭代器执行一次间接，因此，我们不能通过迭代器执行一次间接来获取指向值的地址第二次执行复制。

• 输入迭代器可能是代理迭代器。代理迭代器是一个迭代器，其operator* 返回一个对象，而不是一个引用。使用代理迭代器，表达式 &*it 格式错误，因为 *it 是一个右值（可能会重载一元 -&，但这样做通常被认为是邪恶和可怕的，大多数类型都不会这样做这个）。

• 一个输出迭代器只能用于输出；您不能通过它执行间接并将结果用作右值。您可以写入“指向元素”，但不能从中读取。

所以，如果我们要进行“优化”，我们只需要在两个迭代器都是前向迭代器的情况下进行优化（这包括双向迭代器和随机访问迭代器：它们也是前向迭代器)。

因为我们很好，我们还需要注意一个事实，尽管它违反了概念要求，但许多代理迭代器歪曲了他们的类别，因为拥有一个支持随机访问的代理迭代器非常有用在一系列代理对象上。 （我什至不确定如何在不这样做的情况下为std::vector<bool> 实现高效的迭代器。）

我们将使用以下标准库标头：

#include <iterator>
#include <type_traits>
#include <utility>

我们定义了一个元函数is_forward_iterator，它测试一个类型是否是“真正的”前向迭代器（即，不是代理迭代器）：

template <typename T>
struct is_forward_iterator :
    std::integral_constant<
        bool,
        std::is_base_of<
            std::forward_iterator_tag,
            typename std::iterator_traits<T>::iterator_category
        >::value &&
        std::is_lvalue_reference<
            decltype(*std::declval<T>())
        >::value>
{ };

为简洁起见，我们还定义了一个元函数can_compare，用于测试两种类型是否都是前向迭代器：

template <typename T, typename U>
struct can_compare :
    std::integral_constant<
        bool,
        is_forward_iterator<T>::value &&
        is_forward_iterator<U>::value
    >
{ };

然后，我们将编写 copy 函数的两个重载，并使用 SFINAE 根据迭代器类型选择正确的重载：如果两个迭代器都是前向迭代器，我们将包含检查，否则我们将排除检查并始终执行分配：

template <typename InputIt, typename OutputIt>
auto copy(InputIt const in, OutputIt const out)
    -> typename std::enable_if<can_compare<InputIt, OutputIt>::value>::type
{
    if (static_cast<void const volatile*>(std::addressof(*in)) != 
        static_cast<void const volatile*>(std::addressof(*out)))
        *out = *in;
}

template <typename InputIt, typename OutputIt>
auto copy(InputIt const in, OutputIt const out)
    -> typename std::enable_if<!can_compare<InputIt, OutputIt>::value>::type
{
    *out = *in;
}

像馅饼一样简单！

Answer 2

我认为在这种情况下，您可能必须记录一些关于您期望在函数中使用的类型的假设，并且满足于不完全通用。

像operator*、operator& 一样可以重载以执行各种操作。如果你防operator*，那么你应该考虑operator&和operator!=等。

我想说强制执行的一个很好的先决条件（通过代码中的 cmets 或概念/静态断言）是 operator* 返回对迭代器指向的对象的引用，并且它不（或不应该） 't) 执行副本。在这种情况下，您的代码看起来还不错。

Answer 3

按原样，您的代码肯定不好，或者至少对于所有迭代器类别都不好。

输入迭代器和输出迭代器在第一次之后不需要被取消引用（它们应该是单次传递），并且输入迭代器可以取消引用任何“可转换为T”（§24.2.3 /2)。

所以，如果你想处理各种迭代器，我认为你不能强制执行这种“优化”，即你不能一般地检查两个迭代器是否指向同一个对象。如果您愿意放弃输入和输出迭代器，那么您所拥有的应该没问题。否则，无论如何我都会坚持做副本（我真的认为您对此没有其他选择）。

Answer 4

编写一个帮助模板函数equals，如果迭代器类型不同，它会自动返回false。要么这样做，要么对您的 copy 函数本身进行专门化或重载。

如果它们是同一类型，那么您可以使用比较它们解析到的对象的指针的技巧，无需强制转换：

if (&*i != &*o)
    *o = *i;

如果 *i 或 *o 没有返回引用，没问题 - 即使不需要，也会复制，但不会造成任何伤害。