如何正确返回unique_ptr的集合

我建议您创建自己的迭代器类。然后创建开始和结束成员函数。您甚至可以重载解引用运算符以返回引用，而不是指针（除非指针可能为null）。它可能会启动这样的东西：

class iterator :
    public std::iterator<std::random_access_iterator_tag, Object>
{
public:
    Object& operator*() const { return **base; }
    Object* operator->() const { return &**base; }
    iterator& operator++() { ++base; return *this; }
    // several other members necessary for random access iterators
private:
    std::vector<ObjectUPtr>::iterator base;
};

实现一个符合标准的迭代器有点乏味，但我认为这是迄今为止最常用的解决方案。正如评论中提到的，Boost.Iterator库，特别是boost::iterator_facade，可以用来缓解一些乏味。

您不必返回集合，从而破坏容器类的封装。还有其他选择。

我会选择Enumerator/Seiver模式（我不知道这是否是该模式的实际名称）。

基本思想是让API的客户端实现一个接口，该接口原则上从一个容器一个接一个地接收对象。

它看起来像这样：

class Receiver {
  public:
    virtual void receive(const Object& object) = 0;
};
class Container {
  public:
    void enumerate(Receiver& receiver) const {
      for (auto&& obj : m_objects) {
        receiver.receive(*obj);
      }
    }
  private:
    std::vector<ObjectUPtr> m_objects;
};

然后实现接收器接口：

class ReceiverImpl : public Receiver {
  public:
    virtual void receive(const Object& object) {
      // do something with object
    }  
};

并让容器向接收器枚举对象：

Container container;
ReceiverImpl receiver;
container.enumerate(receiver);

请参阅实例。

此外，您甚至可以通过在Container::enumerate中添加互斥锁/解锁来确保容器线程的安全，而客户端甚至不会注意到！

最后，您可以用模板参数替换Container::enumerate中的接收器参数，以消除虚拟函数调用的运行时开销。

如果使用boost，在这种情况下，我更喜欢tranform_iterator而不是iterator_facade。

为了获得更实用的风格，我将代码分为两部分：

• 创建一个可以容纳两个指针作为范围的类（允许基于范围的循环）
• 创建一个函数，该函数以lambda作为转换步骤并返回一个范围（以隐藏transform_iterator）

因此，转换步骤是在取消引用迭代器时执行的。

代码示例

#include <boost/iterator/transform_iterator.hpp>
#include <memory>
#include <vector>
#include <algorithm>
#include <stdio.h>
using namespace boost;
using namespace std;
template <typename Iterator>
class Range {
    public:
        Range(Iterator begin, Iterator end) : b(begin), e(end) { }
        Range(const Range &r) = default;
        Range(Range &&r) = default;
        Range &operator=(const Range &r) = default;
        Range &operator=(Range &&r) = default;
        template <typename Container>
            Range(Container &c) : b(c.begin()), e(c.end()) { }
        Iterator begin() { return b;}
        Iterator begin() const { return b; }
        Iterator end() { return e;}
        Iterator end() const { return e; }
        Iterator b;
        Iterator e;
};

template <typename Container, typename TransformFunc>
Range<transform_iterator<TransformFunc, typename Container::iterator>>
transform(Container &c, TransformFunc f) {
    using namespace boost;
    using cont_it = typename Container::iterator;
    using iterator = transform_iterator<TransformFunc, cont_it>;
    iterator b = iterator(c.begin(), f), e = iterator(c.end(), f);
    Range<iterator> r(b,e);
    return r;
}
int main(int, char **) {
    vector<unique_ptr<int>> foo;
    for (int i = 0; i < 10; i++) {
        foo.push_back(unique_ptr<int>(new int(10)));
    }
    auto f = [](unique_ptr<int> &i) { return i.get(); };
    for (auto *i : transform(foo, f) ) {
        printf("%p ", i);
    }
    return 0;
}