Question

我不知道这是否可以实现，但考虑到这些功能集\ class：

float plus1(float x) { return x+1; }
float div2(float x) { return x/2.0f; }
template <typename T>
class chain {
public:
    chain(const T& val = T()) : val_(val) {}
    chain& operator<<( std::function<float (float)> func ) {
    val_ = func(val_);
    return *this;
  }
  operator T() const {
    return val_;
  }
  T val_;
};

我可以链接在浮点数上运行的函数，如下所示：

float x = chain<float>(3.0f) << div2 << plus1 << div2 << plus1;

但是，我想概括\扩展它，以便能够在类型之间进行转换并具有带参数的函数。不幸的是，我不够聪明，无法弄清楚如何或者是否可以做到这一点。更具体的我希望能够像这样做某事（其中operator<<只是一个仲裁选择，最好我甚至不必在开头写“链” ）; 此外，这些只是虚拟的例子，我不打算将它用于算术。

std::string str = chain<float>(3.0) << mul(2.0f) << sqrt << to_string << to_upper;

或

vec3d v = chain<vec3i>(vec3i(1,1,1)) << normalize << to_vec3<double>;

有什么想法吗？

Answer 1

我想我明白你为什么要这样做。它类似于iostream操纵器。

您始终需要从chain(...)开始（即您永远无法神奇地执行int x = 1 << plus(2) << times(2)之类的操作），但您可以重载operator int，operator float ，...允许隐式转换。

您还需要返回并定义每种类型（如mul），然后实现需要mul或const mul的operator<<，但总的来说它是可行的（但是PITA ）

Answer 2

为了获得类型之间的转换，您希望一切都返回一个代理对象，可以转换为任何类型。可能是基于boost :: variant的东西。

您还可以重写您的运算符＆lt;＆lt;作为模板函数，使其更通用：

template <class UnaryFunction>
chain& operator<<(UnaryFunction func) { _val = func(_val); return *this;}

这将允许您使用任何类型的函数对象作为参数。

要使用具有多个参数的函数，可以使用bind函数。这是在C ++ 11之前的提升，但现在它已经在标准中，应该可以在任何兼容C ++ 11的编译器上使用。

Answer 3

使用boost :: proto的一般和可扩展的解决方案：

#include <iostream>
#include <boost/proto/proto.hpp>

namespace bp = boost::proto;

// -----------------------------------------------------------------------------
// perform is a callable transform that take a function_ terminal and execute it
// -----------------------------------------------------------------------------
struct perform : bp::callable
{
  template<class Sig> struct result;
  template<class This, class Func, class In>
  struct result<This(Func,In)> 
       : boost::result_of<typename boost::remove_reference<Func>::type(In)> {};

  template<class Func, class In>
  typename result<perform(Func &,In)>::type
  operator()( Func& f, In& in ) const
  {
    return f(in);
  }
};

// -----------------------------------------------------------------------------
// Grammar for chaining pipe of functions
// -----------------------------------------------------------------------------
struct pipeline_grammar
: bp::or_<
    bp::when<
        bp::bitwise_or<pipeline_grammar,pipeline_grammar>
          , pipeline_grammar(
                bp::_right
              , pipeline_grammar(bp::_left,bp::_state)
                )
        >
      , bp::when<
            bp::terminal<bp::_>
          , perform(bp::_value, bp::_state) 
    >
> {};

// -----------------------------------------------------------------------------
// Forward declaration of the pipeline domain
// -----------------------------------------------------------------------------
struct pipeline_domain;

// -----------------------------------------------------------------------------
// A pipeline is the top level DS entity
// -----------------------------------------------------------------------------
template<class Expr>
struct  pipeline : bp::extends<Expr,pipeline<Expr>, pipeline_domain>
{
  typedef bp::extends<Expr, pipeline<Expr>, pipeline_domain> base_type;
  pipeline(Expr const &expr = Expr()) : base_type(expr) {}

  // ---------------------------------------------------------------------------
  // A pipeline is an unary callable object
  // ---------------------------------------------------------------------------
  template<class Input>
  typename boost::result_of<pipeline_grammar(pipeline,Input)>::type
  operator()(Input const& in) const
  {
    pipeline_grammar evaluator;
    return evaluator(*this,in);
  }
};

// -----------------------------------------------------------------------------
// the pipeline_domain make pipeline expression macthes pipeline_grammar
// -----------------------------------------------------------------------------
struct pipeline_domain 
     : bp::domain<bp::generator<pipeline>,pipeline_grammar>
{};

// -----------------------------------------------------------------------------
// Takes a PFO instance and make it a pipeline terminal
// -----------------------------------------------------------------------------
template<class Func>
typename bp::result_of::
make_expr<bp::tag::terminal, pipeline_domain,Func>::type
task( Func const& f )
{
  return bp::make_expr<bp::tag::terminal,pipeline_domain>( f );
}

//--------------------------- Examples --------------------

struct return_value
{  
  template<class Sig> struct result;
  template<class This, class T>
  struct result<This(T)> : bp::detail::uncvref<T>
  {};

  return_value(int i = 1) : factor(i) {}

  template<class T> 
  T operator()(T const& in) const
  {
    return in*factor;
  }

  int factor;
};

struct say_hi
{
  typedef void result_type;

  template<class T> 
  void operator()(T const& in) const
  {
    std::cout << "Hi from value = " << in << "\n";
  }
};

int main()
{
  return_value r1,r2(5);
  (task(r1) | task(r2) | task(say_hi())) (7); // SHould print 35

  float k = 10,r;
  r = (task(r2) | task(r2) | task(r2) | task(r2))(k);
  std::cout << r << "\n"; // Should print 6250
}

基本思想是将函数对象包装为proto终端，构建一个小的|基于语法，让原型系统处理组合。

C ++中非成员函数的广义链接

3 个答案: