C++ 增压范围弱

我有一个映射，其中值是弱指针。这项工作： 虽然我可以这样写：

for_each( IFoo::foo_wptr obj, objects | range::map_values ) {
    IFoo::foo_ptr myObj = obj.lock();
    if( myObj ) myObj->notify();
}

我更希望有一个新的范围，转换成一个锁定的共享指针。大概是这样的：

for_each( IFoo::foo_ptr obj, objects | range::map_values | range::locked ) {
    if( obj ) obj->notify();
}

然而，我一直无法弄清楚这种转换应该是什么样子；或者它是否应该是一个变换

---

有人有主意吗？我相信这种模式可能很常见。

这里有一个我刚刚拼凑的例子：

#include <boost/iterator/transform_iterator.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/range/adaptor/map.hpp>
#include <boost/iterator/transform_iterator.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
#include <boost/weak_ptr.hpp>
#include <boost/foreach.hpp>
#include <map>
#include <vector>

struct weak_ptr_locker
{
    template <typename Sig>
    struct result;

    template <typename F, typename T>
    struct result<F(boost::weak_ptr<T>&)>
    {
        typedef boost::shared_ptr<T> type;
    };

    template <typename T>
    boost::shared_ptr<T> operator()(const boost::weak_ptr<T>& pWeak) const
    {
        return pWeak.lock();
    }
};

template<typename R>
struct lock_transform_range :
    boost::iterator_range< boost::transform_iterator< weak_ptr_locker, typename         boost::range_iterator<R>::type> >
{
private:
    typedef boost::iterator_range< boost::transform_iterator< weak_ptr_locker, typename     boost::range_iterator<R>::type> > base;

public:
    typedef boost::transform_iterator< weak_ptr_locker, typename     boost::range_iterator<R>::type > iterator;

    lock_transform_range(R& r)
        : base(iterator(boost::begin(r)), iterator(boost::end(r)))
    {}
};

namespace detail
{
    struct lock_transform_forwarder {};
}

template< class BidirectionalRng >
inline lock_transform_range<BidirectionalRng> operator | (BidirectionalRng& r,     detail::lock_transform_forwarder)
{
    return lock_transform_range<BidirectionalRng>(r);
}

template< class BidirectionalRng >
inline lock_transform_range<const BidirectionalRng> operator | (const BidirectionalRng&     r, detail::lock_transform_forwarder)
{
    return lock_transform_range<const BidirectionalRng>(r);
}

namespace
{
    const detail::lock_transform_forwarder locked = detail::lock_transform_forwarder();
}

struct Foo
{
    Foo(int i)
        : i(i)
    {}

    int i;
    void notify()
    {
        std::cout << i << std::endl;
    }
};

int main(int argc, char* argv[])
{
    typedef std::map<int, boost::weak_ptr<Foo> > Map;
    typedef boost::shared_ptr<Foo> FooPtr;
    Map objects;

    std::vector<FooPtr> storage;
    for (int i = 0; i < 10; ++i)
    {
        storage.push_back(boost::make_shared<Foo>(i));
        objects[i] = storage.back();
    }

    using namespace boost::adaptors;
    for_each(FooPtr obj, objects | map_values | locked) 
    {
        if (obj) 
            obj->notify();
    }
    return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
结构弱\u ptr\u锁柜
{
模板
结构结果；
模板
结构结果
{
typedef boost：：共享_ptr类型；
};
模板
boost:：shared_ptr operator（）（常量boost:：弱_ptr&pWeak）常量
{
返回pWeak.lock（）；
}
};
模板
结构锁定\u变换\u范围：
boost:：iterator\u range>
{
私人：
typedef boost:：iterator\u range>base；
公众：
typedef boost:：transform_iteratoriterator；
锁定变换范围（R&R）
：base（迭代器（boost:：begin（r）），迭代器（boost:：end（r）））
{}
};
名称空间详细信息
{
结构锁转换转发器{}；
}
模板
内联锁_变换_范围运算符|（双向RNG&r，详细信息：：锁_变换_转发器）
{
返回锁定变换范围（r）；
}
模板
内联锁定变换范围运算符（常量双向RNG&r，详细信息：：锁定变换转发器）
{
返回锁定变换范围（r）；
}
名称空间
{
const detail:：lock_transform_forwarder locked=detail:：lock_transform_forwarder（）；
}
结构Foo
{
富（国际一）
：i（i）
{}
int i；
作废通知（）
{
std：：您是否尝试按照手册进行操作：？此处描述的方法是否有效？