C++ 使用获取指向对象基类的函数在共享_ptr的向量上使用累加

我使用的是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}
// ...
};

然后，我有一个指向基类的共享_ptr向量：

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

vector<Base_sp> v;

//在我的代码中的某个地方
typedef共享\u ptr基本\u 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);
}

intvmin=int_MAX；
int Vmax=int_MIN；
对于（vector:：const_iterator it=v_sp.begin（）；it！=v_sp.end（）；++it）
{
int v1，v2；
（*it）->最小最大值（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;

pair MinMaxFinder（pair vals，Base_sp elem）
{
int Vmin=vals.first；
int Vmax=vals.second；
if（elem）
{
int v1，v2；
元素->最小最大值（v1，v2）；
Vmin=std:：min（v1，Vmin）；
Vmax=std:：max（v2，Vmax）；
}
返回make_对（Vmin，Vmax）；
}
配对tmp=累加（v_sp.begin（），v_sp.end（），
生成一对（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)

pair MinMaxFinder（pair vals，IMyInterface*elem）

但是，这当然不能编译

---

那么，有没有一种方法，通过适配器或者别的什么，来实现我想要的？如果没有，您对如何解决这个问题有何想法？

您可以将函数参数化到所使用的指针类型上：

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*>);

模板
配对MinMaxFinder（配对VAL、MyInterfaceInter元素）
{
//函数体与您的相同
int Vmin=vals.first；
int Vmax=vals.second；
if（elem）
{
int v1，v2；
元素->最小最大值（v1，v2）；
Vmin=std:：min（v1，Vmin）；
Vmax=std:：max（v2，Vmax）；
}
返回make_对（Vmin，Vmax）；
}
向量v_sp；
累加（v_sp.begin（），v_sp.end（），
生成一对（INT_MAX、INT_MIN）、&MinMaxFinder）；
向量v_i；
累加（v_i.begin（），v_i.end（），
生成一对（INT_MAX、INT_MIN）、&MinMaxFinder）；

为方便起见，可以将其进一步包装到由容器类型参数化的函数中：

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);

模板
配对FindMinMax（MyInterfacePointerContainer const&c）
{
返回累加（c.begin（）、c.end（）、make_对（INT_MAX、INT_MIN），
&MinMaxFinder）；
}
向量v_sp；
FindMinMax（v_sp）；
向量v_i；
FindMinMax（v_i）；

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

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*>);

模板
配对MinMaxFinder（配对VAL、MyInterfaceInter元素）
{
//函数体与您的相同
int Vmin=vals.first；
int Vmax=vals.second；
if（elem）
{
int v1，v2；
元素->最小最大值（v1，v2）；
Vmin=std:：min（v1，Vmin）；
Vmax=std:：max（v2，Vmax）；
}
返回make_对（Vmin，Vmax）；
}
向量v_sp；
累加（v_sp.begin（），v_sp.end（），
生成一对（INT_MAX、INT_MIN）、&MinMaxFinder）；
向量v_i；
累加（v_i.begin（），v_i.end（），
生成一对（INT_MAX、INT_MIN）、&MinMaxFinder）；

为方便起见，可以将其进一步包装到由容器类型参数化的函数中：

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);

模板
配对FindMinMax（MyInterfacePointerContainer const&c）
{
返回累加（c.begin（）、c.end（）、make_对（INT_MAX、INT_MIN），
&MinMaxFinder）；
}
向量v_sp；
FindMinMax（v_sp）；
向量v_i；
FindMinMax（v_i）；

所谓“我不使用boost”，您的意思是您目前没有使用它，但如果它解决了您的问题，您会使用它吗；或者你的意思是，出于某种原因，你根本不能或不想使用它？我目前没有使用它，而且由于我们的“特殊”组织，开始使用它将是一件好事，尽管我看到它有很多有用的东西。通过“我不使用boost”，你的意思是你目前没有使用它，但如果它解决了你的问题，你会使用它；或者你的意思是，出于某种原因，你根本不能或根本不想使用它？我目前不使用它，而且由于我们的“特殊”组织，开始使用它将是一件好事，尽管我看到它有很多有用的东西。谢谢！我想我必须更深入地了解模板。前几天我发布了另一个问题，答案基本相同。谢谢！我想我必须更深入地了解模板。前几天我发布了另一个问题，答案基本相同。