用于原始指针上的迭代器和unique_ptrs上的迭代器的Templated函数

Question

假设我有一个模板函数，它接受某种指针集合的const范围(或者最好是开始迭代器和结束迭代器)。该函数内部构造了一个带有指针的stl容器，用于重新组织元素。

现在我想对unique_ptr-collections也重用这个函数。不知何故，我需要修改模板参数或引入新的包装器或重载…但如何?是否有任何c++ 11模板魔术，STL帮助或boost帮助?下面是一个示例代码:

#include <string>
#include <iostream>
#include <vector>
#include <algorithm>
#include <memory>
// Element Class
class Foo { };
// Take a range of elements, sort them internally by their addresses and print them in order    
template <typename FooIterator>
void print_sorted_addresses(FooIterator beginFoos, FooIterator endFoos)
{
    // Sort them
    std::vector<const Foo*> elements(beginFoos, endFoos);
    std::sort(elements.begin(), elements.end());
    // Print them
    for(const auto& e : elements)
        std::cout << e << std::endl;
}
int main() {
    std::vector<Foo*> raw_foos;
    std::vector<std::unique_ptr<Foo>> unique_foos;
    // Fill them
    for(int i=0; i<10; i++) {
        std::unique_ptr<Foo> foo(new Foo());
        raw_foos.push_back(foo.get());
        unique_foos.push_back(std::move(foo));
    }
    print_sorted_addresses(raw_foos.cbegin(), raw_foos.cend());
    //print_sorted_Foos(unique_foos.cbegin(), unique_foos.cend()); // ERROR
    return 0;
}

---

罪魁祸首似乎是原始指针和智能指针(特别是unique_ptr)在将它们都转换为原始指针时的不一致行为。这也可以通过解引用循环 std::addressof(*p)来规避，但这只有在p不是nullptr时才有良好定义的行为。为了减少任何运行时检查，我使用了条件模板，并得出以下结论:

template<typename Ptr> using RawPtr = typename std::pointer_traits<Ptr>::element_type*; 
// raw pointers like int**, const char*, ...
template<typename Ptr>
typename std::enable_if<std::is_pointer<Ptr>::value, RawPtr<Ptr>>::type make_raw(Ptr ptr) { return ptr; }
// smart pointers like unique_ptr, shared_ptr, ... 
template<typename Ptr>
typename std::enable_if<!std::is_pointer<Ptr>::value, RawPtr<Ptr>>::type make_raw(Ptr& ptr) { return ptr.get(); }

可以在@tclamb的迭代器中使用，也可以在@Praetorian的答案中的boost::transform_iterator中使用。但是，构建在智能指针实现的特定get()成员之上，而不是构建使指针成为指针的操作符*接口，仍然感觉很奇怪。

Answer 1

这是一个包装指针迭代器的通用方法。在解引用时，它对存储的迭代器解引用(产生(智能)指针)，然后再次解引用(产生对指针的引用)，然后返回指针的地址(通过std::addressof())。实现的其余部分只是迭代器样板。

template<typename Iterator,
         typename Address = decltype(std::addressof(**std::declval<Iterator>()))
         >
class address_iterator : public std::iterator<std::input_iterator_tag, Address>
{
public:
    address_iterator(Iterator i) : i_{std::move(i)} {};
    Address operator*() const {
        auto&& ptr = *i_;
        return i_ == nullptr ? nullptr : std::addressof(*ptr);
    };
    Address operator->() const {
        return operator*();
    }
    address_iterator& operator++() {
        ++i_;
        return *this;
    };
    address_iterator operator++(int) {
        auto old = *this;
        operator++();
        return old;
    }
    bool operator==(address_iterator const& other) const {
        return i_ == other.i_;
    }
private:
    Iterator i_;
};
template<typename I, typename A>
bool operator!=(address_iterator<I, A> const& lhs, address_iterator<I, A> const& rhs) {
    return !(lhs == rhs);
}
template<typename Iterator>
address_iterator<Iterator> make_address_iterator(Iterator i) {
    return i;
}

Coliru上的实时示例(带有std::random_shuffle()的乐趣)。:)

Answer 2

处理unique_ptr时代码的问题是这一行:

std::vector<const Foo*> elements(beginFoos, endFoos);

vector构造函数将尝试复制unique_ptr s，这是不允许的;你对unique_ptr指向什么很感兴趣。因此，您需要额外的解引用级别来生成对托管对象的引用。这可以使用Boost.IndirectIterator来实现。

使用boost::indirect_iterator将产生Foo const&，然后可以通过在Boost中包装它来转换为Foo const *。将std::addressof作为一元谓词传递给boost::transform_iterator。

template <typename FooIterator>
void print_sorted_addresses(FooIterator beginFoos, FooIterator endFoos) {
    std::vector<Foo const *> elements(
      boost::make_transform_iterator(boost::make_indirect_iterator(beginFoos), 
                                     std::addressof<Foo>),
      boost::make_transform_iterator(boost::make_indirect_iterator(endFoos),
                                     std::addressof<Foo>));
    std::sort(elements.begin(), elements.end());
    for(const auto& e : elements)
        std::cout << e << std::endl;
}

现场演示

Answer 3

我的2个硬币

Foo* get(Foo* const& p) {
    return p;
}
Foo* get(std::unique_ptr<Foo> const& up) {
    return up.get();
}

// Take a range of elements, sort them internally by their addresses and print
// them in order    
template <typename ConstIt>
void print_sorted_addresses(const ConstIt& cbegin, const ConstIt& cend) {
    using deref_type = decltype(*cbegin);
    using raw_ptr_type = decltype(get(*cbegin));
    std::vector<raw_ptr_type> v;
    v.reserve(cend - cbegin);
    std::transform(cbegin, cend, 
                   std::back_inserter(v),
                   [] (const deref_type& p) {
                        return get(p);
                   });

    std::sort(v.begin(), v.end());
    for(const auto& p : v)
        std::cout << p << 'n';
}