使用采用指向对象基类的函数对shared_ptr向量进行累加

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}
// ...
};

然后我有一个指向基类的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);