Question

我正在使用VS2008（所以我有TR1，但没有C ++ 11），我不使用boost。以下描述是我真实问题的简化版本。

我有以下类层次结构：接口，实现它的抽象类以及从该抽象类派生的几个类：

struct IMyInterface
{
    virtual void MinMax(int& Min, int& Max)const = 0;
};

class Base : public IMyInterface // Abstract
{
// ...
};

class A: public Base
{
public:
    virtual void MinMax(int& Min, int& Max)const { // Some stuff for A}
// ...
};

class B: public Base
{
public:
    virtual void MinMax(int& Min, int& Max)const { // Some stuff for B}
// ...
};

然后我有一个到Base类的shared_ptr向量：

// Somewhere in my code
typedef shared_ptr<Base> Base_sp;

vector<Base_sp> v;

我有一些代码可以做到这一点：

int Vmin = INT_MAX;
int Vmax = INT_MIN;
for(vector<Base_sp>::const_iterator it = v_sp.begin(); it != v_sp.end(); ++it)
{
    int v1, v2;
    (*it)->MinMax(v1, v2);

    Vmin = std::min(v1, Vmin);
    Vmax = std::max(v2, Vmax);
}

我在不止一个地方使用类似的代码，所以我把它带到了一个我累积的函数中：

pair<int, int> MinMaxFinder(pair<int, int> vals, Base_sp elem)
{
    int Vmin = vals.first;
    int Vmax = vals.second;

    if (elem)
    {
        int v1, v2;
        elem->MinMax(v1, v2);

        Vmin = std::min(v1, Vmin);
        Vmax = std::max(v2, Vmax);
    }
    return make_pair(Vmin, Vmax);
}


pair<int, int> tmp = accumulate(v_sp.begin(), v_sp.end(), 
                                make_pair(INT_MAX, INT_MIN), &MinMaxFinder);
int Vmin = tmp.first;
int Vmax = tmp.second;

这很好用，但是，在我使用我要替换的代码的其他地方，我不一定使用Base_sp派生类，而是使用其他IMyInterface派生类。所以我想像这样声明MinMaxFinder：

pair<int, int> MinMaxFinder(pair<int, int> vals, IMyInterface* elem)

但是，当然，这不会编译。

那么，有没有办法，通过适配器或其他东西，做我想要的？如果不是，关于如何解决这个问题的任何想法？

Answer 1

您可以使用指针类型对函数进行参数化：

template <typename MyInterfacePointer>
pair<int, int> MinMaxFinder(pair<int, int> vals, MyInterfacePointer elem)
{
    // Function body is identical to yours
    int Vmin = vals.first;
    int Vmax = vals.second;

    if (elem)
    {
        int v1, v2;
        elem->MinMax(v1, v2);

        Vmin = std::min(v1, Vmin);
        Vmax = std::max(v2, Vmax);
    }
    return make_pair(Vmin, Vmax);
}

vector<Base_sp> v_sp;   
accumulate(v_sp.begin(), v_sp.end(), 
           make_pair(INT_MAX, INT_MIN), &MinMaxFinder<Base_sp>);

vector<IMyInterface*> v_i;
accumulate(v_i.begin(), v_i.end(), 
           make_pair(INT_MAX, INT_MIN), &MinMaxFinder<IMyInterface*>);

为方便起见，这可以进一步包含在由容器类型参数化的函数中：

template <typename MyInterfacePointerContainer>
pair<int, int> FindMinMax(MyInterfacePointerContainer const & c)
{
    return accumulate(c.begin(), c.end(), make_pair(INT_MAX, INT_MIN),
        &MinMaxFinder<typename MyInterfacePointerContainer::value_type>);
}

vector<Base_sp> v_sp;
FindMinMax(v_sp);

vector<IMyInterface*> v_i;
FindMinMax(v_i);

使用带有指向对象基类的函数在shared_ptr的向量上使用accumulate

1 个答案: