天道酬勤,学无止境

Using boost::bind to bind member-function to boost::bisect?

I've had problems with this before but now it's somehow working.

Now I've following problem. I need to bind values into member-function before I call boost::bisect with the same function. I found pretty good tutorial and I've followed it but it seems that I'm still doing something wrong.

At first I created test class where I got following working:

std::pair<double, double> result = bisect(&Func, 0.0, 1.0, TerminationCondition());
            double root = (result.first + result.second) / 2;

After that I added binding "on the fly as I thought it could work"

 std::pair<double, double> result = bisect(boost::bind(&CLASS::Function,this, _1), 0.0, 1.000000, TerminationCondition());

Result of that was an error. error: terminate called after throwing an instance of 'boost::exception_detail::clone_impl >' what(): Error in function boost::math::tools::bisect: No change of sign in boost::math::tools::bisect, either there is no root to find, or there are multiple roots in the interval (f(min) = -0.0032916729090909091).

Anyway here is class::function which doesn't work as member function with binding for some reason. I tested it as non-member and it works

double CLASS::Function(double c)
{
/* values: m_a, m_b, m_c, m_d, and m_minus are located in .h file */

normal norm;
double temp = m_d*sqrt(c);

double total = ((1-boost::math::pdf(norm,(m_a*c+m_b)/temp))-(1 - m_c)+boost::math::pdf(norm,(m_a*c+m_b)/temp));

return (total - m_minus); 
}

评论

If I read the tutorial correctly, it should be:

std::pair<double, double> result =
    bisect(boost::bind(&CLASS::Function, this, _1, _2, _3),
        0.0, 1.000000, TerminationCondition());

I.e. the parameters to boost::bind() are:

  1. The name of the function (object) to bind to
  2. the arguments to pass to that, as the function expects them

For your case, a CLASS::memberFunc(), that'd be a CLASS * (possibly this but any CLASS * is ok) as the first, which you literally state as such, followed by the parameters later passed to the bound object.

These "futures" are designated by _1, _2 and so on, depending on their position at invocation time.

Example:

class addthree {
private:
    int second;
public:
    addthree(int term2nd = 0) : second(term2nd) {}
    void addto(int &term1st, const int constval) {
        term1st += (term2nd + constval);
    }
}

int a;
addthree aa;
boost::function<void(int)> add_to_a = boost::bind(&addthree::addto, &aa, a, _1);
boost::function<void(void)> inc_a = boost::bind(&addthree::addto, &aa, a, 1);

a = 0 ; add_to_a(2); std::cout << a << std::endl;
a = 10; add_to_a(a); std::cout << a << std::endl;
a = 0 ; inc_a(); std::cout << a << std::endl;
[ ... ]

This code:

std::pair<double, double> result = bisect(boost::bind(&CLASS::Function,this, _1), 0.0, 1.000000, TerminationCondition());

is correct. The error you get means that what CLASS::Function returns is invalid. bisect is complaining about multiple roots (or possibly no roots) in the given interval [0; 1]. How does CLASS::Function look like?

受限制的 HTML

  • 允许的HTML标签:<a href hreflang> <em> <strong> <cite> <blockquote cite> <code> <ul type> <ol start type> <li> <dl> <dt> <dd> <h2 id> <h3 id> <h4 id> <h5 id> <h6 id>
  • 自动断行和分段。
  • 网页和电子邮件地址自动转换为链接。

