boost.asio: demo.

最新推荐文章于 2024-01-04 14:45:06 发布

weixin_34166472

最新推荐文章于 2024-01-04 14:45:06 发布

阅读量195

点赞数

文章标签： c/c++ 网络 python

原文链接：https://my.oschina.net/SHIHUAMarryMe/blog/1814509

版权

2019独角兽企业重金招聘Python工程师标准>>>

demo 1: tcp socket

#include <iostream>
#include <stdexcept>
#include <exception>
#include <string>
#include <fstream>
#include <thread>

#include <boost/asio.hpp>
#include <boost/system/error_code.hpp>
#include <boost/system/system_error.hpp>

using namespace boost::asio;

int main()
{
    io_service service{};
    ip::tcp::endpoint end_point{ ip::address::from_string("192.168.1.0"), 80 };
    ip::tcp::socket socket{ service };

    socket.open(ip::tcp::v4());
    socket.connect(end_point);
    socket.write_some(buffer("GET /index\r\n"));

    std::cout << "socket available: " << socket.available() << std::endl;

    char the_buffer[1024]{};

    std::size_t size{ socket.read_some(buffer(the_buffer, 1024)) };

    std::cout<< "size of reading: " << size << std::endl;

    socket.shutdown(ip::tcp::socket::shutdown_receive);
    socket.close();

    std::cout << the_buffer << std::endl;


    return 0;
}

demo 2: udp socket

#include <iostream>
#include <stdexcept>
#include <exception>
#include <string>
#include <fstream>
#include <thread>

#include <boost/asio.hpp>
#include <boost/system/error_code.hpp>
#include <boost/system/system_error.hpp>

using namespace boost::asio;

int main()
{
    io_service service{};
    ip::udp::endpoint end_point_receiver{ ip::address::from_string("192.168.1.0"), 80 };
    ip::udp::socket socket{ service };
    socket.open(ip::udp::v4());
    socket.connect(end_point);

    char the_buffer[1024]{};

    socket.send_to(buffer("test\n"), end_point_receiver); //send data to specify address(the port is 80).

    ip::udp::endpoint end_point_sender{};
    std::cout << "the sender address: " << end_point_sender.address().to_string() << std::endl;
    socket.receive_from(buffer(the_buffer, 1024), end_point_sender);

    std::cout << "received data: " << the_buffer << std::endl;


    return 0;
}

demo 3: 查询域名ip地址.

#include <iostream>
#include <stdexcept>
#include <exception>
#include <string>
#include <fstream>
#include <thread>

#include <boost/asio.hpp>
#include <boost/system/error_code.hpp>
#include <boost/system/system_error.hpp>

using namespace boost::asio;

int main()
{
    io_service service{};
    ip::tcp::resolver resolver{ service };
    ip::tcp::endpoint end_point{ };
    ip::tcp::resolver::iterator end_point_itr{ resolver.resolve(ip::tcp::resolver::query("www.baidu.com", "80")) };

    std::cout << end_point_itr->endpoint().address().to_string() << std::endl;

    return 0;
}

demo 4: simple sync client/server

client:

#include <iostream>
#include <stdexcept>
#include <exception>
#include <string>
#include <fstream>
#include <thread>

#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include <boost/bind/bind.hpp>
#include <boost/system/error_code.hpp>
#include <boost/system/system_error.hpp>
#include <boost/enable_shared_from_this.hpp>

#include <QObject>

using namespace boost::asio;

io_service service{};
ip::tcp::endpoint end_point{ ip::address::from_string("127.0.0.1"), 8001 };

std::size_t read_complete(char* buffer, const boost::system::error_code& code, const std::size_t& size)
{
    std::cout << "=====>" << buffer << "<=====" << std::endl;

    (void)code;

    if(buffer){
        return false;
    }

    bool result{ std::find(buffer, buffer+size, '\n') < (buffer + size) };

    return (!result); //if return true shows that reading completely.
}

void sync_echo(const std::string& mesg)
{
    std::string msg_for_echoing{ mesg + '\n' };
    ip::tcp::socket tcp_socket{ service };

    std::cout<<"---->" <<msg_for_echoing << "<----" << std::endl;

    tcp_socket.connect(end_point);
    tcp_socket.write_some(boost::asio::buffer(msg_for_echoing));
    char buf[1024]{};

    std::size_t bytes{boost::asio::read(tcp_socket, boost::asio::buffer(buf), boost::bind(read_complete, buf, boost::placeholders::_1, boost::placeholders::_2))};
//    std::string client_msg{ buf, buf-1 };

//    std::cout << "size of reading: " << bytes << std::endl;
//    std::cout << "message for sending: " << msg_for_echoing << std::endl;
//    std::cout << "message of reading: " << client_msg << std::endl;

    tcp_socket.close();
}


