传递派生共享指针的向量？

Question

什么是允许指向派生类的共享指针向量传递给一个函数的正确方法，该函数期望一个指向基类的共享指针向量而不执行复制？

代码如下：

#include <string>
#include <vector>
#include <memory>

class Base {
public:
    std::string Name;
};
using BaseList = std::vector<std::shared_ptr<Base>>;

class Derived : Base {
};
using DerivedList = std::vector<std::shared_ptr<Derived>>;

class BaseHandler {
public:
    void process( BaseList list ) {
    }
};

int main() {

    DerivedList list;

    BaseHandler bh;
    bh.process( list );

}

代码链接：http://coliru.stacked-crooked.com/a/5a5b18ba3b2a4f08

编辑：DOH！！！我发错了。很抱歉...这里是 shared_ptr 之一。

Answer 1

你可以试试这个。

template <class T,
        class SharedPtr = typename T::value_type,
        class Element = typename SharedPtr::element_type,
        class IsDerived = typename std::enable_if<std::is_base_of<Base, Element>::value, void*>::type
    >
void process(const T& t) { std::cout << "process" << std::endl; }

关键思想是：

1. 我们可以通过编译器知道的具体类型信息来访问它们，而不是通过基类指针访问元素。
2. 此函数模板使用一种称为“SFINAE”的技巧来检查参数是否为派生类智能指针的容器。

---

---

跟进：

从“到派生类的共享指针的容器”到“到基类的共享指针的容器”的转换是可能的并且不是很困难。但是，我担心使用“指向基类的共享指针的容器”的设计选择是否会给您带来可接受的性能。

---

让我们先讨论如何做。

1. 我们可以使用std::static_pointer_cast从每个std::shared_ptr<Derived>对象创建一个std::shared_ptr<Base>对象。
2. 要将std::static_pointer_cast 应用于列表的所有条目，我们可以使用std::transform。
3. 如果您有许多派生类，则可以通过使用带有上述 SFINAE 检查的函数模板，使转换可用于每个派生类。

所以，代码如下：

DerivedList derivedList;
// Put items into derivedList

BaseList baseList;
baseList.reserve(derivedList.size());
std::transform(std::begin(derivedList), std::end(derivedList), std::back_inserter(baseList),
    [](const std::shared_ptr<Derived>& shptr)
    {
        return std::static_pointer_cast<Base>(shptr);
    });

BaseHandler bh;
bh.process(baseList);

或者：

class BaseForwarder
{
public:
    template <class T,
            class SharedPtr = typename T::value_type,
            class Element = typename SharedPtr::element_type,
            class IsDerived = typename std::enable_if<std::is_base_of<Base, Element>::value, void*>::type
        >
    void process(const T& derivedList)
    {
        BaseList baseList;
        baseList.reserve(derivedList.size());

        std::transform(std::begin(derivedList), std::end(derivedList), std::back_inserter(baseList),
                [](const SharedPtr& shptr)
                {
                    return std::static_pointer_cast<Base>(shptr);
                });

        BaseHandler bh;
        bh.process(baseList);
    }
};

---

但是，这种方法有相当多的性能损失。

• 必须为每个派生类的指针列表创建一个新的基类指针列表。构建新列表会花费大量时间和内存。
• 通过指针访问对象。这种间接方式会减慢速度。
• 由于对象没有分配到紧凑的数据结构中，缓存未命中将很严重。

我建议您评估性能，看看这种方法是否可以接受。否则，最好考虑其他一些设计选择。