C++ 确定C+中编译时可变模板类实例的最大大小+；

我想确定以下可变模板类实例在编译时的最大大小

template <typename... T>
class Foo
{
public:

    std::tuple<T...> params;
    void (*func)(T...);

    void save(T...args)
    {
        params=std::make_tuple(args...);
    }

    void call()
    {
        std::apply(func,params);
    }
};

模板
福班
{
公众：
std：：元组参数；
无效（*func）（T.）；
无效保存（T…args）
{
params=std:：make_tuple（args…）；
}
无效调用（）
{
标准：：应用（函数、参数）；
}
};

我想按如下方式使用该类：

void testfoo1(int a,double b,double c,double d)
{
    std::cout<<a<<"--"<<b<<c<<d<<std::endl;
}

void testfoo2(int a,double b,double c,double d,int e,long long int f)
{
    std::cout<<a<<"--"<<b<<c<<d<<e<<f<<std::endl;
}
struct FooObject
{
    char buffer[MAX_SIZE_FOO_OBJECT];
};

int main()
{
    std::queue<FooObject> fooObjectBuffer;
    FooObject foo_temp;
    Foo<int,double,double,double> foo1;
    Foo<int,double,double,double,int,long long int> foo2;
    foo1.func=testfoo1;
    foo1.save(5,10.2,5.3,2.7);
    foo2.func=testfoo2;
    foo2.save(1,2,3,4,5,6);
    fooObjectBuffer.push(*reinterpret_cast<FooObject*>(&foo1));
    fooObjectBuffer.push(*reinterpret_cast<FooObject*>(&foo2));

    foo_temp=fooObjectBuffer.front();
    reinterpret_cast<decltype (foo1)*>(&foo_temp)->call();
    fooObjectBuffer.pop();
    fooObjectBuffer.front();
    foo_temp=fooObjectBuffer.front();
    reinterpret_cast<decltype (foo2)*>(&foo_temp)->call();
    fooObjectBuffer.pop();
}

void testfoo1（int a、双b、双c、双d）
{
std:：cout它是一个模板；除非您对可以进入
Foo
的各种
T
提供一些特定的限制，否则任何人都可以用任何类型实例化它，这些类型可以是
std:：tuple
的成员，或者适合您的接口。
T
s的集合是无限的，因此是不可知的。这意味着任何操作对各种可能的
T
s的定量（如计算最大尺寸）同样是不可知的

只有当你有一组固定的、有界的有效
T
s，你才能知道这一点。即使这样，你也需要大量的模板元编程来计算每个
Foo
的大小，这些
T
s的每一个组合都会实例化

最好完全避免这种情况，做一些类型更安全的事情。否则，如果有人试图用超过此大小的类型实例化
Foo
，请选择一个您满意的最大大小，然后在某个地方执行
static\u assert
。
sizeof（Foo）有什么问题吗

？您的类型双关是UB…

std:：max（sizeof（T）…）

但我可以在设计中使用Foo的另一个变体。例如，Foo或Foo等。我希望将这些对象中的任何一个推送到fooObjectBuffer，而不会出现任何缓冲区溢出问题。@这是不可能的。您可以选择一个大小，使用一个模板，使每个唯一的

Foo

获得自己的缓冲区，或者使用不同的方法。