如何在C++中访问std::bind返回函数对象的绑定参数？

问题根源 #

std::bind返回的std::_Bind类型是标准库的实现细节，标准并未规定它支持std::get接口，所以直接调用std::get<0>(f)会编译失败，这就是你遇到的错误原因。

解决方案 #

1. 利用编译器特定内部结构（非标准，临时应急） #

GCC/Clang的std::_Bind实现中，绑定参数存储在_M_bound_args成员中，这是一个std::tuple。可以通过该成员提取参数，但注意这依赖编译器实现，换环境（如MSVC）可能失效：

#include <iostream>
#include <functional>
#include <tuple>

void foo(int x, double y, char z)
{
    std::cout << "x = " << x << ", y = " << y << ", z = " << z << '\n';
}

int main()
{
    auto f = std::bind(foo, 42, 3.14, 'a');
    // 访问GCC/Clang下的绑定参数tuple
    auto& args = f._M_bound_args;
    // 注意：tuple第一个元素是绑定的函数对象，实际参数从索引1开始
    std::cout << "The first argument is: " << std::get<1>(args) << '\n';
    std::cout << "The second argument is: " << std::get<2>(args) << '\n';
    std::cout << "The third argument is: " << std::get<3>(args) << '\n';
}

2. 标准兼容方案：自定义绑定包装器 #

为保证可移植性，可自行实现bind包装器，公开存储参数的tuple，安全提取参数：

#include <iostream>
#include <functional>
#include <tuple>

// 自定义绑定包装器
template<typename Func, typename... Args>
struct BindWrapper {
    Func func;
    std::tuple<Args...> args;

    BindWrapper(Func f, Args... args_) : func(std::move(f)), args(std::forward<Args>(args_)...) {}

    template<typename... CallArgs>
    auto operator()(CallArgs&&... call_args) const {
        return std::apply(func, std::tuple_cat(args, std::make_tuple(std::forward<CallArgs>(call_args)...)));
    }
};

// 辅助函数创建BindWrapper
template<typename Func, typename... Args>
auto my_bind(Func&& func, Args&&... args) {
    return BindWrapper<std::decay_t<Func>, std::decay_t<Args>...>(
        std::forward<Func>(func), std::forward<Args>(args)...
    );
}

void foo(int x, double y, char z)
{
    std::cout << "x = " << x << ", y = " << y << ", z = " << z << '\n';
}

int main()
{
    auto f = my_bind(foo, 42, 3.14, 'a');
    std::cout << "The first argument is: " << std::get<0>(f.args) << '\n';
    std::cout << "The second argument is: " << std::get<1>(f.args) << '\n';
    std::cout << "The third argument is: " << std::get<2>(f.args) << '\n';
    f(); // 正常调用绑定函数
}

3. 针对并行generate需求的优化方案 #

你需要从bind表达式中提取随机引擎并调用discard()，可结合std::is_bind_expression做类型特化，配合traits提取引擎：

#include <functional>
#include <random>
#include <vector>
#include <type_traits>

// 提取bind表达式参数的traits（GCC/Clang版本）
template<typename BindExpr>
struct BindArgsTraits {
    using ArgsTuple = decltype(std::declval<BindExpr>()._M_bound_args);
    static constexpr size_t args_count = std::tuple_size_v<ArgsTuple> - 1; // 减去绑定的函数

    template<size_t I>
    static auto& get_arg(BindExpr& bind_expr) {
        return std::get<I+1>(bind_expr._M_bound_args); // I从0开始对应第一个绑定参数
    }
};

// 通用discard调用逻辑
template<typename Generator>
std::enable_if_t<!std::is_bind_expression_v<Generator>>
discard_generator(Generator& gen, size_t n) {
    gen.discard(n);
}

template<typename BindExpr>
std::enable_if_t<std::is_bind_expression_v<BindExpr>>
discard_generator(BindExpr& bind_expr, size_t n) {
    // 假设绑定的第一个参数是std::ref包装的随机引擎
    auto& engine_ref = BindArgsTraits<BindExpr>::template get_arg<0>(bind_expr);
    engine_ref.get().discard(n); // 解包reference_wrapper
}

// 并行generate算法示例
template<typename OutputIt, typename Size, typename Generator>
void parallel_generate_n(OutputIt first, Size count, Generator gen) {
    // 按并行任务数计算需要discard的数量
    size_t per_task = count / 4; // 示例：4个并行任务
    discard_generator(gen, per_task);

    // 后续并行生成逻辑...
}

int main() {
    std::mt19937 R(666);
    std::uniform_int_distribution<int> D(0, 100);
    auto bind_gen = std::bind(D, std::ref(R));

    std::vector<int> v(10);
    parallel_generate_n(v.begin(), v.size(), bind_gen);
}

若需完全标准兼容，推荐使用自定义BindWrapper替代std::bind，可直接访问args成员提取引擎，无需依赖编译器实现。

内容的提问来源于stack exchange，提问作者Armin Sobhani