相关推荐
  • 提升 async_wait 并在绑定中添加“this”[重复](boost async_wait and adding “this” in a bind [duplicate])
    问题 这个问题在这里已经有了答案: 如何使用带有成员函数的 boost 绑定1 个回答 5年前关闭。 在这个在类中使用 boost 异步定时器的例子中,作者在 m_timer.async_wait 方法中添加了指向绑定函数的“this”指针。 这很奇怪,因为处理程序是一个不带参数的公共方法 (message(void)),那么为什么要使用 boost::bind 尤其是指针 "this" 呢? class handler { public: handler(boost::asio::io_service& io) : m_timer(io, boost::posix_time::seconds(1)), m_count(0) { m_timer.async_wait(boost::bind(&handler::message, this)); } ~handler() { std::cout << "The last count : " << m_count << "\n"; } void message() { if (m_count < 5) { std::cout << m_count << "\n"; ++m_count; m_timer.expires_at(m_timer.expires_at() + boost::posix_time::seconds(1)); m
  • boost asio async_read:读取的消息添加到自身(boost asio async_read: the read message adds to itself)
    问题 我用我的电脑作为服务器。 客户端发送类似“PART1:Part2”的消息,服务器执行必要的操作。 我使用 boost 的 asio 作为服务器代码。 void start_read() { boost::asio::async_read(socket_, input_buffer_, boost::asio::transfer_at_least(1), boost::bind(&tcp_connection::handle_read, shared_from_this(), boost::asio::placeholders::error)); } // When stream is received handle the message from the client void handle_read(const boost::system::error_code& error) { if (!error) { boost::asio::streambuf::const_buffers_type bufs = input_buffer_.data(); std::string msgstr(boost::asio::buffers_begin(bufs), boost::asio::buffers_begin(bufs) + input_buffer_.size())
  • Boost.Python:包装函数以释放GIL(Boost.Python: Wrap functions to release the GIL)
    问题 我目前正在使用Boost.Python,希望获得一些帮助来解决棘手的问题。 语境 当C ++方法/函数暴露给Python时,它需要释放GIL(全局解释器锁)以让其他线程使用解释器。 这样,当python代码调用C ++函数时,解释器可以被其他线程使用。 现在,每个C ++函数如下所示: // module.cpp int myfunction(std::string question) { ReleaseGIL unlockGIL; return 42; } 为了通过它来增强python,我这样做: // python_exposure.cpp BOOST_PYTHON_MODULE(PythonModule) { def("myfunction", &myfunction); } 问题 该方案可以正常工作,但是它暗示module.cpp完全没有依赖Boost.Python依赖。 理想情况下,只有python_exposure.cpp应该依赖Boost.Python 。 解决方案? 我的想法是使用Boost.Function来包装函数调用,如下所示: // python_exposure.cpp BOOST_PYTHON_MODULE(PythonModule) { def("myfunction", wrap(&myfunction)); }
  • 使用 boost::asio::io_service::post()(Using boost::asio::io_service::post())
    问题 首先,我问这个 在主线程上从 boost 线程运行一个函数并将参数传递给该函数 所以现在我正在尝试这个: 下面是一个控制台c++项目,我完美模拟了我的大项目 TestServicePost.cpp #include "stdafx.h" #include "SomeClass.h" int _tmain(int argc, _TCHAR* argv[]) { SomeClass* s = new SomeClass(); while(true) { s->update(); } return 0; } 某个类.h #include <boost/thread.hpp> #include <boost/asio.hpp> #include <queue> class ServiceNote { public: std::string getType() { std::stringstream typeSS; typeSS << "LamasaTech.MultiWall.PostNote." << (NoteType.compare("Normal") == 0 ? "Node" : "Header") << "." << Shape << "." << Colour; return typeSS.str(); } int Action; int CNoteId; std
  • 成员函数指针的实际用途是什么?(What is the practical use of pointers to member functions?)
    问题 我已经通读了这篇文章,从中得出的结论是,当您想要调用指向成员函数的指针时,您需要一个实例(指向一个的指针或堆栈引用)并这样调用它: (instance.*mem_func_ptr)(..) or (instance->*mem_func_ptr)(..) 我的问题是基于这个:既然你有实例,为什么不直接调用成员函数,像这样: instance.mem_func(..) //or: instance->mem_func(..) 成员函数指针的合理/实际用途是什么? [编辑] 我正在玩 X-development 并达到了实现小部件的阶段; 当事件到达时,用于将 X 事件转换为我的类和小部件的事件循环线程需要为每个小部件/窗口启动线程; 为了正确地做到这一点,我认为我需要指向我的类中的事件处理程序的函数指针。 不是这样:我确实发现我可以通过简单地使用虚拟基类以更清晰、更整洁的方式做同样的事情。 不需要指向成员函数的指针。 正是在开发上述内容时,出现了对指向成员函数的指针的实际可用性/意义的怀疑。 您需要对实例的引用才能使用成员函数指针这一简单的事实,已经过时了。 [编辑 - @sbi 和其他人] 这是一个示例程序来说明我的观点:(特别注意“Handle_THREE()”) #include <iostream> #include <string> #include <map> //
  • 误解函数指针 - 将其作为参数传递(Misunderstanding function pointer - passing it as an argument)
    问题 我想通过函数指针作为参数将 A 类的成员函数传递给 B 类。 请告知这条路是否通向某个地方,并帮助我填补坑洼。 #include <iostream> using namespace std; class A{ public: int dosomeA(int x){ cout<< "doing some A to "<<x <<endl; return(0); } }; class B{ public: B(int (*ptr)(int)){ptr(0);}; }; int main() { A a; int (*APtr)(int)=&A::dosomeA; B b(APtr); return 0; } 这段精彩的代码给我留下了编译器错误: 无法在初始化时将int (A::*)(int)' to int (*)(int)' 首先我想让它编译。 其次,我不希望 dosomeA 是静态的。 回答1 成员指针与普通函数指针不同。 由于编译器错误表明&A::dosomeA的类型实际上是int (A::*)(int)而不是int (*)(int) 。 在B的构造函数中,您需要一个A的实例来使用.*或->*运算符调用成员。 例如' B(int(A::*ptr)(int)) { A atmp; (atmp.*ptr)(int); } 回答2 http://www.parashift
  • 如何使用成员函数初始化`std :: function`?(How to initialize `std::function` with a member-function?)
    问题 我正在尝试学习std::function ,这是我的代码: #include <iostream> #include <functional> struct Foo { void print_add(int i){ std::cout << i << '\n'; } }; typedef std::function<void(int)> fp; void test(fp my_func) { my_func(5); } int main(){ Foo foo; test(foo.print_add); return 0; } 编译器错误: error: cannot convert 'Foo::print_add' from type 'void (Foo::)(int)' to type 'fp {aka std::function<void(int)>}' test(foo.print_add); 如何使这项工作有效,即如何将成员函数作为参数传递? 回答1 print_add是foo一个非静态成员函数,这意味着它必须在Foo的实例上调用; 因此它有一个隐式的第一个参数this指针。 使用可捕获foo实例并在其上调用print_add的lambda。 Foo foo; test([&foo](int i){ foo.print_add(i); }); 另一个选择是使用std
  • 将成员函数作为参数传递给函数模板(passing member-function as argument to function-template)
    问题 Consider three ways to implement a routine in c++: through functors, member functions, and non-member functions. For example, #include <iostream> #include <string> using std::cout; using std::endl; using std::string; class FOO { public: void operator() (string word) // first: functor { cout << word << endl; } void m_function(string word) // second: member-function { cout << word << endl; } } FUNCTOR; void function(string word) // third: non-member function { cout << word << endl; } Now consider a template-function to call the three functions above: template<class T> void eval(T fun) { fun(
  • C ++ 11 std :: bind和boost :: bind之间的区别(Difference between C++11 std::bind and boost::bind)
    问题 两者之间有什么区别吗? 还是我可以安全地用代码中的std::bind替换每次出现的boost::bind ,从而消除对Boost的依赖? 回答1 boost::bind重载了关系运算符,而std::bind没有。 boost::bind支持非默认调用约定,不能保证std::bind (标准库实现可能将此作为扩展)。 boost::bind提供了一种直接的机制,可以防止对嵌套绑定表达式(boost :: protect)的急切求值,而std::bind则不能。 (也就是说,如果需要,可以使用带有std::bind boost::protect ,或者自己轻松地重新实现它。) std::bind提供了一种直接的机制,允许人们将任何用户定义的函子视为嵌套的绑定表达式,以强制进行急切的评估(std :: is_bind_expression:[func.bind.isbind] / 1,[func.bind.bind ] / 10), boost::bind则不会。 回答2 除了在其他答案中引用的几个差异之外,这还有两个其他差异: 在某些情况下, boost::bind似乎可以处理重载的函数名,而std::bind不能以相同的方式处理它们。 参见C ++ 11常见问题解答 (使用gcc 4.7.2,提升lib版本1_54) void foo(){} void foo(int i){}
  • 使用 boost::bind() 或不使用 boost::bind() 创建一个 boost::thread(Creating a boost::thread with boost::bind() or without)
    问题 有些人似乎使用 boost::bind() 函数启动 boost::threads,就像在以下问题的公认答案中一样: 使用 boost 线程和非静态类函数 而其他人根本不使用它,就像在这个问题中获得最多投票的答案中一样: 作为 C++ 类的成员启动线程的最佳方法? 那么,如果存在,又有什么区别呢? 回答1 正如您在下面编译并给出预期输出的代码中看到的那样,对于将 boost::thread 与自由函数、成员函数和静态成员函数一起使用,boost::bind 是完全没有必要的: #include <boost/thread/thread.hpp> #include <iostream> void FreeFunction() { std::cout << "hello from free function" << std::endl; } struct SomeClass { void MemberFunction() { std::cout << "hello from member function" << std::endl; } static void StaticFunction() { std::cout << "hello from static member function" << std::endl; } }; int main() { SomeClass
  • 如何在 VC++ 2010 中使用带有 boost::bind/std::bind 的 lambda 函数?(How to use lambda functions with boost::bind/std::bind in VC++ 2010?)
    问题 我有一些我想使用 boost::bind 或 std::bind 绑定的 lambda 函数。 (不管哪个,只要它有效。)不幸的是,它们都给了我不同的编译器错误: auto f = [](){ cout<<"f()"<<endl; }; auto f2 = [](int x){ cout<<"f2() x="<<x<<endl; }; std::bind(f)(); //ok std::bind(f2, 13)(); //error C2903: 'result' : symbol is neither a class template nor a function template boost::bind(f)(); //error C2039: 'result_type' : is not a member of '`anonymous-namespace'::<lambda0>' boost::bind(f2, 13)(); //error C2039: 'result_type' : is not a member of '`anonymous-namespace'::<lambda1>' 那么,最简​​单的解决方法是什么? 回答1 您需要手动指定返回类型: boost::bind<void>(f)(); boost::bind<int>(f2, 13)()
  • 如何提升::绑定到传递并返回 std::string 的托管类的成员?(How can I boost::bind to a member of a managed class which passes and returns a std::string?)
    问题 我正在尝试做一些与此非常相似的事情,但我正在努力将字符串传递给/从回调传递。 这是我尝试运行的代码的精简版本: using namespace System; using namespace System::Runtime::InteropServices; #pragma unmanaged // The unmanaged boost function prototype the native library wants to bind to typedef boost::function<std::string(const std::string&)> MyNativeCallback; // The unmanaged library I'm trying to wrap class MyUnmanagedClass { public: MyUnmanagedClass() {} void RegisterCallback(MyNativeCallback callback); }; // Taken from here: https://stackoverflow.com/questions/163757/how-to-use-boostbind-in-c-cli-to-bind-a-member-of-a-managed-class typedef std
  • 如何将 boost::bind 对象传递给函数?(How do you pass boost::bind objects to a function?)
    问题 我有一个一维函数最小化器。 现在我正在传递它的函数指针。 然而,许多函数有多个参数,其中一些是固定的。 我已经使用像这样的函子实现了这个 template <class T> minimize(T &f) { } Functor f(param1, param2); minimize<Functor>(f); 然而,函子定义有很多问题。 Boost::bind 看起来更干净。 所以我可以这样做: minimize(boost:bind(f,_1,param1,param2)) 但是我不清楚我的minimize声明应该像使用boost::bind 。 boost::bind是什么类型的对象? 是否有一种简单的模式可以避免仿函数样板但允许多参数绑定? 回答1 你可以只使用boost::function 。 我认为boost::bind确实有自己的返回类型,但这与boost::function兼容。 典型的用途是为函数创建一个 typedef: typedef boost::function<bool(std::string)> MyTestFunction; 然后你可以通过boost::bind传递任何兼容的函数: bool SomeFunction(int i, std::string s) { return true; } MyTestFunction f = boost
  • 在没有组合的情况下对嵌套的 boost::bind 执行参数替换(Perform argument substitution on nested boost::bind without composition)
    问题 假设我有一个函数,它将一个空函子作为参数: void enqueue( boost::function<void()> & functor ); 我有另一个函数,它接受一个 int 并在内部做一些事情: void foo( int a); 我想将这些嵌套但不组合在一起,以便我得到一个带有签名的函子: boost::function<void(int)> functor 当用一个值调用时 - 比如 4 - 执行以下操作: enqueue( boost::bind(&foo, 4) ) 我的第一次尝试如下: boost::function<void(int)> functor = boost::bind(&enqueue, boost::bind(&foo,_1)) 这会失败,因为 bind 在给定嵌套绑定时执行组合。 foo 首先被调用,然后值 void 被“返回”到入队,但失败了。 我的第二次尝试如下: boost::function<void(int)> functor = boost::bind(&enqueue, boost::protect( boost::bind(&foo, _1) ) ) 这失败了,因为 enqueue 接受一个空值,而不是一元函子。 我所寻求的可以完成吗? 其他信息: 这与 6 年前未回答的 boost 论坛问题基本相同:http:/
  • How can I boost::bind to a member of a managed class which passes and returns a std::string?
    I'm trying to do something very similar to this but I'm struggling to pass the string to/from the callback. This is a pared down version of the code I'm trying to run: using namespace System; using namespace System::Runtime::InteropServices; #pragma unmanaged // The unmanaged boost function prototype the native library wants to bind to typedef boost::function<std::string(const std::string&)> MyNativeCallback; // The unmanaged library I'm trying to wrap class MyUnmanagedClass { public: MyUnmanagedClass() {} void RegisterCallback(MyNativeCallback callback); }; // Taken from here: https:/
  • 如何解决 boost::shared_ptr 和使用 std::shared_ptr 之间的冲突?(How to resolve conflict between boost::shared_ptr and using std::shared_ptr?)
    问题 如果我在此代码片段中从 boost::shared_ptr 更改为 std::shared_ptr,我将收到链接器错误。 #include <iostream> #include <sstream> #include <iterator> #include <cctype> #include <cmath> #include <string> #include <vector> #include <stack> #include <queue> #include <set> #include <map> #include <functional> #include <utility> #include <numeric> #include <boost/assign.hpp> #include <boost/assign/std/vector.hpp> #include <boost/algorithm/string.hpp> #include <boost/test/included/unit_test.hpp> #include <boost/test/included/unit_test_framework.hpp> #include <boost/bind.hpp> //using namespace std; //using namespace boost
  • C++:BOOST-bind error: no matching function for call to 'bind(<unresolved overloaded function type>, …?
    I tried to turn this boost-asio server into a class and I got this one error trying to compile it, C:\Documents and Settings\tcpip_server\TCPIP_server.h||In member function 'void TCPIP_server::server(boost::asio::io_service&, short int)':| C:\Documents and Settings\tcpip_server\TCPIP_server.h|56|error: no matching function for call to 'bind(<unresolved overloaded function type>, boost::shared_ptr<boost::asio::basic_stream_socket<boost::asio::ip::tcp, boost::asio::stream_socket_service<boost::asio::ip::tcp> > >&)'| c:\program files\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.4.1\..\..\..\
  • 如何在C ++ / CLI中使用boost :: bind绑定托管类的成员(How to use boost::bind in C++/CLI to bind a member of a managed class)
    问题 我在本机C ++类中使用boost :: signal,现在我在C ++ / CLI中编写.NET包装器,以便可以将本机C ++回调公开为.NET事件。 当我尝试使用boost :: bind获取托管类的成员函数的地址时,出现编译器错误3374,表示除非创建代理实例,否则无法获取成员函数的地址。 有谁知道如何使用boost :: bind绑定托管类的成员函数? 为了澄清起见,以下示例代码会导致编译器错误3374: #include <boost/bind.hpp> public ref class Managed { public: Managed() { boost::bind(&Managed::OnSomeEvent, this); } void OnSomeEvent(void) { } }; 回答1 当您的答案起作用时,它将向世界展示您的某些实现(Managed :: OnSomeEvent)。 如果您不希望人们通过调用OnSomeEvent()随意引发OnChange事件,则可以如下更新您的Managed类(基于此建议): public delegate void ChangeHandler(void); typedef void (__stdcall *ChangeCallback)(void); public ref class Managed {
  • Boost函数对象 boost.bind boost.function Boost.Ref Boost.Lambda
    这次主要介绍的是函数对象,可能称为“高阶函数”更为适合。它实际上是指那些可以被传入到其它函数或是从其它函数返回的一类函数,在C++中高阶函数是被实现为函数对象的。本文将会介绍几个用于处理函数对象的Boost C++库。 其中,Boost.Bind 可替换来自C++标准的著名的 std::bind1st() 和 std::bind2nd() 函数,而 Boost.Function 则提供了一个用于封装函数指针的类。 最后,Boost.Lambda 则引入了一种创建匿名函数的方法。 一、Boost.Bind Boost.Bind简化了由C++标准中的std::bind1st和std::bind2nd 模板函数所提供的一个机制:将这些函数与几乎不限数量的参数一起使用,就可以得到指定签名的函数。这种情形的一个最好的例子就是在C++标准中定义的多个不同算法。 [cpp] view plaincopy #include <iostream> #include <vector> #include <algorithm> void print(int i) { std::cout << i << std::endl; } int main() { std::vector<int> v; v.push_back(1); v.push_back(3); v.push_back(2); std::for
  • 如何将读取处理程序传递给 Beast websocket 的 async_read?(How to pass read handler to async_read for Beast websocket?)
    问题 如何将回调传递给async_read ? 我尝试了以下但它不会编译。 我基于修改文档中的代码 #include <beast/core.hpp> #include <beast/http.hpp> #include <beast/version.hpp> #include <boost/asio.hpp> #include <beast/websocket.hpp> #include <boost/bind.hpp> #include <iostream> #include <fstream> #include <unistd.h> #include <string.h> #include <sys/types.h> #include <unistd.h> using tcp = boost::asio::ip::tcp; namespace http = beast::http; namespace websocket = beast::websocket; beast::multi_buffer buffer_; void read_handler( const boost::system::error_code& ec, std::size_t bytes_transferred) { std::cout << "READ" << std::endl; std