用于操作基础/派生对象容器的函数

Question

考虑下面的数组算法：

class MyType;
{
    // some stuff
}

class MySubType:MyType
{
    // some stuff
}

void foo(MyType** arr, int len)
{
    for (int i = 0;i<len;i++)
        // do something on arr[i]->
}

void bar()
{
    MySubType* arr[10];
    // initialize all MySubType*'s in arr
    foo(&arr, 10);
}

这里没有什么花哨的。我的问题是 - 我如何使用模板来做到这一点？

void foo(std::vector<MyType>& s)
{
    std::vector<MyType>::iterator i;
    for (i = s.begin(); i != s.end(); i++)
        // do stuff on *i
}

所以，在酒吧里，我不能这样做：

void bar()
{
    std::vector<MySubType> s;
    foo(s);  // compiler error
}

错误：std::vector<MyType, std::allocator<MyType> >& 类型的引用从 std::vector<MySubType, std::allocator<MySubType> > 类型的表达式的无效初始化

有没有办法做这样的事情？

基本上，如果有办法做到这一点：

std::vector<MySubType> s;
std::vector<MyType>& t = s;

我会很高兴...

Answer 1

这可能会解决您的问题

template <typename T>
void foo(std::vector<T>& s)
{
    typename std::vector<T>::iterator i;
    for (i = s.begin(); i != s.end(); i++)
        // do stuff on *i
}

Answer 2

为了扩展 kuoson's answer，惯用的 C++ 风格是将迭代器传递给函数而不是容器。

template<typename Iterator>
void foo(const Iterator & begin, const Iterator & end)
{
    Iterator i;
    for (i = begin;  i != end;  ++i)
        // do stuff on *i
}

Answer 3

这就是问题所在 - 如果 s 和 t 指向同一个对象，有什么能阻止您将 MyOtherSubType（与 MySubType 无关）放入 t 中？这将使 s 包含不是 MySubType 的对象。我不知道有任何类型安全的编程语言可以让你做到这一点。如果允许，想象一下我们会遇到的问题：

//MySubType inherits from MyType
//MyOtherSubType also inherits from MyType

std::vector<MySubType> s;
std::vector<MyType>& t = s;

MyOtherSubType o;
t.push_back(o);

由于 t 和 s 是不同名称的完全相同的对象，因此 s[0] 处的元素不是 MySubType。巨大的问题——我们永远无法确定我们的向量是否包含它们应该包含的类型！因此，编译不允许它。

Answer 4

既然你说“这里没什么特别的”，我不确定你是否意识到这一点：

您的原始代码已损坏；或者如果你很幸运，它现在可能不会被破坏，但它非常脆弱，一旦有人做了比看MySubType 类更多的事情就会破坏。

问题是您将MyType* 传递给foo()，但它实际上指向MySubType 的数组。如果MySubType 对象恰好大于MyType 对象（如果您向派生类添加了任何内容，这很可能），那么在foo() 函数中完成的指针运算将不正确。

这是派生类对象数组的严重且经典的缺陷之一。

Answer 5

如果您想将多个不同的 MyType 派生类型的对象存储在单个向量中（我怀疑您会这样做，尽管对于这个特定示例来说这不是必需的），您需要使用 std::vector<MyType*> 来代替的std::vector<MyType>。这个建议类似于 Michael Burr 为您的原始指针代码提出的建议。

这确实有一个不幸的副作用，即您不能将std::vector<MySubType*> 隐式转换为std::vector<MyType*> 以调用foo()。不过转换代码也不算繁琐：

void foo(std::vector<MyType*>& s)
{
    ...
}

void bar()
{
    std::vector<MySubType*> s;

    // Populate s
    ...

    std::vector<MyType*> u(s.begin(), s.end());    // Convert
    foo(u);
}

或者，让bar() 从一开始就使用std::vector<MyType*>。

Answer 6

C++ 不支持模板类型的协变，这与 C# 目前所做的一样，原因大致相同。如果您想这样做，最好将您的向量模板化为一个通用接口类型（指向该类型的指针），并让函数 foo 接受该类型的向量。

Answer 7

不幸的是，没有。不同的模板特化被认为是不同的类；您无法在 std::vector<MyType> 和 std::vector<MySubType> 之间进行转换。

您可以将foo() 的“do stuff”公共位拆分为一个单独的函数，并对每个向量有一个单独的循环（或者可能使用std::foreach）。

Answer 8

使用 boost（用于智能指针）：

foo( std::vector<boost::shared_ptr<MyType> >& v )
{
   std::for_each( v.begin(),
                  v.end(),
                  do_something );
}

bar()
{
    std::vector<boost::shared_ptr<MyType> > s;
    // s.push_back( boost::shared_ptr<MyType> ( new MySubType() ) );
    foo( s ); 
}

Answer 9

如果我知道这些 foobars 背后的真正代码是什么，那么也许我会知道得更好，但是 STL 中是否已经有解决您的问题的方法？

for_each(s.begin(), s.end(), DoStuffOnI());

只需将“do stuff on *i”代码放入函数或仿函数中即可：

struct DoStuffOnI : public std::unary_function<MyType&,void> {
    void operator()(MyType& obj) {
        // do stuff on *i
    }
};

如果您对发送两个参数而不是一个参数感到烦恼，那么好吧，也许您可​​以执行以下操作：

template<typename In>
struct input_sequence_range : public std::pair<In,In> {
    input_sequence_range(In first, In last) : std::pair<In,In>(first, last)
    {
    }
};

template<typename C>
input_sequence_range<typename C::iterator> iseq(C& c)
{
    return input_sequence_range<typename C::iterator>(c.begin(), c.end());
}

template<typename In, typename Pred>
void for_each(input_sequence_range<In> r, Pred p) {
    std::for_each(r.first, r.second, p);
}

然后像这样调用for_each：

for_each(iseq(s), DoStuffOnI());