使用BOOST BIND库提高C++程序性能
By Bj&rn Karlsson
Aug 26, 2005
翻译：Boost.Bind的用法
Boost.Bind为函数和函数对象，值语义和指针提供语义了一致的语法。我们首先通过一些简单的例子来看看它的基本用法，之后我们会延伸到嵌套绑定以实现功能组合。理解bind用法的一个关键是理解占位符（placeholder）的概念。占位符表示该参数将在函数对象里面提供。Boost.Bind提供多达9个这样的参数&&_1, _2, _3, _4, _5,_6,_7,_8, _9。你可以在想要加入参数的地方使用它们。在第一个示例程序中，我们定义一个函数&nine_arguments&，之后用bind表达式调用它。
#include boost/bind.hpp
void nine_arguments(
int i1,int i2,int i3,int i4,
int i5,int i6,int i7,int i8, int i9) {
std::cout && i1 && i2 && i3 && i4 && i5
&& i6 && i7 && i8 && i9 && '
int main() {
int i1=1,i2=2,i3=3,i4=4,i5=5,i6=6,i7=7,i8=8,i9=9;
(boost::bind(&nine_arguments,_9,_2,_1,_6,_3,_8,_4,_5,_7))
(i1,i2,i3,i4,i5,i6,i7,i8,i9);
在这个程序中，你可以创建临时的匿名绑定器并且立即传参调用。如你所见，占位符的顺序是在本例中是混乱的，这使得参数的顺序也被打乱。另外，占位符可以在表达式中重复使用。示例程序1的输出是：
占位符的序数与参数的位置是对应的，也就是说，_1被换为第一个参数，_2被换为第二个参数，以此类推。
原创：实验
void PlaceholderTest(int a, int b, int c)
std::cout && a && b && c && std::
int main()
int a = 1, b = 2, c = 3;
//(boost::bind(&PlaceholderTest, _1, _2))(a, b); //error
//(boost::bind(&PlaceholderTest, _1, _2, _1, _3))(a, b, c); //error
//(boost::bind(&PlaceholderTest, _1, _2, _3))(a, b); //error
(boost::bind(&PlaceholderTest, _1, _2, _1))(a, b); //OK,output:121
(boost::bind(&PlaceholderTest, 99, _2, _1))(a, b) //OK,output:9921
1、参数占位符数量与函数形参数量必须一致
2、占位符的替代值可以少于占位符数量
3、占位符和实参可以混合使用
翻译：调用成员函数（1）
我们看看如何使用bind调用类的成员函数。首先我们也从一个可以由标准库完成的操作开始，这样方便我们对比标准库调用和Boost.Bind调用。当我们在标准库容器类类型中存储元素时，通常需要对部分或所有元素调用成员函数。通常的实现方法是，将这些操作可以放在一个循环中。但是现在有更好的解决办法。观察如下的简单类&&status。我们之后将用它来展示Boost.Bind的简单易用和强大之处。
class status {
std::string name_;
status(const std::string& name):name_(name),ok_(true) {}
void break_it() {
bool is_broken() const {
return ok_;
void report() const {
std::cout && name_ &&
(ok_ ? working nominally:terribly broken) && '
如果我们将这个类的实例储存在vector中，当我们需要调用成员函数report时，大概要遵循以下步骤
std::vector
statuses.push_back(status(status 1));
statuses.push_back(status(status 2));
statuses.push_back(status(status 3));
statuses.push_back(status(status 4));
statuses[1].break_it();
statuses[2].break_it();
for (std::vector::iterator it=statuses.begin();
it!=statuses.end();++it) {
it-&report();
for循环能够正确完成操作，但是它冗长、低效（每次都要检查statuses.end()），还不如使用标准库中专为这种操作设计的for_each算法来的清楚。为了使用for_each替代for循环，我们需要为vector元素调用成员函数report配置一个适配器。在这个实例中，由于元素是值存储的，我们需要的是mem_fun_ref适配器：
std::for_each(
statuses.begin(),
statuses.end(),
std::mem_fun_ref(&status::report));
这是一种更好的办法&&它是如此简洁，不会对代码的作用产生任何迷惑和误解。Boost.Bind中的等效代码如下：
std::for_each(
statuses.begin(),
statuses.end(),
boost::bind(&status::report,_1));
bind版本仍然清晰明了。这是我们第一次真正使用上面提及的Bind库占位符，它向编译器和代码者传递了这样一个信息，_1将在调用绑定器的函数中被实参替换。尽管这段代码长度减少了，但在本例中，它与使用标准库mem_fun_ref几乎没有差别。
原创：编程实验
class Status
Status(const std::string &name) : name_(name), ok_(true){}
void BreakIt()
bool IsBroken() const
return ok_;
void Report() const
std::cout && name_ &&
&& (ok_ ? ok : broken) && std::
std::string name_;
int main()
std::vector v_
v_status.push_back(Status(status 1));
v_status.push_back(Status(status 2));
v_status.push_back(Status(status 3));
v_status.push_back(Status(status 4));
v_status[1].BreakIt();
v_status[2].BreakIt();
std::cout && use
or: && std::
for (std::vector::iterator it = v_status.begin(); it & v_status.end(); it++)
it-&Report();
std::cout &&
or_each, mem_fun_ref: && std::
std::for_each(v_status.begin(), v_status.end(), std::mem_fun_ref(&Status::Report));
std::cout &&
or_each, bind: && std::
//std::for_each(v_status.begin(), v_status.end(), boost::bind(&Status::Report)); //error
std::for_each(v_status.begin(), v_status.end(), boost::bind(&Status::Report, _1));
bind成员函数最大的不同是，必须指明调用该函数的实例对象，代码中用&_1&表示。
翻译：调用成员函数（2）
下面，我们稍微改造一下vector容器，让它装入指针而不是值：
std::vector p_
p_statuses.push_back(new status(status 1));
p_statuses.push_back(new status(status 2));
p_statuses.push_back(new status(status 3));
p_statuses.push_back(new status(status 4));
p_statuses[1]-&break_it();
p_statuses[2]-&break_it();
我们仍然可以用两种标准库，但是我们不能用mem_fun_ref，而是用mem_fun适配器，虽然它的名字听起来有点儿混淆，完成操作还是没问题的。
std::for_each(
p_statuses.begin(),
p_statuses.end(),
std::mem_fun(&status::report));
注意到，这段代码的语法已经有所改变，尽管我们要做的工作几乎相同。当然，如果代码的语法和上面的例子一样就最好了，这样我们就可以更多地关注代码到底做了些什么而不是它怎么做的。使用Bind，我们不需要显式指明要处理的元素是指针（这在容器类型中已经说明了，重复的信息在现代的库里面显然是不必要的）
std::for_each(
p_statuses.begin(),
p_statuses.end(),
boost::bind(&status::report,_1));
如你所见，这与之前非指针元素的代码没有任何区别。也就是说如果你理解了刚才的bind，那么这个也能理解。
原创：编程实验
class Status
Status(const std::string &name) : name_(name), ok_(true){}
void BreakIt()
bool IsBroken() const
return ok_;
void Report() const
std::cout && name_ &&
&& (ok_ ? ok : broken) && std::
std::string name_;
int main()
std::vector v_
v_pstatus.push_back(new Status(status 1));
v_pstatus.push_back(new Status(status 2));
v_pstatus.push_back(new Status(status 3));
v_pstatus.push_back(new Status(status 4));
v_pstatus[1]-&BreakIt();
v_pstatus[2]-&BreakIt();
std::cout && use
or: && std::
for (std::vector::iterator it = v_pstatus.begin(); it & v_pstatus.end(); it++)
(*it)-&Report();
std::cout &&
or_each, mem_fun_ref: && std::
std::for_each(v_pstatus.begin(), v_pstatus.end(), std::mem_fun(&Status::Report));
std::cout &&
or_each, bind: && std::
std::for_each(v_pstatus.begin(), v_pstatus.end(), boost::bind(&Status::Report, _1));
只有bind保持了形式不变
翻译：调用成员函数（3）
我们决定使用指针后，有另外一个问题，即指针的生命周期控制。我们必须手动释放p_statuses中的元素，这很容易出错而且没有必要。因此，我们可能选择使用智能指针（smart pointers），代码变化如下：
std::vector<boost::shared_ptr & s_
s_statuses.push_back(
boost::shared_ptr(new status(status 1)));
s_statuses.push_back(
boost::shared_ptr(new status(status 2)));
s_statuses.push_back(
boost::shared_ptr(new status(status 3)));
s_statuses.push_back(
boost::shared_ptr(new status(status 4)));
s_statuses[1]-&break_it();
s_statuses[2]-&break_it();</boost::shared_ptr
现在，我们该使用标准库中的哪个适配器了？由于智能指针并没有report成员函数，mem_fun和mem_fun_ref都不能用了。如下代码会编译失败。
std::for_each(
s_statuses.begin(),
s_statuses.end(),
std::mem_fun(&status::report));
我们的好运用完了，标准库并不能帮我们完成这个任务。因此，我们只能借助于之前想避开的for形式或者&&Boost.Bind，它可以完全正确地完成任务。
std::for_each(
s_statuses.begin(),
s_statuses.end(),
boost::bind(&status::report,_1));
这与前面的代码是完全一样的（除了容器的名字）。同样的语法可以用于绑定值语义、指针语义或者只能指针。有时候，不同的语法可以帮助我们理解代码，但在我们讨论的情况中不是这样&&我们手中的任务是在容器的元素上调用成员函数，没有其他的需求。语法一致的价值是不容轻视的，它既帮助了写代码的人，也帮助了以后维护代码的人。（当然，实际上我们没有写需要维护的代码，但出于参数的考虑，让我们假装是这样做的吧^_^）。
原创：编程实验
class Status
Status(const std::string &name) : name_(name), ok_(true){}
void BreakIt()
bool IsBroken() const
return ok_;
void Report() const
std::cout && name_ &&
&& (ok_ ? ok : broken) && std::
std::string name_;
int main()
std::vector& boost::shared_ptr & v_
v_spstatus.push_back(boost::shared_ptr(new Status(status 1)));
v_spstatus.push_back(boost::shared_ptr(new Status(status 2)));
v_spstatus.push_back(boost::shared_ptr(new Status(status 3)));
v_spstatus.push_back(boost::shared_ptr(new Status(status 4)));
v_spstatus[1]-&BreakIt();
v_spstatus[2]-&BreakIt();
//std::cout && use
or: && std::
//for (std::vector::iterator it = v_spstatus.begin(); it & v_spstatus.end(); it++)
// (*it)-&Report();
//std::cout &&
or_each, mem_fun_ref: && std::
//std::for_each(v_spstatus.begin(), v_spstatus.end(), std::mem_fun(&Status::Report));
std::cout &&
or_each, bind: && std::
std::for_each(v_spstatus.begin(), v_spstatus.end(), boost::bind(&Status::Report, _1));
1、标准库中的方法不再能够使用
2、使用share_ptr必须引入头文件#include
这些例子展示了一些Boost.Bind最基本最常用的情况，也是它最擅长的方面。尽管标准库也提供了一些基本工具让我们完成同样的任务，但我们看到Bind提供了语法一致性和一些标准库目前没有的扩展功能。boost&bind（一）
Bind 表达式
1、两中形式：
bind(target_function, arguments_list);
bind(target_member_function, object_instance,
arguments_list);
一个bind表达式用于推迟调用一个函数。如果目标函数是一个n元的表达式，那么bind_arg_list就需要包含n个参数。对于普通函数，参数可以有9个，对于成员函数，参数可以有8个，因为成员函数需要把自己绑定的实体作为参数传入。基本上，bind_arg_list应该是一个可供函数使用的有效参数列表，而且到任何参数都可以被占位符替换。目标函数也可以是一个lambda表达式，绑定的表达式结果可以是无元，一元，二元，三元的函数对象，这取决于bind_arg_list中使用的占位符的个数。
lambda返回值得类型可以显示的指定：
bind(target-function,bind-arg-list);
2、函数指针、函数引用的用法：
特别注意，在C++中，重载函数不能直接使用bind，因为bind-arg-list的参数类型不能确定
foo(int i);
foo(float i);
bind(foo, _1)(arg); // &error
void(*fp1)(int) = &
bind(foo, _1)(arg); // It's ok
bind(static_cast(&foo, _1)(arg));
&// it's ok
实例也可以作为参数传递
bool A::foo(int);
list lot_a;
for_each(lot_a.begin(), lot_a.end(),
bind(&foo, _1, 3));&
3、成员函数作为绑定目标：
在使用引用和指针对成员函数进行绑定的时候，虽然接口使用的是一致的，但是实际的使用中有很大区别：
& & A( int x, int y): a(x),
& & void set_a( int a
& & void set_b( int a
bind(&A::set_a, &a, 1); //
对象的a被修改
bind(&A::set_a, a, 1); &//
&对象的拷贝中的a被修改，原值不修改
4、无元的lambda表达式与返回值：
由于C++模版的原因，编译器强制声明一个无元lambda表达式必须显示声明有一个返回值
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。下次自动登录
现在的位置:
& 综合 & 正文
boost::bind
当我们使用函数时习惯于C函数的格式,即如下形式resulttype funname( arglist );返回值类型 函数名( 参数列表 );在Boost.Function中，我们可以方便的定义定义函数对象。不过在定义用来表示类成员函数的函数对象时第一个参数是类指针。而且在调用时，要传入一个类实例的指针。这样用起来并不是很方便，因为调用者要知道类实例。这实际上没有实现解耦。而解耦是我们使用回调或委托设计的一个目标。为了解决这个问题，我们要使用Boost.Bind库Boost.Bind是一个函数对象工厂。他用来产生我们需要的函数对象。好了，有了它，你可以在你设计中大量使用Boost.Function。不用再去定义类成员函数形式的函数对象啦，只用定义普通函数对象。一个简单的例子class CExample{public:
bool printstr( const std::string &str )
std::cout && "CExample::printstr" && str && std::
}};//定义一个函数对象boost::function& bool ( const std::string& ) &//用Boost.Bind创建一个函数对象，赋给printstrCEprintstr = boost::bind( &CExample::printstr, &example, _1 );好了，我们创建了一个函数对象，而且调用时不再需要类实例拉。用Boost.Function和Boost.Bind大大的简化了Command模式的实现。在上面的例子中要个古怪的对象"_1"。这个叫做站位符，他代表这个位置有个参数，但现在还不知道参数是什么。_1代表参数列表中的第一个位置上的参数。Boost.Bind一共定义了9个站位符对象。如下_1,_2,_3,_4,_5,_6,_7,_8,_9。分别代表参数列表中位子。Boost.Bind产生的函数对象可以直接使用，利用上面的例子。bool b = boost::bind( &CExample::printstr, &example, _1 )( "Hello World" );
Boost::bind
一 Boost::bind
在STL中，我们经常需要使用bind1st，bind2st函数绑定器和fun_ptr,mem_fun等函数适配器，这些函数绑定器和函数适配器使用起来比较麻
烦，需要根据是全局函数还是类的成员函数，是一个参数还是多个参数等做出不同的选择，而且有些情况使用STL提供的不能满足要求，所以如
果可以我们最好使用boost提供的bind，它提供了统一的接口，提供了更多的支持，比如说它增加了shared_ptr，虚函数，类成员的绑定。
二 源码剖析
1） bind1st,bind2st函数绑定器，把二元函数对象变为一元函数对象。
2） mem_fun,把成员函数变为函数对象。
3） fun_ptr，把一般的全局函数变为函数对象。
4） boost::bind(),包含了以上所有的功能。
1）区别与mem_fun和fun_ptr
#include &functional&#include &iostream&#include &string&#include "boost/bind.hpp"class some_class{public:void print_string(const std::string& s)const{ std::cout && s && '\n'; }void print_classname(){ std::cout && "some_class" && std:: }};void print_string(const std::string s){
std::cout && s && '\n';}void print_functionname(){ std::cout && "Print_functionname" &&std::}int main(){ std::ptr_fun(&print_string)("hello1");//std::ptr_fun&void&(&print_functionname); some_class sc0; std::mem_fun_ref(&some_class::print_classname)(sc0); std::mem_fun_ref&void,some_class&(&some_class::print_classname)(sc0);//std::mem_fun1_ref&void,some_class,const std::stirng&(&some_class::print_string)(sc0,"hello2"); (boost::bind(&print_string,_1))("Hello func!"); boost::bind(&print_functionname); some_ (boost::bind(&some_class::print_classname,_1)(sc)); (boost::bind(&some_class::print_string,_1,_2))(sc,"Hello member!");}
2）区别与bind1st和bind2st
#include &functional&#include &iostream&#include &string&#include &vector&#include &algorithm&#include "boost/bind.hpp"void main(){ std::vector&int& ints.push_back(7); ints.push_back(4); ints.push_back(12); ints.push_back(10);int count=std::count_if(ints.begin(), ints.end(), boost::bind(std::logical_and&bool&(),boost::bind(std::greater&int&(),_1,5),boost::bind(std::less_equal&int&(),_1,10)) ); std::cout && count && '\n'; std::vector&int&::iterator int_it=std::find_if(ints.begin(), ints.end(), boost::bind(std::logical_and&bool&(),boost::bind(std::greater&int&(),_1,5),boost::bind(std::less_equal&int&(),_1,10)) );if (int_it!=ints.end()){
std::cout && *int_it && '\n';}}
3）区别传ref和传instance
// bind instance or reference#include &functional&#include &iostream&#include &string&#include &vector&#include &algorithm&#include "boost/bind.hpp"class tracer{public:
{ std::cout && "tracer::tracer()\n"; }
tracer(const tracer& other)
{ std::cout && "tracer::tracer(const tracer& other)\n"; } tracer&operator=(const tracer& other){
std::cout && "tracer& tracer::operator=(const tracer& other)\n";return *this; }
{ std::cout && "tracer::~tracer()\n"; }void print(const std::string& s)const{
std::cout && s && '\n'; }};void main(){ boost::bind(&tracer::print,t,_1)(std::string("I'm called on a copy of t\n")); tracer t1; boost::bind(&tracer::print,boost::ref(t1),_1)( std::string("I'm called directly on t\n"));}
4）绑定虚函数
//bind vitual class function#include &functional&#include &iostream&#include &string&#include &vector&#include &algorithm&#include "boost/bind.hpp"classbase{public:virtualvoid print()const{
std::cout && "I am base.\n"; }virtual
~base(){}};class derived :publicbase{public:void print()const{
std::cout && "I am derived.\n"; }};void main(){base boost::bind(&base::print,_1)(b); boost::bind(&base::print,_1)(d);}
5）绑定成员变量
// bind class's member#include &functional&#include &iostream&#include &string&#include &vector&#include &algorithm&#include "boost/bind.hpp"class personal_info{ std::string name_; std::string surname_; unsignedint age_;public:
personal_info(const std::string& n,const std::string& s,unsignedint age):name_(n),surname_(s),age_(age){}
std::string name()
{return name_;}
std::string surname()
{return surname_;}
unsigned int age()
{return age_;}};void main(){ std::vector&personal_info& vec.push_back(personal_info("Little","John",30)); vec.push_back(personal_info("Friar", "Tuck",50)); vec.push_back(personal_info("Robin", "Hood",40)); std::sort(vec.begin(), vec.end(), boost::bind(std::less&unsignedint&(),boost::bind(&personal_info::age,_1),boost::bind(&personal_info::age,_2)) ); std::sort(vec.begin(), vec.end(), boost::bind(std::less&std::string&(),boost::bind(&personal_info::surname,_1),boost::bind(&personal_info::surname,_2)) );}
1) 现在的类库最多可以支持9个参数。
2）在绑定一个成员函数时，bind 表达式的第一个参数必须是成员函数所在类的实例！理解这个规则的最容易的方法是，这个显式的参数将取
替隐式的 this ，被传递给所有的非静态成员函数。细心的读者将会留意到，实际上这意味着对于成员函数的绑定器来说，只能支持八个参数
，因为第一个要用于传递实际的对象。
3）当我们传递某种类型的实例给一个 bind 表达式时，它将被复制，除非我们显式地告诉 bind 不要复制它。要避免复制，我们必须告诉
bind 我们想传递引用而不是它所假定的传值。我们要用 boost::ref 和 boost::cref (分别用于引用和 const 引用)来做到这一点，它们也是
Boost.Bind 库的一部分。还有一种避免复制的方法；就是通过指针来传递参数而不是通过值来传递。
4） 通过 Boost.Bind, 你可以象使用非虚拟函数一样使用虚拟函数，即把它绑定到最先声明该成员函数为虚拟的基类的那个虚拟函数上。这
个绑定器就可以用于所有的派生类。如果你绑定到其它派生类，你就限制了可以使用这个绑定器的类。
5）bind还可以绑定成员变量。
bind并不是一个单独的类或函数，而是非常庞大的家族，依据绑定的参数个数和要绑定的调用对象类型，总共有十个不同的形式，但它们的名字都叫bind. bind接受的第一个参数必须是一个可调用对象f,包括函数，函数指针，函数对象和成员函数，之后bind接受最多9个参数，参数的数量必须与f的参数数量相等 _1,_2这些一直可以到9,是占位符，必须在绑定表达式中提供函数要求的所有参数，无论是真实参数还是占位符均可以。占位符不可以超过函数参数数量。 绑定普通函数:
#include&boost/bind.hpp&
#include&iostream&
void fun(int a,int b){
cout && a+b &&
int main()
bind(fun,1,2)();//fun(1,2)
bind(fun,_1,_2)(1,2);//fun(1,2)
bind(fun,_2,_1)(1,2);//fun(2,1)
bind(fun,_2,_2)(1,2);//fun(2,2)
bind(fun,_1,3)(1);//fun(1,3)
绑定成员函数
#include&boost/bind.hpp&
#include&iostream&
#include&vector&
#include&algorithm&
struct point
point(int a=0,int b=0):x(a),y(b){}
void print(){
cout && "(" && x && "," && y && ")\n";
void setX(int a){
cout && "setX:" && a &&
void setXY(int x,int y){
cout && "setX:" && x && ",setY:" && y &&
void setXYZ(int x,int y,int z){
cout && "setX:" && x && ",setY:" && y && "setZ:" && z &&
int main()
point p1,p2;
bind(&point::setX,p1,_1)(10);
bind(&point::setXY,p1,_1,_2)(10,20);
bind(&point::setXYZ,p2,_1,_2,_3)(10,20,30);
vector&point& v(10);
//for_each的时候只需要_1就可以了
for_each(v.begin(),v.end(),bind(&point::print,_1));
for_each(v.begin(),v.end(),bind(&point::setX,_1,10));
for_each(v.begin(),v.end(),bind(&point::setXY,_1,10,20));
for_each(v.begin(),v.end(),bind(&point::setXYZ,_1,10,20,30));
setX:10,setY:20
setX:10,setY:20setZ:30
setX:10,setY:20
setX:10,setY:20
setX:10,setY:20
setX:10,setY:20
setX:10,setY:20
setX:10,setY:20
setX:10,setY:20
setX:10,setY:20
setX:10,setY:20
setX:10,setY:20
setX:10,setY:20setZ:30
setX:10,setY:20setZ:30
setX:10,setY:20setZ:30
setX:10,setY:20setZ:30
setX:10,setY:20setZ:30
setX:10,setY:20setZ:30
setX:10,setY:20setZ:30
setX:10,setY:20setZ:30
setX:10,setY:20setZ:30
setX:10,setY:20setZ:30
&&&&推荐文章:
【上篇】【下篇】1359人阅读
编程基础（96）
我们先看看下面一段代码：直接使用数组，即StreamConfigTable数组作为bind函数参数，PersistentStreamSettingsToDevice函数的第一个参数为数组形式StreamSetting_t StreamConfigTable[]。大家知道，数组名作为函数参数时候，实际退化为一个指针。
ReturnStatus CServiceEngine::SaveStreamConfigurations(StreamSetting_t StreamConfigTable[], int resourceStreamId , int VideoSourceIndex, PelcoStreamSetting_type_e SettingType)
TRACE(&%s, %d, Start a thread to save stream configurations:%d&, __FUNCTION__, __LINE__,resourceStreamId);
boost::thread boost_thread(
boost::bind(&CServiceEngine::PersistentStreamSettingsToDevice, this, StreamConfigTable, resourceStreamId ,VideoSourceIndex ) );
boost_thread.detach();
return SYS_OK;
测试结果，当在PersistentStreamSettingsToDevice函数中直接以StreamConfigtable[i]，即数组下表引用时，编译可以通过，但运行时出现段错误。
于是猜测：boost::bind函数的参数对对象数组这种指针参数的支持不够好。
为了验证，将PersistentStreamSettingsToDevice函数的第一个参数又数组形式改为容器形式：vector&PelcoStreamSetting_t& StreamConfigTable。
同时上述代码调整为：
ReturnStatus CServiceEngine::SaveStreamConfigurations(StreamSetting_t StreamConfigTable[], int resourceStreamId , int VideoSourceIndex, PelcoStreamSetting_type_e SettingType)
vector&PelcoStreamSetting_t& ConfigT
for ( i= SETTING_ENCODING; i&SETTING_END; i&#43;&#43; )
ConfigTable.push_back(StreamConfigTable[i]);
TRACE(&%s, %d, Start a thread to save stream configurations:%d&, __FUNCTION__, __LINE__,resourceStreamId);
boost::thread boost_thread(
boost::bind(&CServiceEngine::PersistentStreamSettingsToDevice, this,ConfigTable, resourceStreamId ,VideoSourceIndex ) );
boost_thread.detach();
return SYS_OK;
测试结果：程序编译通过，运行也正常。
难道boost::bind函数对数组的支持真的不够好？
欢迎知情者指教！
&&相关文章推荐
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：845110次
积分：9310
积分：9310
排名：第1781名
原创：145篇
转载：172篇
评论：116条
(11)(1)(1)(1)(14)(1)(18)(15)(1)(6)(3)(1)(13)(13)(2)(1)(6)(1)(2)(4)(5)(2)(2)(28)(15)(7)(8)(12)(13)(2)(1)(18)(6)(8)(11)(11)(10)(5)(12)(9)(2)(3)(16)}