#include <cstdlib>
    #include <iostream>
    #include <boost\asio.hpp>
    #include <boost\bind.hpp>
    #include <boost\array.hpp>

    using namespace boost::asio;

    class Client{

    public:
        Client(ip::udp::endpoint endP) :endPoint(endP.address(), endP.port()){}
        ip::udp::endpoint endPoint;
        bool Compare(Client &other)
        {
            if (other.endPoint.address() == endPoint.address() && other.endPoint.port() == endPoint.port())
            {
                return true;
            }
            else
            {
                return false;
            }
        }

    };

    class UdpSimpleServer{
    private:
        ip::udp::socket socket1;
        std::array<char, 1024> buff;
        std::list<Client> clients;
        ip::udp::endpoint endpoint;
        int port;

        void receive_callback(const boost::system::error_code &err, std::size_t bytes_transfered)
        {
            std::cout << "We got " << bytes_transfered << " bytes from port: " << endpoint.port() << std::endl;
            if (bytes_transfered > 0){
                buff[bytes_transfered] = '\0';
                std::cout << buff.data() << std::endl;

                Client client(endpoint);

                bool add = false;

                if (clients.size() > 0)
                {
                    for each (Client cl in clients)
                    {
                        if (client.Compare(cl))
                        {
                            add = true;
                            break;
                        }
                    }
                }

                if (!add)
                {
                    std::cout << "Add new client" << std::endl;
                    clients.push_back(client);
                    std::cout << "We have " << clients.size() << " clients now" << std::endl;
                }
                if (clients.size() > 1)
                {
                    for each (Client cl in clients)
                    {
                        if (!client.Compare(cl))
                        {
                            socket1.send_to(buffer(buff), cl.endPoint);
                            std::cout << "Sent data to: " << cl.endPoint.port() << std::endl;
                        }
                    }
                }
            }

            std::cout << std::endl;

            socket1.async_receive_from(buffer(buff), endpoint, boost::bind(&UdpSimpleServer::receive_callback, this,
                boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
        }

    public:
        UdpSimpleServer(io_service &service, int port) :socket1(service){
            UdpSimpleServer::port = port;
        }

        void Start()
        {
            try{
                socket1.open(ip::udp::v4());
                socket1.bind(ip::udp::endpoint(ip::address_v4::from_string("0.0.0.0"), port));

                socket1.async_receive_from(buffer(buff), endpoint, boost::bind(&UdpSimpleServer::receive_callback, this,
                    boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
            }
            catch (std::exception ex)
            {
                std::cout << "Error: " << ex.what() << std::endl;
            }
        }
    };

    int main()
    {
        io_service service;
        UdpSimpleServer server(service, 9050);
        server.Start();
        service.run();

        std::cin.get();
        return 0;
    }

#include <cstdlib>
#include <iostream>
#include <list>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/array.hpp>
#include <boost/thread.hpp>
#include <locale>

using namespace boost::asio;

io_service ios;

class Client
{
public:
    Client(int port) : socket_(ios)
    {
        receiver_ = ip::udp::endpoint(ip::address_v4::from_string("127.0.0.1"), port);

        socket_.open(ip::udp::v4());
        socket_.async_receive_from(buffer(buffer_), receiver_, boost::bind(&Client::on_receive, this, placeholders::error, placeholders::bytes_transferred));
    }
    void send(const std::string& msg)
    {
        std::copy(msg.begin(), msg.end(), buffer_.begin());
        socket_.async_send_to(buffer(buffer_, msg.size()), receiver_, boost::bind(&Client::on_send, this, placeholders::error, placeholders::bytes_transferred));
    }
private:

    void on_send(const boost::system::error_code& ec, const size_t bytes)
    {
        std::cout << "sended " << bytes << " bytes with " << ec.message()<< std::endl;
    }

    void on_receive(const boost::system::error_code& ec, const size_t bytes)
    {
        std::cout << "received " << bytes << " bytes with " << ec.message() << std::endl;
        buffer_[bytes] = '\0';
        std::cout << buffer_.data() << std::endl;
        socket_.async_receive_from(buffer(buffer_), receiver_, boost::bind(&Client::on_receive, this, placeholders::error, placeholders::bytes_transferred));
    }

    ip::udp::socket socket_;
    std::array<char, 1024> buffer_;
    ip::udp::endpoint receiver_;
};

int main()
{
    setlocale(LC_ALL, "");
    Client client(9050);
    client.send("hello1");
    client.send("hello2");
    client.send("hello3");
    ios.run();
}