有一个weak_ptr的向量，想要返回一个shared_ptr的向量

Question

我目前正在做一个大项目，我需要使用weak_ptr 而不是shared_ptr。

这是我的问题。

我有一个名为 House 的类，其属性为：vector<boost::shared_ptr<People>> my_people。 我想修改这个数据成员为vector<boost::weak_ptr<People>> my_people。

我的吸气剂是

vector<boost::shared_ptr<People>>& getPeople() const
{
    return my_people;
}

通常，使用简单的weak_ptr 我可以返回my_people.lock();

但我有一个向量，但我不知道如何做这样的事情：

vector<boost::shared_ptr<People>>& getPeople() const
{
    for( vector<boost::weak_ptr<People>::iterator it = my_people.begin();
         it != my_people.end();
         ++it)
    {
        (*it).lock();
    }

    return my_people;
}

换句话说，我想返回weak_ptr 的向量，但作为shared_ptr 的向量。可能吗？还是我必须返回weak_ptr 的向量并在我使用它们的任何地方使用lock()？

Answer 1

你的函数是一个合理的开始：

vector<boost::shared_ptr<People>>& getPeople() const
{
    for( vector<boost::weak_ptr<People>::iterator it = my_people.begin();
         it != my_people.end();
         ++it)
    {
        (*it).lock();
    }

    return my_people;
}

但是调用(*it).lock() 只是创建一个shared_ptr 并将其丢弃，它不会改变向量元素的类型，并且您不能将向量作为不同的类型返回。

你需要创建一个正确类型的向量，用 shared_ptr 对象填充它，然后返回它：

vector<boost::shared_ptr<People>> getPeople() const
{
    vector<boost::shared_ptr<People>> people(my_people.size());
    std::transform(my_people.begin(), my_people.end(), people.begin(),
                   boost::bind(&boost::weak_ptr<People>::lock, _1));
    return people;
}

这会遍历my_people的每个元素，在其上调用lock()，并将结果分配给people的对应元素。

如果您知道 my_people 永远不会包含过期的指针，那就更容易了：

vector<boost::shared_ptr<People>> getPeople() const
{
  vector<boost::shared_ptr<People>> people(my_people.begin(), my_people.end());
  return people;
}

这通过从weak_ptr 元素构造每个shared_ptr 元素来填充people 向量。不同之处在于，如果 weak_ptr 已过期，此版本将抛出异常，因为如果传递了过期的 weak_ptr，shared_ptr 构造函数将抛出异常。使用transform 的版本如果转换了过期的weak_ptr，则会在向量中放置一个空的shared_ptr。

Answer 2

你可以使用 std::transform

 std::vector<std::shared_ptr<People>> temp;
 sharedTargetList.resize(my_people.size());

 //transform into a shared_ptr vector
 std::transform(my_people.begin(),
        my_people.end(),
        temp.begin(), 
        [](std::weak_ptr<People> weakPtr){ return weakPtr.lock(); } 
 );

Answer 3

怎么样：

vector<boost::shared_ptr<People>> getPeople() const
{
    vector<boost::shared_ptr<People>> res;
    for( vector<boost::weak_ptr<People>::iterator it = my_people.begin(); 
         it != my_people.end(); ++it)
        res.push_back(it->lock());
    return res;
}

此外，您可以根据需要过滤掉空指针。

当然，您不能返回对局部变量的引用，因此您必须返回一个副本。您可能想要这样做：

void getPeople(vector<boost::shared_ptr<People>> &res) const
{
    for( vector<boost::weak_ptr<People>::iterator it = my_people.begin(); 
         it != my_people.end(); ++it)
        res.push_back(it->lock());
}

避免复制返回向量。

Answer 4

注意vector<weak_ptr<T> > 和vector<shared_ptr<T> > 是两种完全不同的类型。

但是，您可以编写一个接受前者并返回后者的函数：

  template<class Ptrs, class WeakPtrs> 
  void lockWeakPtrs(const WeakPtrs &weakPtrs, Ptrs &ptrs)
  {
      BOOST_FOREACH (typename WeakPtrs::const_reference weakPtr, weakPtrs)
      {
          typename Ptrs::value_type ptr = weakPtr.lock();
          if (ptr) // if you want to drop expired weak_ptr's
              ptrs.insert(ptrs.end(), ptr);
      }
  }

这样调用： lockWeakPtrs(myWeakVector, mySharedVector);