函数参数内存布局是否与结构体一致？代理函数传参疑问

先给结论 #

你设想的reinterpret_cast<FooArgs*>(&b)操作确实属于C++标准定义的未定义行为，风险极大，绝对不能这么写。

为啥不能这么干？ #

1. 参数内存布局无保障 #

C++标准从未规定函数参数在栈上的存储顺序、对齐方式，甚至是否用栈存储都不确定（比如部分参数可能通过寄存器传递）。哪怕你的FooArgs成员顺序和foo的尾部参数完全对应，也没法保证：

• 编译器会不会给参数插入填充字节？结构体的填充规则和函数参数的填充规则可能不一致。
• 像int& e这种引用类型，函数参数里实际存储的是指针，但结构体里的引用成员，标准没强制要求它的存储方式必须和函数参数中的引用完全等价。

2. 违反严格别名规则 #

C++有个严格别名的规矩：不能用一种类型的指针去访问另一种不相关类型的对象。你把float*（&b的类型）转成FooArgs*，再去访问里面的void*、std::string等成员，本质就是用FooArgs类型的指针去访问其他类型的参数，直接违反规则。编译器碰到这种情况可能会进行不合理优化，比如直接忽略你的强转操作，导致程序逻辑混乱。

3. 未构造合法的FooArgs对象 #

你只是把一块原本属于函数参数的内存，强行当成FooArgs对象来使用，但这个FooArgs对象根本没有被构造出来。C++对对象生命周期有严格要求，这种“凭空捏造”对象的操作，被标准直接定义为未定义行为。

低开销调用foo_impl的可行方案 #

既然不能修改foo的接口，给你几个实际可用的低开销方案：

1. 让foo_impl直接复用原参数签名 #

最简单的办法就是让foo_impl保持和当前调用的参数列表一致，同时用移动语义减少拷贝：

// 直接复用原参数列表，无需任何打包操作
int foo_impl(float b, void* c, std::string d, int& e, int f) {
    // 你的业务逻辑
}

int foo(int a, float b, void* c, std::string d, int& e, int f) {
    // 你的簿记操作
    return foo_impl(b, c, std::move(d), e, f); // 对string用move转移所有权，无拷贝开销
}

std::move(d)会把原参数的std::string所有权直接转给foo_impl，几乎没有额外开销。

2. 用转发引用完美传递参数（C++11+） #

如果想更灵活，用模板加转发引用来完美传递参数，连移动操作都能省（针对引用类型）：

#include <utility>

template<typename... Args>
int foo_impl(Args&&... args) {
    // 业务逻辑中用std::forward转发参数
}

int foo(int a, float b, void* c, std::string d, int& e, int f) {
    // 簿记操作
    return foo_impl(b, c, std::move(d), std::forward<int&>(e), f);
}

这种方式能完全保留参数的类型和值类别，避免任何不必要的拷贝。

3. 用tuple+apply打包传递（C++11+） #

如果一定要把参数打包成整体，用std::tuple加std::apply，同时结合移动和引用包装减少开销：

#include <tuple>
#include <functional>

int foo_impl(float b, void* c, std::string d, int& e, int f) {
    // 业务逻辑
}

int foo(int a, float b, void* c, std::string d, int& e, int f) {
    // 簿记操作
    auto args = std::make_tuple(b, c, std::move(d), std::ref(e), f);
    return std::apply(foo_impl, std::move(args));
}

std::ref(e)用来传递引用类型，std::move避免tuple和std::string的拷贝，开销极小。

内容的提问来源于stack exchange，提问作者Alexey S. Larionov