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

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> 实现高效的迭代器。)

我们将使用以下标准库 header :

#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;
}

简单易行!