Question

是否可以使用模板实现下面说明的想法：

// please excuse any syntax errors.

template<typename KEY, typename VALUE>
class Container {
public: 
    VALUE calculate(vector<KEY> searchFors)
    {
        KEY searchFor = searchFors[0];
        pair<KEY,VALUE> lower = getLower(searchFor);
        pair<KEY,VALUE> upper = getUpper(searchFor);
        // calculateImpl uses + - * /
        VALUE value = calculateImpl( 
            lower.first, lower.second(searchFor), 
            upper.first, upper.second(searchFor) );   
        return value;
    }
    // an example of calculateImpl
    VALUE calculateImpl( KEY key1, VALUE value1, KEY key2, VALUE value2 )
    {
         return value1 * value2;
    }
    // an example of getLower getUpper, assuming there're more than 2 elements in _data
    pair<KEY,VALUE> getLower(KEY key)
    {
         return *(_data.begin());
    }        
    pair<KEY,VALUE> getUpper(KEY key)
    {
         return *(_data.begin()+1);
    }        

private:
    vector<pair<KEY,VALUE>> _data;
};

请注意，VALUE需要operator（）的实现。我怎样才能使它可以在原语或仿函数之间进行选择？例如，如果searchFors.size（）== 0，则使用VALUE作为基元，否则，使用VALUE作为函子？

换句话说，VALUE可以是基元（VALUE的类型），也可以是仿函数（VALUE（*）（KEY）的类型），具体取决于依赖于向量大小的开关。

这种容器的用法是

vector<double> keys;
keys.push_back(2);  
keys.push_back(3);

// usage as primitive 
// Note Container<double,double> where VALUE=double
Container<double,Container<double,double>> c1;
double result1 = c1.calculate(keys);

Container<double,Container<double,Array<double>>> c2;
Array<double> result2 = c1.calculate(keys);

我希望能够嵌套容器，递归调用calculate，当VALUE不再是Container时停止。

编辑：添加了代码

template<typename KEY, typename VALUE>
class Container {
public: 
Container(vector<KEY> x, vector<VALUE> y)
    :_x(x),
    _y(y) {}

    VALUE calculate(vector<KEY> searchFors)
{
    if( searchFors.size() == 0 )
    {
        throw exception("no search keys");
    }
    KEY key = searchFors[0];

    if( key >= *(_x.end()-1) )
    {
        return *(_y.end()-1);
    }
    if( key <= *(_x.begin()) )
    {
        return *(_y.begin());
    }
    vector<KEY>::const_iterator iSearchKey;
    iSearchKey = upper_bound( _x.begin(), _x.end(), key );
    size_t pos = iSearchKey - _x.begin();
    return (_y[pos]-_y[pos-1])/(_x[pos]-_x[pos-1]) * (key-_x[pos-1]) + _y[pos-1];
}
private:
vector<KEY> _x;
vector<VALUE> _y;
};


template<typename KEY, typename VALUE>
class Container<KEY, Container<KEY, VALUE> > {
public: 
Container(vector<KEY> x, vector<Container<KEY, VALUE> > y)
    :_x(x),
    _y(y) {}

VALUE calculate(vector<KEY> searchFors)
{
    if( searchFors.size() == 0 )
    {
        throw exception("no search keys");
    }
    KEY key = searchFors[0];
    vector<KEY> remainingKeys( searchFors.begin()+1, searchFors.end() );

    if( key >= *(_x.end()-1) )
    {
        return (_y.end()-1)->calculate(remainingKeys);
    }
    if( key <= *(_x.begin()) )
    {
        return _y.begin()->calculate(remainingKeys);
    }

    vector<KEY>::const_iterator iSearchKey;
    iSearchKey = upper_bound( _x.begin(), _x.end(), key );
    size_t pos = iSearchKey - _x.begin();

    VALUE upperY = _y[pos].calculate(remainingKeys);
    VALUE lowerY = _y[pos-1].calculate(remainingKeys);

    return (upperY-lowerY)/(_x[pos]-_x[pos-1]) * (key-_x[pos-1]) + lowerY;
}
private:
vector<KEY> _x;
vector<Container<KEY, VALUE> > _y;
};

