与std::bind相反，为给定参数传递不同的函数
，可以使用std::function和lambda表达式来实现。
std::function是C++11引入的一个通用函数包装器，可以用于存储、复制和调用任何可调用对象（函数、函数指针、成员函数指针、lambda表达式等）。通过使用std::function，我们可以在运行时动态地传递不同的函数给定参数。
lambda表达式是C++11引入的一种匿名函数形式，可以在需要函数对象的地方使用。它可以捕获外部变量，并且可以根据需要定义参数列表和返回类型。通过使用lambda表达式，我们可以方便地定义并传递不同的函数给定参数。
下面是一个示例代码，展示了如何使用std::function和lambda表达式来实现给定参数传递不同的函数：
#include <iostream>
#include <functional>
void foo(int x) {
std::cout << "foo: " << x << std::endl;
}
void bar(int x) {
std::cout << "bar: " << x << std::endl;
}
int main() {
std::function<void(int)> func;
// 使用lambda表达式传递函数foo给定参数
func = [](int x) { foo(x); };
func(10);
// 使用lambda表达式传递函数bar给定参数
func = [](int x) { bar(x); };
func(20);
return 0;
}在上面的示例中，我们首先定义了一个std::function对象func，它接受一个int类型的参数并返回void。然后，我们使用lambda表达式分别将函数foo和函数bar传递给func，并调用func来执行相应的函数。
这种方式可以灵活地根据需要传递不同的函数给定参数，适用于各种场景，例如事件处理、回调函数等。
腾讯云相关产品和产品介绍链接地址：
- 腾讯云函数（云函数计算）：https://cloud.tencent.com/product/scf
- 腾讯云API网关：https://cloud.tencent.com/product/apigateway
- 腾讯云容器服务：https://cloud.tencent.com/product/ccs
- 腾讯云弹性容器实例：https://cloud.tencent.com/product/eci
- 腾讯云无服务器应用引擎：https://cloud.tencent.com/product/tccli
- 腾讯云云原生应用引擎：https://cloud.tencent.com/product/tekton
- 腾讯云云原生应用管理平台：https://cloud.tencent.com/product/cap
- 腾讯云云原生应用架构：https://cloud.tencent.com/product/cna
- 腾讯云云原生应用开发框架：https://cloud.tencent.com/product/tke
- 腾讯云云原生应用部署工具：https://cloud.tencent.com/product/ck8s
相关·内容
我在map中有一个对象指针集合，在几个地方我需要迭代这个集合并调用每个对象的成员函数。
目前，对于我需要在集合中的每个元素上调用的每个成员函数，我添加了一个代理函数，该函数迭代集合，调用关联的成员。
我想知道是否可以使用boost在集合类中创建一个模板函数，它将在一般情况下为我处理这个问题？
答:事实证明，这非常简单，修改了我的原始示例，使其按预期工作：
class Object
{
public:
void func1();
void func2(int a);
};
class ObjectCollection : public std::map<std::stri
浏览 4提问于2012-11-29得票数 0
回答已采纳
考虑下面的代码：
void makeNew(std::function<void()>&& func)
{
std::function<void()> p = func;
}
void test(){}
用法：
makeNew(std::bind(test));
预期结果：
从std::bind(test)的结果类型创建临时函数对象，然后将这个临时std：：std::function<void()>对象作为右值引用传递给makeNew，然后在std::function p= func；被调用时调用移动构造函数。
实际发生的情况(使用
浏览 2提问于2014-01-23得票数 0
2回答
绑定到成员变量
、、
当我们绑定到成员变量时，我搞不懂boost::bind做了什么。通过绑定到成员函数，我们实质上创建了一个函数对象，然后调用它，将通过占位符提供或延迟并替换的参数传递给它。
但是这个表达式在幕后做了什么：
boost::bind(&std::pair::second, _1);
替换占位符_1的是什么？
我是在阅读boost::bind:上的一篇文章中的示例时发现的：
void print_string(const std::string& s) {
std::cout << s << '\n';
}
std::map<int
浏览 6提问于2009-07-21得票数 7
回答已采纳
这段代码取自
using var_t = std::variant<int, long, double, std::string>;
template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
std::vector<var_t> vec = {10, 15l, 1.5, "hello"};
for (auto& v: vec) {
// 4. another type-matching visitor: a class with 3 o
浏览 2提问于2021-11-10得票数 2
如果有创建线程函数 int thread_create( void*(*create_cb)(void*), void* arg); 有一个具有成员函数的类示例： void* example::startupTask(void *args); 如何将一个类的std::bind成员函数作为线程门户函数转换为"C“格式？ std::function<void* (void*)> func = std::bind(&example::startupTask, this, std::placeholders::_1);
auto rtn = thread_create((
浏览 20提问于2020-03-30得票数 0
回答已采纳
2回答
C++自动解析器调用
、、、
假设我们有一个原始的C样式字符串"test"。我们可以这样声明一个函数：
void printText(std::string textToPrint){
std::cout << textToPrint << "\n";
}
我们可以这样称呼它：
printText("test");
这应该很好，因为参数是一个对象，而不是引用，所以应该在调用函数‘`printText()’时创建像std::string("test")这样的临时对象。
现在，我有了以下模板：
template <typenam
浏览 0提问于2015-11-16得票数 0
回答已采纳
2回答
#include <functional>
struct A
{
int func(int x, int y)
{
return x+y;
}
};
int main()
{
typedef std::function<int(int, int) > Funcp;
A a;
//Funcp func = std:::bind(&A::func, &a);
Funcp func = std::bind(&A::func, a, std::placeholders::_1)
浏览 0提问于2011-03-01得票数 32
回答已采纳
1回答
我正在编写一段代码，它将执行以下操作:让我们假设我们有一个自定义绑定函数的调用
auto bind_obj = bind(some_func, _1, "test")
在我们有了
auto res = bind_obj(42)
其中函数some_func：
int some_func(int val, string test)
如何能够将占位符与实际函数调用(即bind_obj(.)中提供的参数相匹配？
换句话说，是否可以迭代std::tuple (此处的参数和占位符)和变量包(函数参数)以：
推导了函数some_func的返回类型；
做正确的std::tuple
浏览 2提问于2015-05-31得票数 0
回答已采纳
我想我在集合术语上遗漏了什么。
下面的代码可以很好地对向量进行排序：
using boost::bind;
std::vector<SegPoly> result;
//...
std::sort(result.begin(),result.end(),bind(std::less<double>(),bind(&SegPoly::getLength,_1), bind(&SegPoly::getLength,_2)));
但是我不能对std::set使用这样的排序标准
using boost::bind;
std::set<SegPoly&
浏览 0提问于2012-03-21得票数 1
回答已采纳
2回答
下面是一个代码：
#include <functional>
using namespace std::tr1;
typedef void(*fp)(void);
void foo(void)
{
}
void f(fp)
{
}
int main()
{
function<void(void)> fun = foo;
f(fun); // error
f(foo); // ok
}
最初，我需要从非静态类方法创建一个函数指针，因为我需要在函数调用之间保存数据。我尝试过std::tr1::bind和boost::bind，但它们返回的是函数对象，
浏览 6提问于2012-05-12得票数 11
回答已采纳
1回答
为什么只有当第二个参数大于3时，它才能起作用？如果我对copy_if也这么做，它就能工作了！任务:检查函子std :：bind的作用。尝试使用它来形成标准函子std :：greater (模块)的条件。
#include <set>
#include <algorithm>
#include <iostream>
#include <vector>
#include <list>
#include <map>
#include <iterator>
#include <string>
#includ
浏览 2提问于2017-02-16得票数 1
回答已采纳
// By const l-value reference
auto func2 = std::bind([](const std::unique_ptr< std::vector<int> >& pw) // fine
{
std::cout << "size of vector2: " << pw->size() << std::endl;
}, std::make_unique<std::vector<int>>(22, 1));
//By non-const l-
浏览 5提问于2017-03-02得票数 4
我正在使用c++11特性，并刚刚实验了以下代码：
void dump(ostream &os, const MyType &mt)
{
}
void f(const vector<MyType> &mts, ostream &os)
{
for_each(mts.begin(), mts.end(), bind(dump, ref(os), ref(_1));
}
此代码在clang处编译错误：
/usr/bin/../lib/gcc/x86_64-linux-gnu/4.8/../../../../include/c++/4.8/bits
浏览 3提问于2014-05-26得票数 4
回答已采纳
给定两个explicit构造函数重载(基于不同的std::function<...>类型)，std::bind的返回值可以选择或(从而使调用变得模糊)
call of overloaded ‘Bar(std::_Bind_helper<false, void (Foo::*)(int),
Foo*, int>::type)’ is ambiguous
如果我注释掉了，那么代码就编译了！
我想让构造函数explicit要么选择正确的重载，要么阻止两者被选中？
当然，显式在绑定点创建std::function的工作原理是：
Bar b(std::funct
浏览 2提问于2013-09-22得票数 1
回答已采纳
1回答
Unix套接字文件名错误
、、、、
这是我第一次用Unix套接字编程，所以请原谅这些愚蠢的错误。我编写了以下函数来创建unix套接字。
int create_server_unix_socket(const string& socket_path) {
// STEP 1 : socket()
int unix_socket = socket(AF_UNIX, SOCK_STREAM, 0);
if (unix_socket == -1) {
throw std::runtime_error {"Error occured in socket() call : "
浏览 2提问于2016-05-03得票数 1
回答已采纳
在本例中，我应该根据给定的大小对字符串向量进行排序，以免其长度大于或等于给定大小的元素先排序后再排序。
以下是我所做的：
bool is_shorter(std::string const& str, std::string::size_type sz){
return !(str.size() < sz);
}
int main(){
std::vector<string> vstr{"vector", "In", "this", "example", "am", &
浏览 2提问于2021-10-08得票数 0
回答已采纳
我注意到，boost::bind与std::bind不同，当重载函数中的一个函数没有任何参数时，它可以处理这些函数。我说的对吗？这有记录下来吗？
#include <boost/bind.hpp>
#include <functional>
#include <iostream>
void foo()
{
std::cout << "::foo() \n";
}
void foo(int)
{
std::cout << "::foo(int) \n";
}
int main()
浏览 2提问于2013-10-07得票数 2
我想要一个std::function<void(char**)>类型的变量。以下是一个失败的简单例子。
我想要理解的是：
当我调用jj_2a(5, 6)时，编译器没有抱怨的自动操作是什么？该函数的所有参数都有限制。
但是如果我不使用auto，我就会得到我期望的行为(用参数编译错误)。所以很明显，function<void(void)>根本不是汽车公司的决定。
如果我绑定第一个参数而不是第二个参数(jj_3)，那么用两个参数进行调用是有效的(但根据我的心智模型，删除了错误的参数)，而用一个参数调用(我认为应该有效)不能编译。
使用std::function
浏览 1提问于2016-08-11得票数 5
回答已采纳
3回答
我一直试图了解std::bind是如何工作的。所以用不同的例子。下面是示例程序，它的输出我无法理解。
版本1
class NAME
{
public:
void f()
{
std::cout<<"f"<<std::endl;
}
NAME()
{
std::cout<<"default constructor"<<std::endl;
}
NAME(const NAME&)
{
std::c
浏览 7提问于2021-08-24得票数 4
回答已采纳
3回答
我有下面的代码，有几件事最让我困扰：
At原始构造函数在什么时间点调用happen?Under什么情况下，复制构造函数得到called?
#include <iostream>
#include <functional>
class Samp {
char str[10] = "Default";
public:
Samp(char s[]) { strcpy(str, s); printf("Constructor\n"); }
Samp(const Samp& s) { printf("Cop
浏览 2提问于2020-06-14得票数 3
回答已采纳
我得到的代码如下所示，它构建：
#include <functional>
typedef std::function<void(int)> ReadCallback;
void falseRead() {}
int main()
{
ReadCallback callback = std::bind(falseRead);
}
ReadCallback的签名是void(int)，而falseRead的签名是void()。作业怎么会发生？
如果我使用callback对象来调用函数，我应该使用哪个语句，callback()还是callback(0)
浏览 2提问于2016-08-25得票数 1
回答已采纳
2回答
std：：绑定绑定函数
、、、
我很难发现这到底是为什么不能编译。我有一些lambda函数，它根据一些参数返回一个std::function。
我已经将我的问题缩小到这个片段(它没有使用lambdas，但完美地重现了我的错误)：
#include <functional>
#include <iostream>
struct foo {
template<class T>
void bar(T data) {
std::cout << data << "\n";
}
};
void some_fun(co
浏览 0提问于2012-05-28得票数 21
回答已采纳
我只是尝试为给定的std::packaged_task创建一个std::bind。
#include <functional>
#include <future>
class A
{
public:
template<class T>
void execute(T func)
{
std::packaged_task<T> task(func);
}
};
int main()
{
auto func = std::bind([](int x) { return x*x; }, 5);
A name;
浏览 2提问于2015-10-14得票数 2
回答已采纳
我给出了一个简单的代码片段：
#include <functional>
#include <iostream>
using namespace std;
void module2(int x, int y)
{
cout << "\n " << __PRETTY_FUNCTION__ << ":\t x = " << x << "\t y = " << y;
}
void module3(int x, int y, int z)
浏览 1提问于2019-07-05得票数 0
下面的片段有什么问题？
#include <tr1/functional>
#include <functional>
#include <iostream>
using namespace std::tr1::placeholders;
struct abc
{
typedef void result_type;
void hello(int)
{ std::cout << __PRETTY_FUNCTION__ << std::endl; }
void hello(int) const
浏览 5提问于2008-11-21得票数 5
回答已采纳
2回答
template<typename T>
class BlockingQueue
{
std::queue<T> container_;
template< typename U >
void push(U&& value)
{
static_assert(std::is_same<T, typename std::remove_reference<U>::type>::value,"Can't call p
浏览 3提问于2013-11-01得票数 6
回答已采纳
2回答
我有这样的代码：
#include <iostream>
#include <functional>
struct Foo
{
int get(int n) { return 5+n; }
};
int main()
{
Foo foo;
auto L = std::bind(&Foo::get, &foo, 3);
std::cout << L() << std::endl;
return 0;
}
看起来是这样的：
auto L = std
浏览 0提问于2013-04-15得票数 14
回答已采纳
1回答
下面我有一个简单的C++程序，它注册一些回调/侦听器，它们只是std::function的，然后它删除回调。
代码：
#include <iostream>
#include <functional>
#include <vector>
#include <memory>
class SomeClass {
public:
typedef std::function<void(int)> ListenerType;
std::vector<ListenerType> m_listeners;
v
浏览 0提问于2020-09-08得票数 4
回答已采纳
我有一个Register函数，它以一个std::function<void(const uint8_t* data, size_t len)>作为参数。我想使用对象的成员函数作为目标。
我找到了，根据它，答案是使用std::bind将第一个参数(隐式this指针)绑定到实际的对象指针，然后使用它作为std::function参数。
然而，这在C++11、C++14和C++17中都不再起作用了？
考虑下面的测试程序。
#include <iostream>
#include <cstdint>
#include <functional>
void
浏览 0提问于2018-05-18得票数 3
回答已采纳
我使用的是一个库，它需要回调函数的函数指针，但我想将一个成员函数传递给它。
这样做的方法似乎是使用std::bind并将target()作为参数传递给函数指针，但我肯定做错了什么。
#include <iostream>
#include <functional>
using namespace std;
typedef void(__stdcall* ClassicFuncPtr)(int a, double b);
void CallMyFunc(ClassicFuncPtr f) {
f(1, 2.0);
}
class MyClass {
pub
浏览 2提问于2021-06-29得票数 2
回答已采纳
1回答
boost：：函数与函数指针
、、、、
我正在实现一个通用设置读取器。我的想法是，我有一个应用程序，它的设置可以是布尔、整数和字符串。然后，我有一个Config类，其中实现了此类设置的getter，config类在构造函数中接受一个customer，这样它就知道它将读取该客户的设置。
我在工作上遇到了麻烦，我想我误用了boost::function，把它和普通的函数指针混淆了。
在映射中，我希望有引用，而boost::function只能在配置读取时绑定，因为我已经为给定的客户分配了一个Config实例。
问题是，如果没有类型防御，我就不能使用函数指针，这会使模板工作变得复杂，还有更明智的解决方案吗？
#include "C
浏览 2提问于2013-11-07得票数 4
回答已采纳
我编写了一些代码，它使用函子以及来自ref或std:: (用于C++11)命名空间的boost::和bind模板来计算向量的元素数。我使用#define在boost::和std::命名空间之间切换。我使用的是boost版本1.53，我的编译命令是g++ test.cpp -std=c++11。我试过gcc版本4.7.2和4.6.3，这两个版本都有相同的错误。
我有三个问题：
我不理解生成的错误，例如2。
仅仅通过交换名称空间就可以使这样的代码可移植吗？
是否有很好的参考资料详细描述了std和boost版本的bind、ref和function之间的差异？(我看到了的问题，但答案没有提
浏览 4提问于2013-02-25得票数 6
回答已采纳
例如，这是我的成员函数(do_it)：
class oops
{
public:
void do_it(GtkWidget *widget, GdkEvent *event, gpointer data)
{
g_print ("Hi there :)\n");
}
};
..。我使用std::bind让它看起来像一个非成员函数：
oops o;
std::function<void(GtkWidget*, GdkEvent*, gpointer)> f = std::bind(&oops::do_it, o);
但是
浏览 0提问于2014-03-15得票数 20
回答已采纳
2回答
std::bind的功能组合
、、、、
我正在读第二版的美丽的书尼古拉乔苏蒂斯在C++11 STL。
我找到了以下代码：
#include <functional>
#include <iostream>
int main()
{
auto plus10 = std::bind(std::plus<int>(),
std::placeholders::_1,
10);
std::cout << "+10: " << plus10(7) << std::endl;
auto plus10times
浏览 7提问于2020-08-28得票数 4
回答已采纳
我想编写一个日志函数或宏，它可以接受其他回调函数作为参数，并在内部运行回调函数、日志运行时和名称。但是回调函数可能有不同的参数类型和数目，我不想显式地将回调函数的名称作为参数传递。
我尝试使用std::bind和std::function
空日志(std：：function<void()> callbackFunc){ //假设所有callbackFunc返回类型都是void，tmEnd；gettimeofday(& tmBegin )；callbackFunc()；gettimeofday(& tmEnd )；//然后将tmEnd- tmBegin写到文件/，但
浏览 3提问于2015-07-10得票数 1
回答已采纳
int func(int x){return x;}
...
std::function<int(int)> x = std::bind(func, std::placeholders::_1);
x(123);
，，x(123)实际上调用了std::function生成的函子的operator()，进而调用了std::bind生成的函子的operator()，最终调用了func？这会被优化为像调用func(123)Where那样的优化吗?函子是否存在于std::bind生成的函数中？在什么范围内？std::bind是如何命名它的？(命名为collisions)Can lambda
浏览 2提问于2011-11-10得票数 11
回答已采纳
1回答
将类方法绑定到线程
、、、
请看下面的片段：
struct Event
{
void event1( time_t t );
void event2( int, int );
}
Event* f = ...;
time_t t; int i1, int i2;
// 1st
std::thread t{ std::bind( &Event::event1, f, std::placeholders::_1 ), t };
std::thread t{ std::bind( &Event::event2, f, std::placeholders::_1, std::placehol
浏览 1提问于2013-11-05得票数 0
回答已采纳
我正在处理回调函数，并希望通过std::bind注册多个签名不同的函数(尽管它们都返回void)。将std::bind的结果赋值给std::variant会产生“转换为非标量类型”的错误。这是歧义错误吗？我能向编译器提供更多的信息吗？
删除std::bind (允许分配)不是一个选项，因为我希望使用
template <typename Function, typename... Args>
void register(Function &&f, Args &&... args)
{
variant_of_multiple_func_type
浏览 0提问于2019-08-29得票数 10
回答已采纳
下面的代码用于计算满足以下条件的元素数：
(i > 5) && (i <=10)
std::vector<int> ints;
..
int count=std::count_if(
ints.begin(),
ints.end(),
boost::bind( // # bind 1
std::logical_and<bool>(),
boost::bind(std::greater<int>(),_1,5), // # bind 2
boost::bind(std::less_equal&l
浏览 0提问于2012-01-03得票数 2
回答已采纳
当存储在容器中时，std::function构造函数到底是做什么的？
在本测试代码中：
struct A {
int sn;
A() = delete;
A(int v) : sn(v) { cout << "A::init(" << sn << ')' << endl; }
A(const A& a) : sn(a.sn+1) { cout << "A::copy(" << sn << ')' <&l
浏览 5提问于2020-10-27得票数 3
回答已采纳
我试图从std：：线程获得一个std：：未来，而且似乎是唯一的方法(?)要做到这一点，就要使用std::packaged_task。另外，我想在std：：线程中调用的函数是一个类成员函数。我可以找到这个线程，但是他们使用std：：异步而不是std：：。我试图获得一些基于该帖子的编译内容，但是当我试图在这里编译这段代码时：
#include <iostream>
#include <future>
#include <thread>
class test
{
int fthread(int b)
{
return a + b;
浏览 2提问于2014-10-24得票数 0
回答已采纳
在试图理解std::bind分配内存的环境时，我看了看，它给了我一些直觉，但我想要更详细的理解，所以我去看了gcc的源代码。
我正在研究std::bind的，它来自于C++标准库的gcc实现。
/**
* @brief Function template for std::bind.
* @ingroup binders
*/
template<typename _Func, typename... _BoundArgs>
inline typename
_Bind_helper<__is_socketlike<_Func&
浏览 4提问于2016-04-14得票数 6
我找不到正确的语法来绑定成员函数。如果我有一个带有单个参数的函数，如何将一个对象传递给它？
在下面的示例中，传递函数的正确语法是什么？
#include <iostream>
#include <functional>
void caller(std::function<void(int)> f)
{
f(42);
}
class foo
{
public:
void f(int x)
{
std::cout<<x<<std::endl;
}
};
int main()
{
fo
浏览 3提问于2014-08-18得票数 1
回答已采纳
我正在尝试为一个函数设置一个委托，并让以下两个类来实现这一点。
最下面是我所犯的错误。我该怎么处理？
A类
typedef void (*SocketEventString) (String);
class SocketIO
{
public:
SocketIO();
void onMessage(SocketEventString _cb);
private:
SocketEventString _onMessage;
};
B类
class BoardManager
{
public:
浏览 0提问于2019-01-21得票数 2
回答已采纳
2回答
下面我举一个例子。该程序编译和运行良好，但我想知道它在理论上是否是根据C++11标准定义的行为；我能返回绑定(临时)本地函数对象的结果吗？
示例代码(简称编辑)：
#include <iostream>
#include <functional>
struct MyFunctionObject
{
inline void operator() ( const std::string& name )
{ std::cout<< "Hello " << name << "!"
浏览 3提问于2015-01-15得票数 3
回答已采纳
我有如下代码：
#include <functional>
#include <iostream>
using namespace std;
void F(int x) {
cout << x << endl;
}
int main() {
std::function<void(int)> f1 = std::bind(F, std::placeholders::_1);
f1(100); // This works, will print 100.
int x = 0;
std::function<vo
浏览 5提问于2015-03-20得票数 14
回答已采纳
我有以下代码：
void MyClass::create_msg(MyTime timestamp) {
// do things here ...
}
我尝试为上面的函数创建一个std::bind：
MyMsg MyClass::getResult(MyTime timestamp) {
// do things here ...
std::bind(create_msg(), timestamp);
// do things ...
}
但是得到了以下错误：
error: too few arguments to function call, single argu
浏览 0提问于2018-12-20得票数 1
回答已采纳
1回答
根据标准，函数参数求值的顺序和lambda捕获初始化器的顺序似乎都是未指定的。
(请参见和)
这引起了我的一些关注，因为它可能与移动语义交互。
假设我有一个类型为T的对象，该对象可能具有一个复制或移动构造函数，该构造函数将抛出。然后假设我有一个只能移动的对象，比如一个std::promise。考虑以下情况：
T value; // some type that potentially throws when moved or copied
promise<U> pr; // a promise whose result is some type U
future<U>
浏览 1提问于2018-05-25得票数 6
回答已采纳
Class A {
public:
A();
void onTouch();
}
A::A() {
touchAttachInterrupt(1, std::bind(&A::onTouch, this), 40)
}
对于ESP32来说，这不适用于我。touchAttachInterrupt的定义是：
void touchAttachInterrupt(uint8_t pin, void (*userFunc)(void), uint16_t threshold);
我的代码会导致编译错误，
error: cannot convert 'std::_Bind_h
浏览 10提问于2022-10-24得票数 0
1回答
我使用以下代码将成员函数绑定到类的实例：
class Foo {
public:
int i;
void test() {
std::cout << i << std::endl;
}
};
int main() {
Foo f;
f.i = 100;
auto func = std::bind(&Foo::test, std::forward<Foo>(f));
f.i = 1000;
func();
}
但是std::bind语句并不通过引用绑定到f。调用func会
浏览 0提问于2014-10-04得票数 18
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
