将多个不同类型的参数发送到一个方法进行处理的最佳方式。 C++

Question

目前我有一个方法如下：

std::stringstream ss; ss << "lives:" << this->Lives;
Text->RenderText(ss.str(), font, x, y, scale,color);

现在这对我来说似乎很乱，我想将它减少到一行。 但我似乎想不出一种干净利落的方法。

我曾想过使用可变函数，但这将我限制为一种类型，并且我必须指定参数的数量。

虽然使用了 std::initializer_list 或可变模板，但它似乎并没有更好。

在这个解决方案中：Here Georg Fritzsche 提供的答案显示了一个可能的解决方案：

helper() << a << b << c;

但它的实际实现我....不确定。

类似于：

Text->render(font, x, y, scale,color) << "lives:" << this->Lives;

会很好，但在方法中我不确定如何定义它。

我无法返回一个字符串流对象，因为返回后我无法访问它。

那么像这样的链式

Answer 1

返回一个累积字符串所有部分的临时对象，然后当它在语句末尾自动销毁时，让它在其析构函数中呈现内容。

#include <utility>
#include <string>
#include <sstream>
#include <iostream>
using namespace std;

class Renderer {
    stringstream sstream;
    float x;
    float y;
public:
    Renderer(float x, float y) : x(x), y(y){}
    template<class T>
    Renderer && operator<<(T&& t) {
        sstream << std::forward<T>(t);
        return std::move(*this);
    };
    ~Renderer() {
        // your real code replaces the line below..
        cout << sstream.str() << endl;
    }
};

Renderer render(float x, float y) {
    return Renderer(x, y);
}

int main() {
    int i = 5;
    render() << "foo" << i;
}

直播：https://wandbox.org/permlink/UToweQELJ4jt0QYl

Answer 2

我将如何处理这个问题

好的，所以你有这个：

std::stringstream ss; ss << "lives:" << this->Lives;
Text->RenderText(ss.str(), font, x, y, scale,color);

现在，如果您真的想在一行中完成，为什么不将字符串生成放入单个函数调用中，具体的类似

std::string life_text(int lifecount){
   std::stringstream ss;
   ss<<"lives:"<<lifecount;
   return ss.str();
}

所以你可以这样调用渲染：

Text->render(life_text(lives), x, y, scale,color);

你在找什么

首先，在我回答您提出的问题之前，<< 运算符并不意味着方法链接。至少在原版 C++ 中没有，事实上，我不认为它在 C++ 中的任何地方都使用过。

流对象并不是真正链接一个方法，而是调用类似的东西

template<typename T> std::stringstream& operator<<(std::stringstream& rightside,T leftside){
    rightside.append(leftside);
    return rightside;
}

因此，每一步都会发生如下情况：

stringstream r;
r<<"lives:";
r<<this->lives;

您所要求的并不是那么简单。您需要更改 rendertext 函数以返回一种可以传递参数的新对象。这很难。

其次，这意味着您的评估顺序会使这更具挑战性。有办法解决这个问题，但我不知道这是否是一个像上面这样简单的便利功能不会更好的情况。

如果您一心想这样做，那么您可能不得不做一些可能非常有问题的事情。您必须让对象调用实际的渲染函数（我假设您可能从某个框架中获得）。

很好，但是现在您需要添加一些范围，如果您需要按特定顺序完成此操作，这可能很重要。它可能看起来像这样：

{
    Text->render(x,y,scale,color)<<"lives:"<<this->Lives;
}

在我看来，这看起来令人沮丧。

如果您愿意，我会回答您可能对我的回答提出的任何问题，但是，至少在我看来，您最初的目标似乎是您按照自己的喜好找错了方向这样做。

以您想要的方式接近解决方案

template<std::function<typename ReturnType(std::string&,typename Ts...)> Func>
class caller{
std::stringstream r;
Ts... arguments;
Func storedFunction;
public:

caller(Func x,typename Ts...):storedFunction(x){
arguments=Ts;

}
~caller(){
Func(r.str(),...Ts);
}
friend template<typename S,typename P> caller<S>& operator<<(caller<S>&,T value);
};
template<typename S,typename P> caller<S>& operator<<(caller<S>& c, T value){
    c.r<<value;
}

调用者 a_suitable_name(std::bind(&Text::Render,&Text),_those_other_arguments); 来电者

这不太可能以目前的形式工作，但我没有时间完成定义。