Boost.asio ошибка в socket.connect

#include <boost/asio.hpp>
#include <iostream>
 
int main()
{
    boost::asio::io_service io_service;
    
    boost::asio::ip::tcp::endpoint server_endpoint( boost::asio::ip::tcp::v4(), 9999 );
    boost::asio::ip::tcp::socket server_socket( io_service );
    boost::asio::ip::tcp::acceptor server_acceptor( io_service, server_endpoint );
    
    boost::asio::ip::tcp::socket socket( io_service );
    boost::asio::ip::tcp::endpoint endpoint( boost::asio::ip::address::from_string("127.0.0.1"), 9999 );
    
    boost::system::error_code ec;
    socket.connect(endpoint,ec);
    if(!ec)
    {
        std::cerr << "connected" << std::endl;
    }
    else
    {
        std::cerr << ec.message() << std::endl;
    }
    
    return 0;
}

boost::asio::ip::tcp::acceptor acceptor(io_service, endpoint );

boost::asio::ip::tcp::acceptor acceptor(io_service);
acceptor.open(protocol);
acceptor.bind(endpoint);
acceptor.listen();

#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/smart_ptr.hpp>
#include <boost/thread.hpp>
 
#include <deque>
#include <iostream>
 
namespace
{
    std::deque< std::string > messagesToSend;
    boost::asio::io_service ioService;
    boost::shared_ptr< boost::asio::io_service::work > work;
}
 
class Server
{
public:
    Server( boost::asio::io_service& ioService )
        : acceptor_( ioService, boost::asio::ip::tcp::endpoint( boost::asio::ip::tcp::v4(), 7001 ) )
        , socket_( ioService )
    {
    }
 
    ~Server()
    {
        stop();
    }
 
    void run()
    {
        acceptor_.async_accept( socket_, boost::bind( &Server::onAccept, this, _1 ) );
    }
    
    void stop()
    {
        if( socket_.is_open() )
        {
            socket_.cancel();
            socket_.close();
        }
        
        socket_.close();
        acceptor_.close();  
    }
 
private:
    void onAccept( const boost::system::error_code& e )
    {
        if( e )
        {
            std::cerr << "Server error on accept: " << e.message() << std::endl;
            return;
        }
        socket_.async_read_some( boost::asio::buffer( buffer_, 512 ), boost::bind( &Server::onRead, this, _1, _2 ) );
    }
 
    void onRead( const boost::system::error_code& e, std::size_t bytesTransferred )
    {
        if( bytesTransferred )
        {
            std::cout << "Server got msg: " << std::string( buffer_, bytesTransferred ) << std::endl;
        }
        if( e )
        {
            std::cerr << "Server error on read: " << e.message() << std::endl;
            return;
        }
        
        boost::this_thread::sleep( boost::posix_time::milliseconds(100) );
        
        socket_.async_read_some( boost::asio::buffer( buffer_, 512 ), boost::bind( &Server::onRead, this, _1, _2 ) );
    }
 
private:
    boost::asio::ip::tcp::acceptor acceptor_;
    boost::asio::ip::tcp::socket socket_;
 
    char buffer_[512];
};
 
class Client
{
public:
    Client( boost::asio::io_service& ioService )
        : socket_( ioService )
    {
    }
 
    ~Client()
    {
        if( socket_.is_open() )
        {
            socket_.cancel();
            socket_.close();
        }
    }
 
    void run()
    {
        socket_.async_connect( boost::asio::ip::tcp::endpoint( boost::asio::ip::address::from_string("127.0.0.1"), 7001 ),
                               boost::bind( &Client::onConnect, this, _1 ) );
    }
 
private:
    void onConnect( const boost::system::error_code& e )
    {
        if( e )
        {
            std::cerr << "Client error on connect: " << e.message() << std::endl;
            return;
        }
        if( messagesToSend.empty() )
        {
            std::cerr << "Client has nothing to send" << std::endl;
        }
        
        std::cout << "Clent sending message: " << messagesToSend[0] << std::endl;
        
        boost::asio::async_write( socket_,
                                  boost::asio::buffer( messagesToSend[0].data(), messagesToSend[0].size() ),
                                  boost::bind( &Client::onWrite, this, _1, _2, 1 ) );
    }
 
    void onWrite( const boost::system::error_code& e, std::size_t bytesTransferred, int messageNumber )
    {
        if( e )
        {
            std::cerr << "Client error on write: " << e.message() << std::endl;
            return;
        }
        if( messageNumber >= messagesToSend.size() )
        {
            std::cout << "Client has sent all messages" << std::endl;
            return;
        }
        
        boost::this_thread::sleep( boost::posix_time::milliseconds(300) );
        std::cout << "Clent sending message: " << messagesToSend[messageNumber] << std::endl;
        
        boost::asio::async_write( socket_,
                                  boost::asio::buffer( messagesToSend[messageNumber].data(), messagesToSend[messageNumber].size() ),
                                  boost::bind( &Client::onWrite, this, _1, _2, messageNumber+1 ) );
    }
 
private:
    boost::asio::ip::tcp::socket socket_;
};
 
int main()
{
    messagesToSend.push_back( "First Message ");
    messagesToSend.push_back( "Second Message ");
    
    work.reset( new boost::asio::io_service::work( ioService ) );
    
    boost::thread thread( boost::bind( &boost::asio::io_service::run, &ioService ) );
 
    Server server( ioService );
    server.run();
    
    Client client( ioService );
    client.run();
 
    boost::this_thread::sleep( boost::posix_time::seconds(1) );
    
    server.stop();
    work.reset();
    thread.join();
 
    return 0;
}