有没有办法为函数指定通用参数，并限制它应该实现给定的接口

Question

示例：

我有一个使用向量的函数：

double interpolate2d(const vector<double> & xvals, const vector<double> & yvals, double xv, double yv, const vector<vector<double> > &fvals) {
    int xhi, xlo, yhi, ylo;
    double xphi, yphi;
    bracketval(xvals,xv,xhi,xlo,xphi);
    bracketval(yvals,yv,yhi,ylo,yphi);
    return (fvals[xhi][yhi]*xphi+fvals[xlo][yhi]*(1.-xphi))*yphi + (fvals[xhi][ylo]*xphi+fvals[xlo][ylo]*(1.-xphi))*(1.-yphi);
}

但现在我想用 boost::array 元素作为前 2 个参数来调用它（与括号val() 相同），如果 std::vector 和 boost::array 是自变量实现后，我将能够从强制实施运算符[]的公共基类（类似接口）派生两者，因为两者都是库提供的，有什么方法可以强制转换/指定这样的限制吗？

我总是可以求助于普通的 c 数组，但它不是很简洁。

编辑：FWIW，这是原始的括号实现：

void bracketval(const vector<double> &vals, double v, int &hi, int &lo, double &prophi){
    hi=vals.size()-1;
    lo=0;
    while(abs(hi-lo)>1) {
        int md = (hi+lo)/2;
        if(vals[md]>v) hi=md; else lo=md;
    }
    if(vals[hi]!=vals[lo])
        prophi = (v-vals[lo])/(vals[hi]-vals[lo]);
    else
        prophi = 0.5;

}

Answer 1

这适用于 std::vector、boost::array、内置数组以及通常可索引的任何内容。我还提供了有关如何实现 bracketval 函数的建议：

template<class Vec>
void bracketval(Vec const & xvals, double xv, int xhi, int xlo, double xphi)
{
}

template <class Vec, class VecOfVecs>
double interpolate2d(Vec const & xvals, Vec const & yvals, 
                     double xv, double yv,
                     VecOfVecs const & fvals)
{
    int xhi, xlo, yhi, ylo;
    double xphi, yphi;
    bracketval(xvals,xv,xhi,xlo,xphi);
    bracketval(yvals,yv,yhi,ylo,yphi);
    return (fvals[xhi][yhi]*xphi+fvals[xlo][yhi]*(1.-xphi))
             *yphi + (fvals[xhi][ylo]*xphi+fvals[xlo][ylo]
             *(1.-xphi))*(1.-yphi);
}

int main()
{
    {
        std::vector<double> v, w;
        std::vector<std::vector<double> > vv;
        interpolate2d(v, w, 1., 2., vv);
    }
    {
        boost::array<double, 4> v, w;
        boost::array<boost::array<double, 4>, 4> vv;
        interpolate2d(v, w, 1., 2., vv);
    }
    {
        double v[4], w[4];
        double vv[4][4];
        interpolate2d(v, w, 1., 2., vv);
    }    
}

如果您设想第二个向量可能与第一个向量的类型不同，您甚至可以添加额外的模板参数（例如，第一个是向量，第二个是 boost::array）：

template <class VecX, class VecY, class VecOfVecs>
double interpolate2d(VecX const & xvals, VecY const & yvals, 
                     double xv, double yv,
                     VecOfVecs const & fvals)

Answer 2

虽然这对于您的特定问题来说可能有点过分，但通常您可以通过显式检查是否提供了某些成员以及某些表达式是否有效来检查模板参数是否实现特定接口。
Boosts 概念检查库为您提供了一种干净的方式这样做，但是容器检查类 它提供的内容对您没有帮助，因为 Boost.Array 仅支持序列要求的某个子集。

如果您需要一种干净的方式来施加限制，您可以做的是自己对需求进行建模，使用 Boosts 实用程序或类似的自定义方法。

Answer 3

无法对模板参数进行类型限制。您可以定义自己的接口并为您想要支持的所有类型创建适配器。