如何正确返回 unique_ptr 的集合

Question

在更改我的代码以使用唯一指针后，我偶然发现了如何将对象集合返回给客户端。一般来说，我想将对象作为引用或非拥有指针传递。但如果我有一个对象集合，我不能只返回对它的引用。

例如，我有一个包含对象集合的简单类，这些对象都创建一次，之后不会更改。

using ObjectUPtr = std::unique_ptr<Object>;
class MyClass
{
  public:
  const std::vector<Object*>& GetObjectsOldStyle() const
  {
    return mObjectsOldStyle;
  }

  const std::vector<VObjectUPtr>& GetObjectsNewStyleA() const
  {
    // I don't like that: The client should not see the unique_ptr ...
    return mObjectsNewStyle; 
  }

  std::vector<VObject*> GetObjectsNewStyleB() const
  {
    // Ok, but performance drops
    std::transform(...); // Transform the collection and return a copy
  }

  const std::vector<VObject*>& GetObjectsNewStyleC() const
  {
    // Ok, only copied once, but two variables per collection needed
    // Transform the collection and cache in a second vector<Object*>
    std::transform(...);
  }

  std::vector<Object*> mObjectsOldStyle;    // old-style owning pointers here
  std::vector<ObjectUPtr> mObjectsNewStyle; // how I want to do it today
}

今天，我通常更喜欢 GetObjectsNewStyleB，但我想知道是否有更优雅和有效的方式或一般的最佳实践来返回此类集合。

Answer 1

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

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

实现符合标准的迭代器有点乏味，但我认为这是迄今为止最惯用的解决方案。如 cmets 中所述，Boost.Iterator 库，特别是 boost::iterator_facade 可用于减轻一些乏味。

Answer 2

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

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

基本思想是让 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;
};

然后实现Receiver接口：

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

并让容器将对象枚举给接收者：

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

见live example。

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

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

Answer 3

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

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

• 创建一个可以将两个指针作为一个范围保存的类（允许基于范围的 for 循环）。
• 创建一个函数，将 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;
}