小编Tan*_*ury的帖子

我正在尝试使用boost :: program_options来读取包含多个部分的ini文件:

[slave]
address=localhost
port=1111

[slave]
address=192.168.0.1
port=2222

有什么解决方案吗？

提前致谢!

在python中调用C++函数时遇到一个奇怪的问题.

我公开了一个我想要调用函数的类:

class_<MyClass, std::shared_ptr<MyClass>>("MyClass", init<>())
    // ...
    .def("someFunc", &MyClass::someFunc)
;

我std::shared_ptr<MyClass>从另一个通过公开的类中获取一个成员变量.def_readonly(...)

当我尝试调用该函数时,我收到以下错误:

File "pytest.py", line 27, in test_func
    cu.someFunc("string")
Boost.Python.ArgumentError: Python argument types in
    MyClass.someFunc(MyClass, str)
did not match C++ signature:
    result(MyClass{lvalue}, std::string)

据我所知,签名确实匹配.有人看到了这个问题吗？

我正在使用boost附带的一个示例http服务器(在doc/html/boost_asio/example/cpp03/http/server,或者在http://www.boost.org/doc/libs/1_55_0/) doc/html/boost_asio/examples/cpp03_examples.html#boost_asio.examples.cpp03_examples.http_server).

该示例打开一个接受器套接字并侦听,剥离请求对象的请求.服务器还有一个boost asio signal_set,用于注册信号处理程序,并在收到SIGINT或SIGTERM时从io_service中取消所有asio请求.按CTRL-C键接收信号,io_service调出一个handle_stop()函数,然后调用.close()所有函数asio::ip::tcp::sockets.整个服务器正常关闭,io_service.run()呼叫退出,程序结束.

我希望能够在一个线程中启动这个http服务器,然后以编程方式取消它而不是使用信号.这样做的可接受方式是什么？我删除了signal_set信号处理程序,然后在另一个线程上启动了服务器.它可以很好地处理来自新线程的http请求.如何从另一个线程中阻止它？asio::ip::tcp::socket::close()从另一个线程调用是否安全？文档不清楚,只是这样做感觉非常,非asio-ish.实际上,当我尝试这样做时,只要我还没有接受任何http请求,它就能正常工作.如果我甚至处理了一个http请求,那么进程会在boost中崩溃:

>   test_ssl_server_sa.exe!boost::detail::sp_counted_base::add_ref_lock()  Line 81 + 0x3 bytes  C++
    test_ssl_server_sa.exe!boost::detail::shared_count::shared_count(const boost::detail::weak_count & r={...})  Line 578 + 0x12 bytes  C++
    test_ssl_server_sa.exe!boost::shared_ptr<http::server::connection>::shared_ptr<http::server::connection><http::server::connection>(const boost::weak_ptr<http::server::connection> & r={...})  Line 405 + 0x3f bytes    C++
    test_ssl_server_sa.exe!boost::enable_shared_from_this<http::server::connection>::shared_from_this()  Line 49 + 0xc bytes    C++
    test_ssl_server_sa.exe!http::server::connection::handle_handshake(const boost::system::error_code & error={...})  Line 83 + 0x11 bytes  C++
    test_ssl_server_sa.exe!boost::_mfi::mf1<void,http::server::connection,boost::system::error_code const &>::operator()(http::server::connection * p=0x004b8fe8, const boost::system::error_code & a1={...})  Line 165 + …

我有一个Linux服务(守护进程),它有多个线程,并使用boost io_service监听TCP套接字.当我在该套接字上收到某个消息时,我想用例如启动另一个服务/etc/init.d/corosync start.

问题是,在启动服务后,当我退出自己的服务时,另一个服务从我自己的服务继承了套接字,并且它仍处于一种奇怪的状态,我无法以通常的方式停止它.

在退出我的进程"MonitorSipServer"之前,打开的套接字显示如下:

netstat -anop |grep 144
tcp        0      0 0.0.0.0:20144           0.0.0.0:*               LISTEN          4480/MonitorSipServ off (0.00/0/0)
tcp        0      0 140.0.24.181:20144      140.0.101.75:47036      ESTABLISHED 4480/MonitorSipServ off (0.00/0/0)

退出我的进程"MonitorSipServer"后,打开的套接字显示如下:

netstat -anop |grep 144
tcp        0      0 0.0.0.0:20144           0.0.0.0:*               LISTEN      4502/corosync    off (0.00/0/0)
tcp        0      0 140.0.24.181:20144      140.0.101.75:47036      ESTABLISHED 4502/corosync    off (0.00/0/0)

我已经试过system,popen并与fork+ execv或execve与null环境.它总是相同或更糟.我最后的希望是Linux setsid命令,但它也没有用.

任何帮助,将不胜感激.此致,Jan

以下架构来自boost asio文档:

我明白,如果我调用io_service::run方法两次(在两个独立的线程中),我将有两个线程从完成事件队列中通过异步事件多路复用器来解除事件我对吗？

更确切地说,我怀疑是通过多次调用io_service::run方法实现并行化.例如,在处理套接字时,如果我有两个套接字绑定在同io_service object一个套接字调用socket.async_read_some方法上,它涉及2个注册的回调(通过async_read_some方法)可以在调用 io_service::run两次时查询.

我对boost asio :: streambuf类中的输入序列和输出序列感到困惑.

根据文档中的代码示例(用于发送数据),似乎表示输入序列的缓冲区用于写入socket,而表示输出序列的缓冲区用于读取.

示例 -

boost::asio::streambuf b;
std::ostream os(&b);
os << "Hello, World!\n";
// try sending some data in input sequence
size_t n = sock.send(b.data());
b.consume(n); // sent data is removed from input sequence

现在,有没有命名问题？

对于正在处理的辅助项目应使用哪种类型的解析器，我有些困惑。我在asio文档中找不到答案。

我知道DNS可以与UDP或TCP一起使用，并且较大的响应通常通过TCP发送。

asio提供ip :: tcp :: resolver和ip :: udp :: resolver。

• 我可以互换使用吗？
• 将名称解析为终结点之后，我计划使用TCP套接字进行连接。这是否意味着我必须使用ip :: tcp :: resolver？

如果实际上可以互换：

• 使用UDP解析器对性能有好处吗？
• 使用TCP解析器还有其他好处吗？
• 如果我使用UDP解析器，是否需要处理对于UDP查找而言太大的响应并使用TCP重试？（我希望连接到一个CDN，该CDN将解析为每个主机多个IP地址）

我正在使用boost::asio::write()将数据从缓冲区写入 com-Port。这是一个波特率为 115200 的串行端口，这意味着（据我所知）我可以有效地将 11520 字节/秒或 11,52 KB/秒的数据写入套接字。

现在我有一大块数据（10015 字节）要写入。我认为这应该需要不到一秒钟的时间才能真正在端口上写入。但是boost::asio::write()在使用传输的字节 10015 调用后已经返回 300 微秒。我认为在那个波特率下这是不可能的？

所以我的问题是它实际上在做什么？真正将其写入端口，或者只是其他类型的缓冲区，稍后将其写入端口。

我希望write()只有在所有字节真正写入端口后才返回。

编辑代码示例：

问题是我总是遇到未来/承诺的超时，因为发送消息需要超过 100 毫秒，但我认为计时器应该只在发送最后一个字节后启动。因为write()应该阻塞？

void serial::write(std::vector<uint8_t> message) {
  //create new promise for the request
  promise = new boost::promise<deque<uint8_t>>;
  boost::unique_future<deque<uint8_t>> future = promise->get_future();
  // --- Write message to serial port --- //
  boost::asio::write(serial_,boost::asio::buffer(message));
  //wait for data or timeout
  if (future.wait_for(boost::chrono::milliseconds(100))==boost::future_status::timeout) {
    cout << "ACK timeout!" << endl;
    //delete pointer and set it to 0
    delete …

Asio:是否有可自动调整大小的缓冲区来接收输入？

我事先并不知道要收到的尺寸,所以我将这个数量发送到标题中.

我查看了http://www.boost.org/doc/libs/1_59_0/doc/html/boost_asio/example/cpp03/chat/chat_message.hpp以获取使用标题的示例,但此示例假定规范为最大体型.

看一下asio :: buffer类,我必须提供一些底层缓冲区,因此不灵活.相反,我看向asio :: streambuf类,但是如下所示使用它会产生分段/内存错误.

我尝试给出最大大小以只读取HEADER_LEN字节即标题.

这种方法有误吗？

void do_recv_header() 
{
    asio::streambuf buf(HEADER_LEN);
    asio::async_read(*g_selected_conn, buf, [this, &buf](const system::error_code& ec, std::size_t bytes_transferred)
    {
        if (ec != 0) {
            std::cout << "async_read() error: " << ec.message() << " (" << ec.value() << ") " << std::endl;
            remove_closed_conn(g_selected_conn);
            SetEvent(g_wait_event);
        }
        else {
            std::istream is(&buf);
            int body_len;
            is >> body_len;
            std::cout << body_len << std::endl;
            do_recv_body(body_len);
        }
    });
}

我现在正试图抓住我的手boost::asio.这样做,我继续阅读" 在一个post/dispatch 内部或外部调用链".不知怎的,我想不通怎么里面一股不同于通过一个链,因此不能把握调用链函数的概念外链中的所有.

可能我的拼图中只缺少一小块.有人可以举个例子来说明对一条链的调用是在内部还是外部？

到目前为止,我认为我已经理解的是,通过一连串发布一些东西就是

m_strand.post(myfunctor);

要么

m_strand.wrap(myfunctor);
io_svc.post(myfunctor); 

后者被认为是dispatch对外线的召唤(而不是另一个是对post内部的召唤)？链的"内部领域"与链操作的线程之间是否存在某种关系？

如果在一个链内只是为了调用一个strand的函数,那么strand 该类的文档将毫无意义.它声明strand::post可以在线外调用......这正是我不理解的部分.