int main()
{
    const char* megs[3]{ "shi", "hua", "marryme"};
    boost::thread_group thread_group{};

    for(std::size_t index = 0; index < 3; ++index){
        thread_group.create_thread(boost::bind(sync_echo,megs[index]));
        boost::this_thread::sleep_for(boost::chrono::milliseconds(50));
    }

    thread_group.join_all();
    return 0;
}

server:

#include <iostream>

#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/thread.hpp>
#include <boost/system/system_error.hpp>

#include "server.h"

using namespace boost::asio;

io_service service{};

std::size_t read_complete(const char* content, const boost::system::error_code& code, const std::size_t& size)
{
    if(code){
        return 0;
    }

    bool found_result{ std::find(content, content + size, '\n') < (content + size) };
    return (!found_result);
}

void handle_connection()
{
//    ip::tcp::endpoint end_point{ ip::address::from_string("0.0.0.0"), 80 };

//    std::cout << end_point.address().to_string() << std::endl;

    ip::tcp::acceptor acceptor{service, ip::tcp::endpoint{ ip::tcp::v4(), 8001 }};
    char the_buffer[1024]{};

    while(true){
        ip::tcp::socket the_socket{service};
        acceptor.accept(the_socket);
        std::size_t bytes{ boost::asio::read(the_socket, buffer(the_buffer), boost::bind(read_complete, the_buffer, boost::placeholders::_1, boost::placeholders::_2)) };
        std::string msg{the_buffer, bytes};

        std::cout << msg << std::endl;

        the_socket.write_some(buffer(msg));
        the_socket.close();
    }
}

int main()
{
    std::cout << SERVER_VERSION_MAJOR << "=======" <<SERVER_VERSION_MINOR << std::endl;
    handle_connection();

    return 0;
}

demon5: simple async client/server

client:

#include <iostream>
#include <stdexcept>
#include <exception>
#include <string>
#include <fstream>
#include <thread>

#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include <boost/function.hpp>
#include <boost/bind/bind.hpp>
#include <boost/system/error_code.hpp>
#include <boost/system/system_error.hpp>
#include <boost/enable_shared_from_this.hpp>

#include <QObject>

using namespace boost::asio;

io_service service{};

class client : public boost::enable_shared_from_this<client>
{
public:
    client(const std::string& msg)
        :boost::enable_shared_from_this<client>{},
         message{msg}{}
    virtual ~client()=default;

    client(const client&)=delete;
    client& operator=(const client&)=delete;

    void start(const ip::tcp::endpoint& end_point)
    {
        boost::function<void(const boost::system::error_code&)> on_connected_functor{
            boost::bind(&client::on_connected, this->shared_from_this(), boost::placeholders::_1)
        };

        std::cout << "=========start=========" << std::endl;

        socket.async_connect(end_point, on_connected_functor);
    }

    void do_write(const std::string& meg)
    {
        if(!this->is_starting()){
            return;
        }

        std::cout << "do_wirte" << std::endl;

        std::copy(meg.cbegin(), meg.cend(), write_buffer);

        boost::function<void(const boost::system::error_code& code, const std::size_t& size)> on_write_functor{
          boost::bind(&client::on_wirte, this->shared_from_this(), boost::placeholders::_1, boost::placeholders::_2)
        };

        socket.async_write_some(boost::asio::buffer(write_buffer, meg.size()), on_write_functor);
    }

    void do_read()
    {
        boost::function<std::size_t(const boost::system::error_code&, const std::size_t&)> read_complete_functor{
            boost::bind(&client::read_complete, this->shared_from_this(), boost::placeholders::_1, boost::placeholders::_2)
        };

        boost::function<void(const boost::system::error_code& code, const std::size_t&)> on_read_functor{
          boost::bind(&client::on_read, this->shared_from_this(), boost::placeholders::_1, boost::placeholders::_2)
        };

        boost::asio::async_read(socket, buffer(read_buffer), read_complete_functor, on_read_functor);
    }

    void on_connected(const boost::system::error_code& code)
    {
        if(code){
            std::cout << "error code: " << code.message() << std::endl;
            this->stop();
            return;
        }

        std::cout << "message: " << message << std::endl;

        do_write(message + '\n');
    }

    void on_read(const boost::system::error_code& code, const std::size_t& bytes)
    {
        if(code){
            this->stop();
            return;
        }

        std::string copy_meg{read_buffer, bytes - 1};
        std::cout << "server echoed our " << message << std::endl;

        if(copy_meg == message){
            std::cout << "ok" << std::endl;
        }else{
            std::cout << "failed" << std::endl;
        }
    }

    void on_wirte(const boost::system::error_code& code, const std::size_t& bytes)
    {
        (void)code;
        (void)bytes;

        do_read();
    }

    void stop()
    {
        if(!started){
            return;
        }

        started = false;
        socket.close();
    }