void main()
{
using namespace boost::assign;

vector<double> y;
vector<double> z;

y += 1,2,3,4;
z += 1,4,9,16;
Container<double,double> yz1(y,z);

z.clear();
z += 1,8,27,64;
Container<double,double> yz2(y,z);

vector<double> x;   
x += 1,4;
vector<Container<double,double> > ys;
ys += yz1,yz2;

Container<double,Container<double,double> > xy(x,ys);

    vector<double> keys;
keys += 2.5,3.5;
double value = xy.calculate(keys);

    // prints 29
cout << value << endl;

}

编辑：通过存储迭代器而不是数据

来提高效率

template<typename KEY, typename VALUE>
class Container;

template<typename KEY, typename VALUE>
class Container_helper{
public:
typedef typename std::vector<KEY>::const_iterator key_iterator_type;
typedef VALUE value_type;
typedef typename vector<VALUE>::const_iterator value_iterator_type;

static value_type getValue(const value_iterator_type& iValue, 
    const key_iterator_type&, const key_iterator_type&){
          return *iValue;
     }
};

template<typename KEY, typename VALUE>
class Container_helper<KEY, Container<KEY, VALUE> >{
public:
typedef typename std::vector<KEY>::const_iterator key_iterator_type;
     typedef typename Container_helper<KEY, VALUE>::value_type value_type;
typedef typename std::vector<Container<KEY, VALUE> >::const_iterator value_iterator_type;

static value_type getValue(const value_iterator_type& iValue, 
    const key_iterator_type& xBegin, const key_iterator_type& xEnd)
{
           return (*iValue)(xBegin,xEnd);
     }
};

template<typename KEY, typename VALUE>
class Container {

typedef typename std::vector<KEY>::const_iterator key_iterator_type;
typedef typename std::vector<VALUE>::const_iterator value_iterator_type;
typedef typename Container_helper<KEY, VALUE>::value_type value_type;

public:   
Container(const key_iterator_type& xBegin, 
          const key_iterator_type& xEnd,        
          const value_iterator_type& yBegin, 
          const value_iterator_type& yEnd)
    :_xBegin(xBegin),_xEnd(xEnd),_yBegin(yBegin),_yEnd(yEnd) {}
Container(const Container& source)
    :_xBegin(source._xBegin),_xEnd(source._xEnd),
     _yBegin(source._yBegin),_yEnd(source._yEnd) {}
     Container& operator=(const Container& source)
{
    _xBegin = source._xBegin;
    _xEnd = source._xEnd;
    _yBegin = source._yBegin;
    _yEnd = source._yEnd; 
    return *this;
}


public:
     value_type 
operator()( const key_iterator_type& searchBegin, const key_iterator_type& searchEnd ) const
{
    if( searchBegin == searchEnd )
    {
        throw exception("no search keys");
    }
    KEY key = *searchBegin;
    key_iterator_type searchNext = searchBegin + 1;

              if( key >= *(_xEnd-1) )
              {
                  return Container_helper<KEY,VALUE>::getValue(_yEnd-1, searchNext, searchEnd);
              }
              if( key <= *_xBegin )
              {
                  return Container_helper<KEY,VALUE>::getValue(_yBegin, searchNext, searchEnd);
              }

              key_iterator_type iSearchKey = upper_bound( _xBegin, _xEnd, key );
              size_t pos = iSearchKey - _xBegin;

    KEY lowerX = *(_xBegin+pos-1);
    KEY upperX = *(_xBegin+pos);

              value_type upperY = Container_helper<KEY,VALUE>::
        getValue(_yBegin+pos, searchNext, searchEnd);
              value_type lowerY = Container_helper<KEY,VALUE>::
        getValue(_yBegin+pos-1, searchNext, searchEnd);

              return (upperY-lowerY)/(upperX-lowerX) * (key-lowerX) + lowerY;
         }

  private:
     key_iterator_type _xBegin; 
     key_iterator_type _xEnd;       
     value_iterator_type _yBegin; 
     value_iterator_type _yEnd; 
  };

Answer 1

我认为您可以在Container类中定义一个获取VALUE和KEY并返回VALUE的方法。然后你可以将这个函数指定为返回值或调用函子。或者（我可能会这样做）编写一个Wrapper类，它将一个Primitive包装到一个Functor中，所以当你需要一个原语时，只需使用Wrapper创建一个Container。这看起来像这样（这可能不会编译）

 template<typename KEY, typename VALUE>
 class PrimitiveToFunctor {
   public:
    PrimitiveToFunctor(VALUE v) {
       value = v;
    }
    VALUE function_to_wrap(KEY key) {
       return value;
    } 
  private:
  VALUE value;
 }

