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

目前我有一种方法，其工作原理如下：

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

std:：stringstream-ss；ss RenderText（ss.str（），字体，x，y，比例，颜色）；

现在我觉得这很混乱，我想把它减少到一行。 但我似乎想不出一个干净的方法

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

尽管使用std:：initializer\u列表或varidic模板，但它看起来并没有什么好的

在该解决方案中：Georg Fritzsche提供的答案显示了一个可行的解决方案，使用：

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

---

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

#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;
}

#包括
#包括
#包括
#包括
使用名称空间std；
类渲染器{
溪流；
浮动x；
浮动y；
公众：
渲染器（浮动x，浮动y）：x（x），y（y）{
模板
渲染器和运算符我将如何处理此问题（&O）
好的，你有这个：

std:：stringstream ss；ss RenderText（ss.str（），字体，x，y，比例，颜色）；

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

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

你在找什么
首先，在回答你问的问题之前，<代码运算符不意味着方法链。至少在香草C++中，实际上，我认为它不在C++中使用。
p流对象实际上并不是链接一个方法，而是调用类似/p的东西
预编码模板类型名T std:：stringstream和运算符（std:：stringstream和右侧，T左侧）{
右侧。追加（左侧）；
返回右侧；
}
/编码/预编码
pSo这一过程的每一步都会发生什么情况：/p
预破坏气流r；
r“生命：”；
他活着；
/编码/预编码
p您要求的并不是那么简单。您需要更改rendertext函数以返回一种新类型的对象，您可以将参数传递给它。这很难。/p
p其次，这意味着您的评估顺序会使这项工作更具挑战性。有很多方法可以解决这一问题，但我不知道在这种情况下，像上面这样简单的便利功能是否会更好。/p
pIf如果你死心塌地地想这样做，那么你可能不得不做一些真正可能非常有问题的事情。你必须让对象调用实际的渲染函数（我假设你可能从某个框架中调用了该函数）。/p
pFine，但现在您需要添加一些作用域，如果您需要按特定顺序执行，这些作用域可能会很重要
预编码{
Text->render（x，y，scale，color）
Text->RenderText（“lives:+std:：to_string（this->lives），font，x，y，scale，color）；
？@Jarod42您不能将
+
映射到
字符常量*
上。您可以使用“sc++11
操作符”
将其设置为std:：string，不过：“lives:”s+…其他东西`@xaxxon:如果右边的参数是
std:：string
，就可以了，就像Jarod42的例子一样。@BenjaminLindley我发誓我过去在尝试这样做时遇到过错误，但我只是尝试了一下，当然可以了。谢谢。
Renderer:：operatorAh，好吧，所以有一种中间类。我会尝试一下。应该支持吗bably add
#include
以确保
std:：forward
可用。这让我想知道，这个对象何时失去作用域？解构器何时调用？是在处理行之后？还是在使用的函数末尾？@StevenVenham它在行的末尾（语句）除非它被扩展：临时对象生命周期部分，这对于C++来说是很好的定义。我告诉过你，你不理解用<代码>做了什么。我花了大约3分钟写我的答案。它比编写函数更有效，不是吗？我只是指出一个简单的、短的函数可能更适合T。我在这里指出了一个问题，或者你不认为渲染的次序很重要吗？“排序”你正在谈论的问题..你是说你认为临时变量可能不会在正确的时间被销毁？除非它的生存期被明确延长，否则该变量将在行尾被销毁。说实话，我没有考虑使用临时变量。尽管我不同意我没有回答这个问题n、 我做了，甚至在尝试那个坏的模板代码之前，我建议用一种方法来做。尽管我承认你的观点，请你不要以那种方式使用吓人的引语。
std::string life_text(int lifecount){
   std::stringstream ss;
   ss<<"lives:"<<lifecount;
   return ss.str();
}

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

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

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

{
    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;
}