    inline bool is_starting()noexcept
    {
        return started;
    }

    std::size_t read_complete(const boost::system::error_code& code, const std::size_t& bytes)
    {
        if(code){
            return 0;
        }

        bool found_result{ std::find(read_buffer, read_buffer + bytes, '\n') < (read_buffer + bytes) };

        return static_cast<std::size_t>(!found_result);
    }

private:
    bool started{ true };
    std::string message{};
    char write_buffer[1024]{};
    char read_buffer[1024]{};

    ip::tcp::socket socket{ service };
};


int main()
{
    const char* megs[3]{ "shi", "hua", "marryme"};
    ip::tcp::endpoint end_point{ ip::address::from_string("127.0.0.1"), 8001 };

    std::cout << megs[0] << std::endl;

    for(std::size_t index = 0; index < 3; ++index){
        std::string{megs[index]};

        boost::shared_ptr<client> client_ptr{ boost::make_shared<client>(std::string{megs[index]}) };
        client_ptr->start(end_point);

        boost::this_thread::sleep(boost::posix_time::milliseconds(100));
    }

    service.run();

    return 0;
}

server:


#include <iostream>

#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/thread.hpp>
#include <boost/make_shared.hpp>
#include <boost/system/system_error.hpp>

#include "server.h"

using namespace boost::asio;

io_service service{};
ip::tcp::acceptor acceptor{service, ip::tcp::endpoint{ ip::address::from_string("127.0.0.1"), 8001 }};

class server : public boost::enable_shared_from_this<server>
{
public:
    server():boost::enable_shared_from_this<server>{}{}
    virtual ~server()=default;

    server(const server&)=delete;
    server& operator=(const server&)=delete;

    const ip::tcp::socket& sock()const = delete;
    ip::tcp::socket& sock()
    {
        return this->socket;
    }

    void start()
    {
        started = true;
        this->do_read();
    }

    inline bool is_starting()const noexcept
    {
        return this->started;
    }

    bool stop()noexcept
    {
        if(started){
            return false;
        }

        socket.close();
        return true;
    }

    void on_read(const boost::system::error_code& code, const std::size_t& bytes)
    {
        if(!code){
            std::string echoed_str{ read_buffer, bytes};

            std::cout << "str from client: " << echoed_str << std::endl;

            this->do_write(echoed_str + '\n');
        }
    }

    void on_write(const boost::system::error_code& code, const std::size_t& bytes)
    {
        (void)code;
        (void)bytes;

        do_read();
    }


    void do_write(const std::string& meg)
    {
        if(!this->is_starting()){
            return;
        }

        std::copy(meg.cbegin(), meg.cend(), write_buffer);

        boost::function<void(const boost::system::error_code& code, const std::size_t& size)> on_write_functor{
          boost::bind(&server::on_write, this->shared_from_this(), boost::placeholders::_1, boost::placeholders::_2)
        };

        socket.async_write_some(boost::asio::buffer(write_buffer, meg.size()), on_write_functor);
    }

    void do_read()
    {
        boost::function<std::size_t(const boost::system::error_code&, const std::size_t&)> read_complete_functor{
            boost::bind(&server::read_complete, this->shared_from_this(), boost::placeholders::_1, boost::placeholders::_2)
        };

        boost::function<void(const boost::system::error_code& code, const std::size_t&)> on_read_functor{
          boost::bind(&server::on_read, this->shared_from_this(), boost::placeholders::_1, boost::placeholders::_2)
        };

        boost::asio::async_read(socket, buffer(read_buffer), read_complete_functor, on_read_functor);
    }

    std::size_t read_complete(const boost::system::error_code& code, const std::size_t& bytes)
    {
        if(code){
            return 0;
        }

        bool found_result{ std::find(read_buffer, read_buffer + bytes, '\n') < (read_buffer + bytes) };

        return static_cast<std::size_t>(!found_result);
    }

private:
    ip::tcp::socket socket{ service };
    char write_buffer[1024]{};
    char read_buffer[1024]{};
    bool started{ false };
};

void handle_accept(boost::shared_ptr<server> ptr_server, const boost::system::error_code& code)
{
    ptr_server->start();

    boost::shared_ptr<server> server_ptr{ boost::make_shared<server>() };
    acceptor.async_accept(server_ptr->sock(),
                          boost::bind(handle_accept, server_ptr, boost::placeholders::_1));
}

int main()
{
    std::cout << SERVER_VERSION_MAJOR << "=======" <<SERVER_VERSION_MINOR << std::endl;
    boost::shared_ptr<server> server_ptr{ boost::make_shared<server>() };
    acceptor.async_accept(server_ptr->sock(),
                          boost::bind(handle_accept, server_ptr, boost::placeholders::_1));

    service.run();

    return 0;
}

转载于:https://my.oschina.net/SHIHUAMarryMe/blog/1814509