Container<double, Container<double, PrimitiveToFunction<double>>> c1;

Answer 2

如果我理解你的话，我认为这可能对你有用

template<typename KEY, typename VALUE>
class Container {
public: 
    VALUE calculate(vector<KEY> searchFors);
    .
    .
    .
private:
    vector<pair<KEY,VALUE> > _data;

};

template<typename KEY, typename VALUE>
VALUE Container<KEY, VALUE>::calculate(vector<KEY> searchFors)
{
     // operate on non-container (simple) values.
}

template<typename KEY, typename VALUE>
class Container<KEY, Container<KEY, VALUE> > {
public: 
    VALUE calculate(vector<KEY> searchFors);
    .
    .
    .
private:
    vector<pair<KEY, Container<KEY, VALUE> > > _data;
};

template<typename KEY, typename VALUE>
VALUE Container<KEY, Container<KEY, VALUE> >::calculate(vector<KEY> searchFors)
{
     // operate on container values
}

这些函数应该很好地封装什么是基类型和什么是容器。唯一的问题是它只适用于容器类 - 如果你有多种类型的容器，你可能会使用某种类型的特征。

编辑：

在看到你的确切示例之后，我看到将功能分离到helper类是可能的，但它会使用其他类来破坏命名空间。如果您不介意，那么代码就在这里：

#include <iostream>
#include <vector>

#include <boost/assign.hpp> 

using namespace std;

template<typename KEY, typename VALUE>
class Container;

template<typename KEY, typename VALUE>
class Container_helper{
public:
    typedef VALUE value_type;

    static value_type calculate(VALUE& val, vector<KEY> /*remainingKeys*/){
        return val;
    }
};

template<typename KEY, typename VALUE>
class Container_helper<KEY, Container<KEY, VALUE> >{
public:
    typedef typename Container_helper<KEY, VALUE>::value_type value_type;

    static value_type calculate(Container<KEY, VALUE>& val, vector<KEY> remainingKeys){
        return val.calculate(remainingKeys);
    }
};

template<typename KEY, typename VALUE>
class Container {

public: 

Container(vector<KEY> x, vector<VALUE> y)
    :_x(x),
    _y(y) {}

public:

    typename Container_helper<KEY, VALUE>::value_type calculate(vector<KEY> searchFors){
          if( searchFors.size() == 0 )
        {
            throw exception(/*"no search keys"*/);
        }
        KEY key = searchFors[0];
        vector<KEY> remainingKeys( searchFors.begin()+1, searchFors.end() );

        if( key >= *(_x.end()-1) )
        {
            return Container_helper<KEY, VALUE>::calculate(*(_y.end()-1), remainingKeys);
        }
        if( key <= *(_x.begin()) )
        {
            return Container_helper<KEY, VALUE>::calculate((*_y.begin()), remainingKeys);
        }

        typename vector<KEY>::const_iterator iSearchKey;
        iSearchKey = upper_bound( _x.begin(), _x.end(), key );
        size_t pos = iSearchKey - _x.begin();

        typename Container_helper<KEY, VALUE>::value_type upperY = Container_helper<KEY, VALUE>::calculate(_y[pos], remainingKeys);
        typename Container_helper<KEY, VALUE>::value_type lowerY = Container_helper<KEY, VALUE>::calculate(_y[pos-1], remainingKeys);

        return (upperY-lowerY)/(_x[pos]-_x[pos-1]) * (key-_x[pos-1]) + lowerY;
    }

private:
vector<KEY> _x;
vector<VALUE> _y;
};


int main(int argc, char* argv[])
{
using namespace boost::assign;

vector<double> y;
vector<double> z;

y += 1,2,3,4;
z += 1,4,9,16;
Container<double,double> yz1(y,z);

z.clear();
z += 1,8,27,64;
Container<double,double> yz2(y,z);

vector<double> x;   
x += 1,4;
vector<Container<double,double> > ys;
ys += yz1,yz2;

Container<double,Container<double,double> > xy(x,ys);

    vector<double> keys;
keys += 2.5,3.5;
double value = xy.calculate(keys);

    // prints 29
cout << value << endl;

}

c ++ template：如何在类和基元类型之间动态选择

2 个答案: