将 vector<boost::shared_ptr<Foo> > 转换为 vector<Foo*> ，有可能吗？

Question

我有一个函数，它接受一个指向 Foo 的指针的 stl 向量作为参数。

但是，我也有一些对象，它们是指向同一个类 Foo 的共享指针。我也希望能够调用这个函数来提供其他对象。我必须重载该功能吗？我似乎无法将它从vector<shared_ptr<Foo>> 动态转换为vector<Foo*>。

我知道可以使用 Get() 方法将 shared_ptr 转换为指针，但是这个呢？有什么想法吗？

问题更新：

我已经实现了下面建议的解决方案，但是现在，当为模板函数声明所有可能的类型时，我得到：

“'void my_func(std::vector&, std::vector&) [with Ptr_Jet1 = Jet*, Ptr_Jet2 = Jet*]' 的显式实例化，但没有可用的定义”

对于所有其他组合（例如，Ptr_Jet1 是 shared_ptr 而不是 Jet*。

在 .cpp 文件中，我有：

template<typename Ptr_Jet1, typename Ptr_Jet2>
void my_func(vector<Ptr_Jet1> vec1, vector<Ptr_Jet2> vec2){
//definition
}

在 .h 文件中，我有：

typedef boost::shared_ptr<Jet> ptr_jet;

template<typename Ptr_Jet1, typename Ptr_Jet2>
void my_func(vector<Ptr_Jet1> vec1, vector<Ptr_Jet2> vec2);
//
template void my_func(vector<Jet*> vec1, vector<Jet*> vec2);
template void my_func(vector<Jet*> vec1, vector<ptr_jet> vec2);
template void my_func(vector<ptr_jet> vec1, vector<Jet*> vec2);
template void my_func(vector<ptr_jet> vec1, vector<ptr_jet> vec2);

我不明白这里有什么问题......

Answer 1

shared_ptr<T> 和T* 是不同的类型，因此您不能简单地将vector<shared_ptr<T>> 转换为vector<T*>。如果您真的需要vector<T*>（这意味着您不能按照 Barnabas Szabolcs 的回答更改您的功能），您需要手动将指针从源向量中复制出来。由于您无论如何都在使用 boost，我认为使用 Boost.Range 是可以的。如果你可以使用 C++11，这很简单：

vector< shared_ptr<Foo> > foo;
auto range = foo | boost::adaptors::transform([](shared_ptr<Foo>& ptr) { return ptr.get(); };
std::vector<Foo*> bar(range.begin(), range.end());

这将 C++11 用于 lambda 函数（可以很容易地被 c++03 代码的函子/functionptr 替换）和auto 以保存范围。 IIRC 范围转换的返回类型在Boost.Range 的文档中未指定，因此硬编码可能不是一个好主意。要摆脱 c++03 代码中的auto，您可以使用boost::copy_range：

struct transformation //using a functor instead of a plain function will enable inlining of the transformation, which is liekly benefitial for performance
{ Foo* operator()(shared_ptr<Foo>& ptr) { return ptr.get();}};

std::vector<Foo*> bar = boost::copy_range<std::vector<Foo*>>(foo | boost::adaptors::transform(transformation()));

当然，您可以改用 Boost.Iterators 中的 transform_iterator，但我发现使用 Range 会导致代码更具可读性。

当然，如果您仅将 vector<Foo*> 用作函数的参数，则可以跳过将其写入变量并直接调用 myFunc(copy_range<std::vector<Foo*>>(...))，这可能会使编译器跳过几个副本。

Answer 2

如果你写了那个函数，我建议模板化，因为 shared_ptr 有operator*，就像你使用原始指针一样。

template<typename _Tp_ptr_Foo>
void your_fun(const vector<_Tp_ptr_Foo>& ); // or something alike here

在这种情况下，模板化与函数重载基本相同，但使用模板化可以避免重复代码。

如果您无法控制函数，则需要转换整个向量。如果它不超过 1000 个元素，并且您执行的次数不超过几百次，则无需担心太多的性能损失。

不幸的是，您不能将一个动态转换为另一个，因为它们不是通过继承相关的。虽然看起来很像，但vector<T> 和vector<U> 没有任何关系。

更新：
我同意 Grizzly 的观点，模板参数是自动推导出来的，所以你不需要明确地写出来。所以你可以继续叫它your_fun(v)。

你唯一需要注意的是：如果你分别处理头文件和代码文件，你需要explicitly instruct the compiler that it should create both of your functions，像这样：

//header file:

template<typename _Tp_ptr_Foo>
void your_fun(const vector<_Tp_ptr_Foo>& ); 

template void your_fun(const vector<Foo*>& ); 
template void your_fun(const vector<shared_ptr<Foo> >& ); 

//code file:

template<typename _Tp_ptr_Foo>
void your_fun(const vector<_Tp_ptr_Foo>& )
{
  // implementation
}

---

UPDATE2：（回答 Elelias 的评论）

您的模板声明应如下所示：

// header file:

template<typename _Tp1, typename _Tp2, typename _Tp3>
void your_fun(const vector<_Tp1>&, const vector<_Tp2>&, const vector<_Tp3>& ); 

之后，您有两个选择：

1. 您可以将定义放入单独的代码文件中。在这种情况下，您需要 6 个实现文件中的显式模板实例作为标头，每个组合一个。

2. 您可以将定义放在标题中，然后您就不需要 6 个显式实例化。在这种情况下，我宁愿建议这样做。虽然它没有将声明和实现分开，但它并不是那么糟糕的解决方案。我在严肃的 c++ 库中也看到过这种方法，例如，您可以查看 OpenCV 中的 operations.hpp。