blocks|key|174844|text|试试这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|174845|boost::bind(&Foo::f1,+object,+_1,+_2);|code-block|syntax|javascript|174846|object是类Foo的一个实例。_1和_2是参数占位符。|offset|length|style|CODE|174847|entityMap^0|0|0|0|6|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Try this:

<pre><code>boost::bind(&amp;Foo::f1, object, _1, _2);
</code></pre>

<code>object</code> is an instance of class Foo.
_1 and _2 are the argument placeholders.

blocks|key|3499623|text|typedef+double+(Foo::*+MyFooFunc)(+int+);

MyFooFunc+func1+=+boost::bind(+&Foo::f1,+_1,+_2,+"some+string"+);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3499624|boost::bind的结果不是指向成员的指针，因此不能在第二行将func1初始化为成员。boost::bind的结果是一个未指定的类型(这取决于参数)。如果使用C%2B%2B0x，则对bind调用的结果命名的最简单方法是使用auto|unstyled|offset|length|style|CODE|3499625|auto+func1+=+boost::bind(+&Foo::f1,+_1,+_2,+"some+string"+);|3499626|另一种简单的方法(不限于C%2B%2B03)是简单地不命名结果，而是在现场使用它：|3499627|SomeOtherFunction(boost::bind(&Foo::f1,+_1,+_2,+"some+string"));|3499628|或者，您可以使用类型擦除将boost::bind的结果存储到您似乎很熟悉的boost::function中。boost::function<double(Foo&,+int)>是一种可能性，但不是唯一的选择。|3499629|3499630|现在我们需要为SomeOtherFunction找到合适的签名:同样，指向成员的指针不能从boost::bind调用的结果中初始化，因此void+SomeOtherFunction(MyFooFunc+func);将不起作用。您可以将该函数设置为模板：|3499631|template<typename+Func>
void+SomeOtherFunction(+Func+func+)
{
+++++Foo+foo;
+++++boost::function<+double+(int)+>+finalFunc+=
++++++++++boost::bind(+func,+foo,+_1+);
}|3499632|如果模板不是最好的，那么您必须使用某种类型擦除，例如boost::function。|3499633|void+SomeOtherFunction(boost::function<double(Foo&,+int)>+const&+func);|3499634|(同样，根据细节，其他boost::function类型也是可能的，例如传递引用到常量，而不是传递引用到非常量)|3499635|entityMap^0|0|0|B|X|5|19|B|2H|4|31|4|0|0|0|0|D|B|11|F|1I|Y|0|0|7|H|19|B|1W|13|0|0|Q|F|0|0|B|F|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|16|8|@$G|17|H|18|I|J]|$G|19|H|1A|I|J]|$G|1B|H|1C|I|J]|$G|1D|H|1E|I|J]|$G|1F|H|1G|I|J]]|9|@]|A|$]]|$1|K|3|L|5|6|7|1H|8|@]|9|@]|A|$B|C]]|$1|M|3|N|5|F|7|1I|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1J|8|@]|9|@]|A|$B|C]]|$1|Q|3|R|5|F|7|1K|8|@$G|1L|H|1M|I|J]|$G|1N|H|1O|I|J]|$G|1P|H|1Q|I|J]]|9|@]|A|$]]|$1|S|3|-4|5|F|7|1R|8|@]|9|@]|A|$]]|$1|T|3|U|5|F|7|1S|8|@$G|1T|H|1U|I|J]|$G|1V|H|1W|I|J]|$G|1X|H|1Y|I|J]]|9|@]|A|$]]|$1|V|3|W|5|6|7|1Z|8|@]|9|@]|A|$B|C]]|$1|X|3|Y|5|F|7|20|8|@$G|21|H|22|I|J]]|9|@]|A|$]]|$1|Z|3|10|5|6|7|23|8|@]|9|@]|A|$B|C]]|$1|11|3|12|5|F|7|24|8|@$G|25|H|26|I|J]]|9|@]|A|$]]|$1|13|3|-4|5|F|7|27|8|@]|9|@]|A|$]]]|14|$]]

<pre><code>typedef double (Foo::* MyFooFunc)( int );

MyFooFunc func1 = boost::bind( &amp;Foo::f1, _1, _2, "some string" );
</code></pre>

The result of <code>boost::bind</code> is not a pointer to member, so <code>func1</code> cannot be initialized as such on the second line. The result of <code>boost::bind</code> is an unspecified type (which will depend on the parameters). If you're using C++0x, the simplest way to name the result of a call to <code>bind</code> is to use <code>auto</code>:

<pre><code>auto func1 = boost::bind( &amp;Foo::f1, _1, _2, "some string" );
</code></pre>

Another simple way (not restricted to C++03) is simply to not name the result, but to use it on the spot:

<pre><code>SomeOtherFunction(boost::bind(&amp;Foo::f1, _1, _2, "some string"));
</code></pre>

Or, you can use type-erasure to store the result of <code>boost::bind</code> into a <code>boost::function</code>, which you seem to be familiar with. <code>boost::function&lt;double(Foo&amp;, int)&gt;</code> is a possibility but not the only choice.

<hr>

We now need to find the appropriate signature for <code>SomeOtherFunction</code>: again, a pointer to member can't be initialized from the result of a call to <code>boost::bind</code>, so <code>void SomeOtherFunction(MyFooFunc func);</code> won't work. You can make the function a template instead:

<pre><code>template&lt;typename Func&gt;
void SomeOtherFunction( Func func )
{
 Foo foo;
 boost::function&lt; double (int) &gt; finalFunc =
 boost::bind( func, foo, _1 );
}
</code></pre>

If a template is not preferrable, then you must use some kind of type-erasure such as, again, <code>boost::function</code>.

<pre><code>void SomeOtherFunction(boost::function&lt;double(Foo&amp;, int)&gt; const&amp; func);
</code></pre>

(once again other <code>boost::function</code> types are possible depending on details such as passing a ref-to-const as opposed to a ref-to-non-const)

<pre><code>class Foo 
{
 double f1( int x, std::string s1 );
 double f2( int x, SomeClass s2 );
}
</code></pre>

I want to be able to bind Foo.f1's s1 without an instance of foo to create in essense

<pre><code>typedef double (Foo::* MyFooFunc)( int ) 

MyFooFunc func1 = boost::bind( &amp;Foo::f1, _1, _2, "some string" );
MyFooFunc func2 = boost::bind( &amp;Foo::f2, _1, _2, SomeClass );
</code></pre>

Then I pass func1 and func2 as parameters to other functions, inside which Foo is finally bound:

<pre><code>void SomeOtherFunction( MyFooFunc func )
{
 Foo foo;
 boost::function&lt; double (int) &gt; finalFunc =
 boost::bind( func, foo, _1 );
}
</code></pre>

Questions:
Is this possible? If yes, 1) how to achieve it? 2) What's the declaration of MyFooFunc?

boost bind class function pointer

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

class Foo {    double f1( int x, std::string s1 );    double f2( int x, SomeClass s2 );}我希望能够在没有foo实例的情况下绑定foo.f1的s1来创建essensetypedef double (Foo::* MyFooFunc)(...

问boost绑定类函数指针
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问boost绑定类函数指针EN