C++ 从缓存中获取保存的可变参数

我想在一个方法中将变量参数保存在缓存中，然后在另一个函数中使用它们。 希望在不将类“X”作为模板类的情况下实现这一点，因为这意味着我需要将对象创建方式的更改传播到许多链接方法中。另外，若X被模板化，那个么X的对象将变成不同的类型，并且不能保存在同一个容器中

我首选的方法是将“bar”作为模板方法。因此，只有相关的呼叫者需要改变

我尝试了两种方法，一种是使用“Ctx”类，我不能将其作为成员，因为MsgType在类级别上是未知的。另一种方法是使用std:：vector of variant。如何在运行时将参数推送到向量？ 还有其他可能的方法吗

#include<iostream>
#include<vector>
#include <tuple>
#include <variant>

template< typename ...MsgType>
struct Ctx {
    void update(MsgType&& ... items) {
        cache = std::make_tuple(std::forward<MsgType>(items)...);
    }
    std::tuple<MsgType...> cache;
};

struct  X {
    template<typename ...MsgType>
    void bar(const int& y, MsgType&&... args) {
        Ctx<T...> ctx;   
        ctx.update(std::forward<MsgType>(args)...);
        //(vv.push_back(args)...);
    }

    void foo() {
        //use 'args' saved from last call to 'bar' 
    }

    //Ctx<...>
    //std::vector<std::variant<uint16_t, uint8_t, uint32_t>> vv;
};



int main() {

    X x;  //want to avoid making the class 'X' a  template class
    x.bar(1, 10.09, 2121);
    x.bar(2, 10.229, 2334); //Params to all call of bar for one instance of 'X' will have same number & type of args 
    x.foo();

}

#包括
#包括
#包括
#包括
模板
结构Ctx{
无效更新（MsgType&…项）{
cache=std:：make_tuple（std:：forward（items）…）；
}
std：：元组缓存；
};
结构X{
模板
空栏（常量整型和y、MsgType和…参数）{
Ctx-Ctx；
ctx.update（std:：forward（args）…）；
//（vv.推回（args）；
}
void foo（）{
//使用上次调用“bar”时保存的“args”
}
//Ctx
//std：：向量vv；
};
int main（）{
X；//要避免将类“X”作为模板类吗
x、 巴（1,10.09,2121）；
x、 bar（2，10.229，2334）；//对于一个“x”实例的所有bar调用的参数将具有相同数量和类型的参数
x、 foo（）；
}

非模板类的非模板方法

X:：f（）

可以对缓存中保存的任意数量的任意类型变量做什么？与

X:：bar

做的事情相同。除了在特定的代码路径中调用它之外，它的调用频率比

foo

低很多。它主要用于处理bar上次处理的相同数据。

foo

在不知道该数据是什么的情况下，应该如何处理

bar

提供的相同数据？答：这是不可能的。解决方案：使

X

成为模板，而不是

bar

。