c++ - 通过 boost tcp 传输文件-6ren

c++ - 通过 boost tcp 传输文件

转载作者：可可西里更新时间：2023-11-01 02:32:36

我想通过 LAN 通过 tcp 传输一些文件，所以我为我的 TX-Part 编写了以下代码:

void send_data(char * filename, char * dest)
{
    try
    {
        boost::asio::io_service io_service;
        char dest_t = *dest;
        std::string adr = ip_adr_display[0] + ':' + boost::lexical_cast<std::string>(PORTNUM_TCP_IN);
        std::cout << "Adress is: " << adr << " and file is: " << filename << '\n';
        if(debugmode)
            debug_global << adr << '\n';
        std::string file = filename;
        async_tcp_client client(io_service, adr, file);
        io_service.run();
    }
    catch(std::exception& e)
    {
    };
};

和接收部分:

void rec_data(void)
{
    try
    {
        std::cout << "Receiving data...\n";
        async_tcp_server *recv_file_tcp_server = new async_tcp_server(PORTNUM_TCP_IN);
        if(debugmode)
            debug_global << "Receiving...\n";
        delete recv_file_tcp_server;
    }
    catch(std::exception &e)
    {
    };
};

使用以下服务器和客户端代码:

using boost::asio::ip::tcp;
    class async_tcp_client
    {
    public: 
        async_tcp_client(boost::asio::io_service& io_service, const std::string& server, const std::string& path):resolver_(io_service), socket_(io_service)
        {
            size_t pos = server.find(':');
            if(pos==std::string::npos)
                return;
            std::string port_string = server.substr(pos+1);
            std::string server_ip_or_host = server.substr(0,pos);
            source_file.open(path.c_str(), std::ios_base::binary|std::ios_base::ate);
            if(!source_file)
            {
                std::cout << "Failed to open " << path << std::endl;
                return;
            }
            size_t file_size = source_file.tellg();
            source_file.seekg(0);
            std::ostream request_stream(&request_);
            request_stream << path << "\n" << file_size << "\n\n";
            std::cout << "Request size: " << request_.size() << std::endl;
            tcp::resolver::query query(server_ip_or_host, port_string);
            resolver_.async_resolve(query, boost::bind(&async_tcp_client::handle_resolve, this, boost::asio::placeholders::error, boost::asio::placeholders::iterator));
        };
    private:
        void handle_resolve(const boost::system::error_code & err, tcp::resolver::iterator endpoint_iterator)
        {
            if(!err)
            {
                tcp::endpoint endpoint = *endpoint_iterator;
                socket_.async_connect(endpoint, boost::bind(&async_tcp_client::handle_connect, this, boost::asio::placeholders::error, ++endpoint_iterator));
            }
            else
            {
                std::cout << "Error: " << err.message() << '\n';
            }
        };

        void handle_connect(const boost::system::error_code &err, tcp::resolver::iterator endpoint_iterator)
        {
            if(!err)
            {
                boost::asio::async_write(socket_, request_, boost::bind(&async_tcp_client::handle_write_file, this, boost::asio::placeholders::error));
            }
            else if(endpoint_iterator != tcp::resolver::iterator())
            {
                socket_.close();
                tcp::endpoint endpoint = *endpoint_iterator;
                socket_.async_connect(endpoint, boost::bind(&async_tcp_client::handle_connect, this, boost::asio::placeholders::error, ++endpoint_iterator));
            }
            else
            {
                std::cout << "Error: " << err.message() << '\n';
            };
        }

        void handle_write_file(const boost::system::error_code& err)
        {
            if(!err)
            {
                if(source_file.eof() == false)
                {
                    source_file.read(buf.c_array(), (std::streamsize)buf.size());
                    if(source_file.gcount()<= 0)
                    {
                        std::cout << "read file error" << std::endl;
                        return;
                    };
                    std::cout << "Send " << source_file.gcount() << "bytes, total: " << source_file.tellg() << " bytes.\n";
                    boost::asio::async_write(socket_, boost::asio::buffer(buf.c_array(), source_file.gcount()),boost::bind(&async_tcp_client::handle_write_file, this, boost::asio::placeholders::error));
                    if(err)
                    {
                        std::cout << "Send error: " << err << std::endl;
                        return;
                    }
                }
                else
                    return;
            }
            else
            {
                std::cout << "Error: " << err.message() << "\n";
            }
        };


        tcp::resolver resolver_;
        tcp::socket socket_;
        boost::array<char, 1024> buf;
        boost::asio::streambuf request_;
        std::ifstream source_file;
    };

    class async_tcp_connection: public boost::enable_shared_from_this<async_tcp_connection>
    {
    public:
        async_tcp_connection(boost::asio::io_service& io_service):socket_(io_service), file_size(0){}
        void start()
        {
            if(debugmode)
                debug_global << __FUNCTION__ << std::endl;
            async_read_until(socket_, request_buf, "\n\n", boost::bind(&async_tcp_connection::handle_read_request, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
        }
        boost::asio::ip::tcp::socket& socket(){return socket_;}
    private:
        boost::asio::streambuf request_buf;
        size_t file_size;
        std::ofstream output_file;
        boost::asio::ip::tcp::socket socket_;
        boost::array<char, 40960> buf;
        void handle_read_request(const boost::system::error_code& err, std::size_t bytes_transferred)
        {
            if(err)
            {
                return handle_error(__FUNCTION__, err);
            }
            if(debugmode)
                debug_global << __FUNCTION__ << "(" << bytes_transferred << ")" <<", in_avail = " << request_buf.in_avail() << ", size = " << request_buf.size() << ", max_size = " << request_buf.max_size() << ".\n";
            std::istream request_stream(&request_buf);
            std::string file_path;
            request_stream >> file_path;
            request_stream >> file_size;
            request_stream.read(buf.c_array(), 2);
            if(debugmode)
                debug_global << file_path << " size is " << file_size << ", tellg = " << request_stream.tellg() << std::endl;
            size_t pos = file_path.find_last_of('\\');
            if(pos!= std::string::npos)
                file_path = file_path.substr(pos+1);
            output_file.open(file_path.c_str(), std::ios_base::binary);
            if(!output_file)
            {
                if(debugmode)
                    debug_global << "Failed to open: " << file_path << std::endl;
                return;
            }
            do{
                request_stream.read(buf.c_array(), (std::streamsize)buf.size());
                if(debugmode)
                    debug_global << __FUNCTION__ << " write " << request_stream.gcount() << " bytes.\n";
                output_file.write(buf.c_array(), request_stream.gcount());
            }while(request_stream.gcount() > 0);
            async_read(socket_, boost::asio::buffer(buf.c_array(), buf.size()),boost::bind(&async_tcp_connection::handle_read_file_content, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
        }

        void handle_read_file_content(const boost::system::error_code& err, std::size_t bytes_transferred)
        {
            if (bytes_transferred>0)
            {
                output_file.write(buf.c_array(), (std::streamsize)bytes_transferred);
                if(debugmode)
                    debug_global << __FUNCTION__ << " recv " << output_file.tellp() << " bytes."<< std::endl;
                if (output_file.tellp()>=(std::streamsize)file_size)
                {
                    return;
                }
            }
            if (err)
            {
                return handle_error(__FUNCTION__, err);
            }
            async_read(socket_, boost::asio::buffer(buf.c_array(), buf.size()), boost::bind(&async_tcp_connection::handle_read_file_content, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
        }

        void handle_error(const std::string& function_name, const boost::system::error_code& err)
        {
            if(debugmode)
                debug_global << __FUNCTION__ << " in " << function_name <<" due to " << err <<" " << err.message()<< std::endl;
        }
    }; 

    class async_tcp_server : private boost::noncopyable
    {
    public:
        typedef boost::shared_ptr<async_tcp_connection> ptr_async_tcp_connection;

        async_tcp_server(unsigned short port):acceptor_(io_service_, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port), true)
        {
                ptr_async_tcp_connection new_connection_(new async_tcp_connection(io_service_));
                acceptor_.async_accept(new_connection_->socket(), boost::bind(&async_tcp_server::handle_accept, this,new_connection_, boost::asio::placeholders::error));
                io_service_.run();
        }   
        void handle_accept(ptr_async_tcp_connection current_connection, const boost::system::error_code& e)
        {
            if(debugmode)
                debug_global << __FUNCTION__ << " " << e << ", " << e.message()<<std::endl;
            if (!e)
            {
                current_connection->start();
                //ptr_async_tcp_connection new_connection_(new async_tcp_connection(io_service_));
                //acceptor_.async_accept(new_connection_->socket(),
                //    boost::bind(&async_tcp_server::handle_accept, this,new_connection_,
                //    boost::asio::placeholders::error));
            }
        }

        ~async_tcp_server()
        {
            io_service_.stop();
        }
    private:
        boost::asio::io_service io_service_;
        boost::asio::ip::tcp::acceptor acceptor_;
    };

如果我想传输文件，我必须输入绝对路径(为什么？)，如果我输入相对路径(例如“Image.jpg”)，我会得到错误信息“无法打开Image.jpg ”。成功调用该函数后，我得到以下输出:

Adress is: <ip>:<port> and file is: <full file path>
Request size: 91
Send 1024 bytes, total: 1024 bytes
Send 1024 bytes, total: 2048 bytes
etc..
Send 1024 bytes, total: 20480 bytes
Send 406 bytes, total: -1 bytes (Why?)

在接收端，我没有收到任何数据。为什么？我不明白为什么我的代码不起作用...
非常感谢!

最佳答案

UPDATE 在我的回答中我随便说了

I added postfix .received to the output file name to prevent overwriting the source.

我刚刚意识到这可能是您的问题:

如果您将代码与发送方在同一台机器上的接收方一起使用，您将在发送源文件时覆盖它...糟糕。

因此，我修改了代码，使其能够运行。

这是测试主体:

int main()
{
    boost::thread_group g;
    g.create_thread(rec_data); // get the receiver running

    boost::this_thread::sleep_for(boost::chrono::milliseconds(100));
    g.create_thread([] { send_data("test.cpp"); });

    g.join_all();
}

我在输出文件名中添加了后缀 .received 以防止覆盖源文件。运行它时，它似乎运行良好:

g++ -std=c++11 -Wall -pedantic -pthread test.cpp -lboost_system -lboost_thread 
./a.out 
md5sum test.cpp test.cpp.received

我们得到输出

0dc16e7f0dc23cb9fce100d825852621  test.cpp.received
0dc16e7f0dc23cb9fce100d825852621  test.cpp

我还使用 png 和 93Mb 的可执行文件对其进行了测试。

完整代码(也是 on Coliru, although Coliru doesn't allow network connections ):

#include <boost/asio.hpp>
#include <boost/array.hpp>
#include <boost/bind.hpp>
#include <boost/thread.hpp>

#include <iostream>
#include <fstream>
#include <boost/enable_shared_from_this.hpp>

using boost::asio::ip::tcp;

static bool debugmode = true;
static boost::mutex debug_mutex;
static std::ostream debug_global(std::clog.rdbuf());

class async_tcp_client
{
public:
    async_tcp_client(boost::asio::io_service& io_service, const std::string& server, const std::string& path)
        : resolver_(io_service), socket_(io_service)
    {
        size_t pos = server.find(':');
        if(pos==std::string::npos)
        {
            return;
        }
        std::string port_string = server.substr(pos+1);
        std::string server_ip_or_host = server.substr(0,pos);
        source_file.open(path, std::ios_base::binary|std::ios_base::ate);
        if(!source_file)
        {
            boost::mutex::scoped_lock lk(debug_mutex);
            std::cout << __LINE__ << "Failed to open " << path << std::endl;
            return;
        }
        size_t file_size = source_file.tellg();
        source_file.seekg(0);
        std::ostream request_stream(&request_);
        request_stream << path << "\n" << file_size << "\n\n";
        {
            boost::mutex::scoped_lock lk(debug_mutex);
            std::cout << "Request size: " << request_.size() << std::endl;
        }
        tcp::resolver::query query(server_ip_or_host, port_string);
        resolver_.async_resolve(query, boost::bind(&async_tcp_client::handle_resolve, this, boost::asio::placeholders::error, boost::asio::placeholders::iterator));
    };
private:
    void handle_resolve(const boost::system::error_code & err, tcp::resolver::iterator endpoint_iterator)
    {
        if(!err)
        {
            tcp::endpoint endpoint = *endpoint_iterator;
            socket_.async_connect(endpoint, boost::bind(&async_tcp_client::handle_connect, this, boost::asio::placeholders::error, ++endpoint_iterator));
        }
        else
        {
            boost::mutex::scoped_lock lk(debug_mutex);
            std::cout << "Error: " << err.message() << '\n';
        }
    };

    void handle_connect(const boost::system::error_code &err, tcp::resolver::iterator endpoint_iterator)
    {
        if(!err)
        {
            boost::asio::async_write(socket_, request_, boost::bind(&async_tcp_client::handle_write_file, this, boost::asio::placeholders::error));
        }
        else if(endpoint_iterator != tcp::resolver::iterator())
        {
            socket_.close();
            tcp::endpoint endpoint = *endpoint_iterator;
            socket_.async_connect(endpoint, boost::bind(&async_tcp_client::handle_connect, this, boost::asio::placeholders::error, ++endpoint_iterator));
        }
        else
        {
            boost::mutex::scoped_lock lk(debug_mutex);
            std::cout << "Error: " << err.message() << '\n';
        };
    }

    void handle_write_file(const boost::system::error_code& err)
    {
        if(!err)
        {
            if(source_file)
            //if(source_file.eof() == false)
            {
                source_file.read(buf.c_array(), (std::streamsize)buf.size());
                if(source_file.gcount()<= 0)
                {
                    boost::mutex::scoped_lock lk(debug_mutex);
                    std::cout << "read file error" << std::endl;
                    return;
                };
                {
                    boost::mutex::scoped_lock lk(debug_mutex);
                    std::cout << "Send " << source_file.gcount() << "bytes, total: " << source_file.tellg() << " bytes.\n";
                }
                boost::asio::async_write(socket_, boost::asio::buffer(buf.c_array(), source_file.gcount()),boost::bind(&async_tcp_client::handle_write_file, this, boost::asio::placeholders::error));
            }
            else
            {
                return;
            }
        }
        else
        {
            boost::mutex::scoped_lock lk(debug_mutex);
            std::cout << "Error: " << err.message() << "\n";
        }
    };


    tcp::resolver resolver_;
    tcp::socket socket_;
    boost::array<char, 1024> buf;
    boost::asio::streambuf request_;
    std::ifstream source_file;
};

class async_tcp_connection: public boost::enable_shared_from_this<async_tcp_connection>
{
public:
    async_tcp_connection(boost::asio::io_service& io_service)
        : socket_(io_service), file_size(0)
    {
    }
    void start()
    {
        if(debugmode)
        {
            boost::mutex::scoped_lock lk(debug_mutex);
            debug_global << __FUNCTION__ << std::endl;
        }
        async_read_until(socket_, request_buf, "\n\n", boost::bind(&async_tcp_connection::handle_read_request, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
    }
    boost::asio::ip::tcp::socket& socket()
    {
        return socket_;
    }
private:
    boost::asio::streambuf request_buf;
    std::ofstream output_file;
    boost::asio::ip::tcp::socket socket_;
    size_t file_size;
    boost::array<char, 40960> buf;
    void handle_read_request(const boost::system::error_code& err, std::size_t bytes_transferred)
    {
        if(err)
        {
            return handle_error(__FUNCTION__, err);
        }
        if(debugmode)
        {
            boost::mutex::scoped_lock lk(debug_mutex);
            debug_global << __FUNCTION__ << "(" << bytes_transferred << ")" <<", in_avail = " << request_buf.in_avail() << ", size = " << request_buf.size() << ", max_size = " << request_buf.max_size() << ".\n";
        }
        std::istream request_stream(&request_buf);
        std::string file_path;
        request_stream >> file_path;
        request_stream >> file_size;
        request_stream.read(buf.c_array(), 2);
        if(debugmode)
        {
            boost::mutex::scoped_lock lk(debug_mutex);
            debug_global << file_path << " size is " << file_size << ", tellg = " << request_stream.tellg() << std::endl;
        }
        size_t pos = file_path.find_last_of('\\');
        if(pos!= std::string::npos)
        {
            file_path = file_path.substr(pos+1);
        }
        output_file.open(file_path + ".received", std::ios_base::binary);
        if(!output_file)
        {
            if(debugmode)
            {
                boost::mutex::scoped_lock lk(debug_mutex);
                debug_global << __LINE__ << "Failed to open: " << file_path << std::endl;
            }
            return;
        }
        do
        {
            request_stream.read(buf.c_array(), (std::streamsize)buf.size());
            if(debugmode)
            {
                boost::mutex::scoped_lock lk(debug_mutex);
                debug_global << __FUNCTION__ << " write " << request_stream.gcount() << " bytes.\n";
            }
            output_file.write(buf.c_array(), request_stream.gcount());
        }
        while(request_stream.gcount() > 0);
        async_read(socket_, boost::asio::buffer(buf.c_array(), buf.size()),boost::bind(&async_tcp_connection::handle_read_file_content, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
    }

    void handle_read_file_content(const boost::system::error_code& err, std::size_t bytes_transferred)
    {
        if (bytes_transferred>0)
        {
            output_file.write(buf.c_array(), (std::streamsize)bytes_transferred);
            if(debugmode)
            {
                boost::mutex::scoped_lock lk(debug_mutex);
                debug_global << __FUNCTION__ << " recv " << output_file.tellp() << " bytes."<< std::endl;
            }
            if (output_file.tellp()>=(std::streamsize)file_size)
            {
                return;
            }
        }
        if (err)
        {
            return handle_error(__FUNCTION__, err);
        }
        async_read(socket_, boost::asio::buffer(buf.c_array(), buf.size()), boost::bind(&async_tcp_connection::handle_read_file_content, shared_from_this(), boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
    }

    void handle_error(const std::string& function_name, const boost::system::error_code& err)
    {
        if(debugmode)
        {
            boost::mutex::scoped_lock lk(debug_mutex);
            debug_global << __FUNCTION__ << " in " << function_name <<" due to " << err <<" " << err.message()<< std::endl;
        }
    }
};

class async_tcp_server : private boost::noncopyable
{
public:
    typedef boost::shared_ptr<async_tcp_connection> ptr_async_tcp_connection;

    async_tcp_server(unsigned short port):acceptor_(io_service_, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port), true)
    {
        ptr_async_tcp_connection new_connection_(new async_tcp_connection(io_service_));
        acceptor_.async_accept(new_connection_->socket(), boost::bind(&async_tcp_server::handle_accept, this,new_connection_, boost::asio::placeholders::error));
        io_service_.run();
    }
    void handle_accept(ptr_async_tcp_connection current_connection, const boost::system::error_code& e)
    {
        if(debugmode)
        {
            boost::mutex::scoped_lock lk(debug_mutex);
            debug_global << __FUNCTION__ << " " << e << ", " << e.message()<<std::endl;
        }
        if (!e)
        {
            current_connection->start();
        }
    }

    ~async_tcp_server()
    {
        io_service_.stop();
    }
private:
    boost::asio::io_service io_service_;
    boost::asio::ip::tcp::acceptor acceptor_;
};

void send_data(std::string const& filename, std::string const& adr = "localhost:6767")
{
    try
    {
        boost::asio::io_service io_service;
        {
            boost::mutex::scoped_lock lk(debug_mutex);
            std::cout << "Adress is: " << adr << " and file is: " << filename << '\n';
        }

        if(debugmode)
        {
            boost::mutex::scoped_lock lk(debug_mutex);
            debug_global << adr << '\n';
        }

        async_tcp_client client(io_service, adr, filename);
        io_service.run();
    }
    catch(std::exception const& e)
    {
        std::cerr << "Exception in " << __PRETTY_FUNCTION__ << ": " << e.what() << "\n";
    };
};

void rec_data(void)
{
    try
    {
        {
            boost::mutex::scoped_lock lk(debug_mutex);
            std::cout << "Receiving data...\n";
        }
        async_tcp_server recv_file_tcp_server(6767);
        if(debugmode)
        {
            boost::mutex::scoped_lock lk(debug_mutex);
            debug_global << "Received\n";
        }
    }
    catch(std::exception const& e)
    {
        std::cerr << "Exception in " << __PRETTY_FUNCTION__ << ": " << e.what() << "\n";
    };
};

int main()
{
    boost::thread_group g;
    g.create_thread(rec_data); // get the receiver running

    boost::this_thread::sleep_for(boost::chrono::milliseconds(100));
    g.create_thread([] { send_data("main.cpp"); });

    g.join_all();
}

关于c++ - 通过 boost tcp 传输文件，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/22859665/

文章推荐： javascript - 无法将 "apply"陷阱设置为代理对象

文章推荐： c# - 多人游戏大厅和配对系统的架构？

文章推荐： java - 从 ServletRequest 获取 Cookie

文章推荐： tcp - 在 Erlang 中如何获取客户端的 ip 和端口？

boost - boost boost::spirit::qi以使用STL容器
我正在尝试使用boost.spirit的qi库解析某些内容，而我遇到了一个问题。根据spirit docs，a >> b应该产生类型为tuple的东西。但这是boost::tuple(又名 fusio
boost - 在 CMake 中轻松使用 Boost，无需安装 Boost(Boost CMake 模块化)
似乎有/正在努力做到这一点，但到目前为止我看到的大多数资源要么已经过时(带有死链接)，要么几乎没有信息来实际构建一个小的工作样本(例如，依赖于boost program_options 以构建可执行文
boost - boost.log 是 Boost 的正式一部分吗？
我对 Boost.Log 的状态有点困惑。这是 Boost 的官方部分，还是尚未被接受？当我用谷歌搜索时，我看到一些帖子谈论它在 2010 年是如何被接受的，等等，但是当我查看最后一个 Boost 库
boost - boost::string_ref 和 boost::string_view 的区别
Boost 提供了两种不同的实现 string_view ，这将成为 C++17 的一部分: boost::string_ref在 utility/string_ref.hpp boost::stri
boost - Boost.Geometry是否足够成熟？
最近，我被一家GIS公司雇用来重写他们的旧地理信息库。所以我目前正在寻找一个好的计算几何库。我看过CGAL，这真是了不起，但是我的老板想要免费的东西。所以我现在正在检查Boost.Geometry。
boost - 在图中添加和删除现有边(BOOST)？
假设我有一个无向图 G。假设我添加以下内容 add_edge(1,2,G); add_edge(1,3,G); add_edge(0,2,G); 现在我再说一遍: add_edge(0,2,G); 我
boost - CMake 找到 Boost，但导入的目标不适用于 Boost 版本
我使用 CMake 来查找 Boost。找到了 Boost，但 CMake 出错了 Imported targets not available for Boost version 请参阅下面的完整错
boost - boost::MPL 和 boost::fusion 之间的区别
我是 boost::fusion 和 boost::mpl 库的新手。谁能告诉我这两个库之间的主要区别？到目前为止，我只使用 fusion::vector 和其他一些简单的东西。现在我想使用 fus
boost - boost phoenix什么时候有用？
这个问题已经有答案了: 已关闭10 年前。 Possible Duplicate: What are the benefits of using Boost.Phoenix? 所以我开始阅读 boos
boost - 链接器错误 : Boost. Chrono 到 Boost.Timer
我正在尝试获得一个使用 Boost.Timer 的简单示例，用于一些秒表性能测量，但我不明白为什么我无法成功地将 Boost.Timer 链接到 Boost.Chrono。我使用以下简单脚本从源代码构
boost - C++ boost::shared_ptr & boost::weak_ptr & dynamic_cast
我有这样的东西: enum EFood{ eMeat, eFruit }; class Food{ }; class Meat: public Food{ void someM
boost - Boost::variant与无序映射
有人可以告诉我，我如何获得boost::Variant处理无序地图？ typedef boost::variant lut_value;unordered_map table; 我认为有一个用于boo
boost - boost 几何中的环和多边形有什么区别？
我对 Boost.Geometry 中的环和多边形感到困惑。在文档中，没有图形显示什么是环，什么是多边形。谁能画图解释两个概念的区别？最佳答案在 Boost.Geometry 中，多边形被定义
boost - boost::pool<>::malloc 和 boost::pool<>::ordered_malloc 有什么区别，什么时候应该使用 boost::pool<>::ordered_malloc？
我正在使用 boost.pool，但我不知道何时使用 boost::pool<>::malloc和 boost::pool<>::ordered_malloc ? 所以， boost::pool<>:
c++ - (Boost 库) - boost::container::flat_set with boost::fast_pool_allocator
我正在尝试通过 *boost::fast_pool_allocator* 使用 *boost::container::flat_set*。但是，我收到编译错误。非常感谢您的意见和建议。为了突出这个问题
c++ - boost::bind、boost::asio、boost::thread 和类
sau_timer::sau_timer(int secs, timerparam f) : strnd(io), t(io, boost::posix_time::seconds(secs)
boost - Boost.Graph 中的 boost::out_edges( v, g ) 有什么作用？
我无法理解此功能的文档，我已多次看到以下内容 tie (ei,ei_end) = out_edges(*(vi+a),g); **g**::out_edge_iterator ei, ei_end;
boost-propertytree - 我们如何在另一个 boost ptree 中插入一个 boost ptree 作为节点？
我想在 C++ 中序列化分层数据结构。我正在处理的项目使用 boost，所以我使用 boost::property_tree::ptree 作为我的数据节点结构。我们有像 Person 这样的高级结
c++ - boost::exception_detail::clone_impl>
我需要一些帮助来解决这个异常，我正在实现一个 NPAPI 插件，以便能够使用来自浏览器扩展的本地套接字，为此我正在使用 Firebreath 框架。对于套接字和连接，我使用带有异步调用的 Boost
c++ - boost::bind、boost::function 和 boost::factory 的问题
我尝试将 boost::bind 与 boost::factory 结合使用但没有成功我有这个类 Zambas 有 4 个参数(2 个字符串和 2 个整数)和 class Zambas { publ

可可西里

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

c++ - 通过 boost tcp 传输文件