【问题标题】:Is there any way to specify a generic argument to a function with the restriction that it should implement a given interface有没有办法为一个函数指定一个泛型参数,并限制它应该实现一个给定的接口
【发布时间】:2011-01-15 06:40:18
【问题描述】:

例子:

我有一个适用于向量的函数:

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 是自实现的,我将能够推导出两者都来自一个共同的基类(类接口)来执行 operator[] 的实现,因为两者都是库提供的,有没有办法强制转换/指定这样的限制?

我总是可以使用普通的 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;

}

【问题讨论】:

    标签: c++ arrays vector interpolation


    【解决方案1】:

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

    【讨论】:

    • 虽然在技术上是正确的,但有一些方法可以强制执行模板参数类型。例如,您可以将它分配给基类,如果在编译时失败,则它不是所述基类的子类,并且您有效地设置了类似于 java 中的扩展的限制。
    • 你知道 SFINAE 或 enable_if-paradigms 吗?
    • @roe:好吧,要测试继承,您想使用指针。 object 可以分配给另一个类型而不是子类,例如,如果它具有转换运算符重载,或者分配给的类型具有非显式 1-arg 构造函数,或者类型是构建的-in 并进行标准转换:float f = 'A';
    • @Steve:我只是在说明一点,虽然可能不防水。还有很多更精细的方案。更不用说鸭子类型方面了,因为它不会编译,除非它包含所需的方法/运算符/其他。虽然,我想无论您选择什么解决方案,如果出现问题,您将无法摆脱完全悲惨的编译错误...... :)
    【解决方案2】:

    这适用于 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)
    

    【讨论】:

    • 比我的清晰得多(即使我的工作已经完成了),并且接近我最初想要发布的内容 - 我不知道我遇到了什么 :-)
    【解决方案3】:

    虽然这对于您的特定问题来说可能是多余的,但通常您可以通过显式检查是否提供了某些成员以及某些表达式是否有效来检查模板参数是否实现了某个接口。
    Boosts concept check library 为您提供了一种干净的方式来做到这一点,但它提供的 container checking classes 在这里对您没有帮助,因为 Boost.Array 仅支持 sequence 要求的某个子集。

    如果您需要一种清晰的方式来设置限制,您可以自己建模需求,或者使用 Boosts 实用程序或类似的自定义方法。

    【讨论】:

      猜你喜欢
      • 2016-07-16
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 2017-10-13
      • 1970-01-01
      • 1970-01-01
      • 2013-10-15
      • 1970-01-01
      相关资源
      最近更新 更多