有没有办法用一行在同一个对象上调用多个函数？

Question

只是想整理一个程序，想知道是否有人可以给我一些关于在同一行上多次调用一个队列上的成员函数的语法糖。

例如，改变：

queue<int> q;
q.push(0);
q.push(1);

类似于：

q.(push(0), push(1));
//or
q.push(0).push(1);

我知道这看起来有点荒谬，而且不实用。但是，如果我想缩短这样的一小部分代码，是否可以选择这样做？从我目前阅读的内容来看，只有当函数具有非void 返回值时，才可能链接方法。

当然，这是一个选项：

q.push(0); q.push(1);

但我试图避免出现两次q。再次......语法糖:)

这里的目标不是初始化，而是压缩一个对象/容器在一段代码中被调用的次数。我引用队列的原因是因为它是动态的。

Answer 1

如果你有一个可以修改的类，让函数返回一个对自身的引用：

template<typename T>
class queue {
public:
    //...
    queue& push(T data) {
        //...
        return *this; //return current instance
    }
    //...
private:
    //...
};

那你就可以了

queue<int> q;
q.push(0).push(1);

---

如果你不能，那么你的双手就被束缚了。您可以对类进行包装，但为了节省一些字符，这几乎不值得。

在您使用push 的情况下，您可以这样做：

queue<int> q = { 0, 1 };

但这显然只适用于push，因为在两次推送之后队列将包含0 和1。

Answer 2

你总是可以只定义一个包装器，比如

template< class Item >
void push( queue<Item>& q, std::initializer_list<Item> const& values )
{
    for( Item const& v : values ) { q.push( v ); }
}

然后这样称呼它：

push( q, {1, 2, 3} );

如果你想要的不是符号方便，而只是使用流畅的接口技术，那么如果你不能修改类，定义一个操作符：

template< class Item >
auto operator<<( queue<Item>& q, Item v )
    -> queue<Item>&
{ q.push( move( v ) ); return q; }

然后这样称呼它：

q << 1 << 2 << 3;

请务必记录您的同事尝试掌握代码的过程。 :)

哦，好吧，仍然，如果你不能修改类，你当然可以这样做：

template< class Item >
struct Fluent
{
    queue<Item>& items;

    auto push( Item v )
        -> Fluent&
    { items.push( move( v ) ); return *this; }

    Fluent( queue<Item>& q ): items( q ) {}
};

然后这样称呼它：

Fluent( q ).push( 1 ).push( 2 ).push( 3 );

免责声明：编译器未触及任何代码。

玩得开心！

Answer 3

这里只是为了好玩，这是一个小模板技巧，它提供了一种链接几乎所有方法的方法，忽略返回值：

// The struct providing operator()(...) so that a call is simply
// chainer_t_instance(param_for_call1)(param_for_call2)(param_for_call3);
template <typename Class, typename Method>
struct chainer_t
{
    chainer_t(Class& instance, Method&& method) :
        _instance(instance),
        _method(method)
    {}

    chainer_t(chainer_t&& chainer) :
        _instance(chainer._instance),
        _method(chainer._method)
    {}

    // Avoid copy to avoid misunderstanding
    chainer_t(const chainer_t&) = delete;    
    chainer_t& operator=(const chainer_t&) = delete;

    // Operator () takes anything
    template <typename... Types>
    chainer_t& operator()(Types&&... types)
    {
        (_instance.*_method)(std::forward<Types>(types)...);
        return *this;
    }

protected:
    Class& _instance;
    Method& _method;
};

// Just to ease the writting
template <typename Class, typename Method>
chainer_t<Class, Method> chain(Class& instance, Method&& method)
{
    using chainer = chainer_t<Class, Method>;
    return chainer(instance, std::forward<Method>(method));
}

链式调用将是：

chain(my_instance, &my_class::add)(1)(2)(3)(4);

Live example

Answer 4

auto repeat_call = [](auto&& f){
  return y_combinate(
    [f=decltype(f)(f)](auto&& self, auto&&...args)->decltype(self){
      f( decltype(args)(args)... );
      return decltype(self)(self);
    }
  );
};

y_combinate being a y combinator.

现在我们可以repeat_call( [&](int x){ q.push(x); } )(1)(0);

Answer 5

如果不能修改类，仍然可以使用逗号：

#include<queue>
#include<iostream>

int main() {
    std::queue<int> q;
    (q.push(0), q).push(1);
    std::cout << q.size() << std::endl;
}

Answer 6

这可能不是您要寻找的，但请不要忘记，C++ 不是基于行的语言（// cmets 除外）。

因此，将多个简短的语句放在一行中是完全合理的。从而达到：

在同一个队列上多次调用成员函数 行。

你只需要改变：

queue<int> q;
q.push(0);
q.push(1);

进入：

queue<int> q;
q.push(0); q.push(1);

不，它不会删除两次键入 q，但如果这是一个问题，我怀疑你的问题更有可能是名称过长的变量。假设是这种情况，请记住您可以使用引用来为变量提供更简单的本地句柄：

auto &foo = a_really_long_name_for_a_queue;
foo.push(0); foo.push(1);