C++ 在给定远程终端对象和套接字的情况下向客户端发送数据包？

有没有一种方法可以将数据包发送给知道使用了

endpoint.address

和

endpoint.port

的对象的客户端

EDIT：我添加了

async\u write

免费功能，但我仍然不知道如何指定

套接字的ip地址或端口，以便将
数据发送到（客户端）。这些更改是boostasync服务器示例的第44-49行

#include <cstdlib>
#include <iostream>
#include <boost/bind.hpp>
#include <boost/asio.hpp>

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

class session
{
public:
  session(boost::asio::io_service& io_service)
    : socket_(io_service)
  {
  }

  tcp::socket& socket()
  {
    return socket_;
  }

  void start()
  {
      std::cout<<"start(): "<<std::endl;
          socket_.async_read_some(boost::asio::buffer(data_, max_length),
          boost::bind(&session::handle_read, this,
          boost::asio::placeholders::error,
          boost::asio::placeholders::bytes_transferred));
  }
void read_handler(const boost::system::error_code& ec, std::size_t bytes_transferred);


private:
  void handle_read(const boost::system::error_code& error,
      size_t bytes_transferred)
  {
      std::cout<<"handle read: bytes_transferred"<<bytes_transferred<<std::endl;
    if (!error)
    {
          data_ = {'0','1','2','3','4','5','6','7','8','9'};
          /*read_handler(error, bytes_transferred);
          boost::asio::async_write(socket_,boost::asio::buffer(data_, bytes_transferred),
                boost::bind(&session::handle_write, this,
                            boost::asio::placeholders::error));*/
          boost::system::error_code ec;
          boost::asio::ip::tcp::endpoint endpoint = socket_.remote_endpoint(ec);
          std::cout<<"ip address: "<<endpoint.address()<<std::endl;
          std::cout<<"port: "<<endpoint.port()<<std::endl;
          //how to get the socket to send data to specific port, ip-address e.g. changing the ip-address and port by editing it?
          async_write(socket_, boost::asio::buffer(data_, max_length), boost::bind(&session::writeHandler, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
    }
    else
    {
      delete this;
    }
  }
  void writeHandler(const boost::system::error_code& errorCode, size_t bytesTransferred)
  {
        std::cout << "DEBUG> Transfered " << bytesTransferred << " bytes to " << socket_.remote_endpoint().address().to_string() << std::endl;
  }
  void handle_write(const boost::system::error_code& error)
  {
      std::cout<<"handle write: "<<std::endl;

    if (!error)
    {
            std::cout<<"before: "<<data_<<std::endl;

            socket_.async_read_some(boost::asio::buffer(data_, max_length),
            boost::bind(&session::handle_read, this,
            boost::asio::placeholders::error,
            boost::asio::placeholders::bytes_transferred));

            std::cout<<"after: "<<data_<<std::endl;
    }
    else
    {
      delete this;
    }
  }

  tcp::socket socket_;
  enum { max_length = 1024 };
  char data_[max_length];
};
void session::read_handler(const boost::system::error_code& ec, std::size_t bytes_transferred)
{
      std::cout<<bytes_transferred<<std::endl;
}

class server
{
public:
  server(boost::asio::io_service& io_service, short port)
    : io_service_(io_service),
      acceptor_(io_service, tcp::endpoint(tcp::v4(), port))
  {
    start_accept();
  }


private:
  void start_accept()
  {
    session* new_session = new session(io_service_);
    acceptor_.async_accept(new_session->socket(),
        boost::bind(&server::handle_accept, this, new_session,
          boost::asio::placeholders::error));
  }

  void handle_accept(session* new_session,
      const boost::system::error_code& error)
  {
    if (!error)
    {
      new_session->start();
    }
    else
    {
      delete new_session;
    }

    start_accept();
  }

  boost::asio::io_service& io_service_;
  tcp::acceptor acceptor_;
};

int main()
{
  try
  {
    boost::asio::io_service io_service;
    server s(io_service, 4000);

    io_service.run();
  }
  catch (std::exception& e)
  {
    std::cerr << "Exception: " << e.what() << "\n";
  }

  return 0;
}

#包括
#包括
#包括
#包括
使用boost:：asio:：ip:：tcp；
课堂
{
公众：
会话（boost:：asio:：io_服务和io_服务）
：socket_（io_服务）
{
}
tcp:：套接字和套接字（）
{
返回插座；
}
void start（）
{
std:：cout假设TCP套接字，因为这是您在文档中链接到的，不，这是不可能的。您需要一个套接字对象来发送数据，而不仅仅是一个端点。使用
async_write（）
free函数，它的许多重载之一，或任何用于发送数据的套接字类方法。
好的，我改变了主意，
socket
对象可用，但我只能使用
write
或
send
否？我查看了
async\u write
页面，但没有一个参数使用
remote\u端点
？这与图中的情况如何？@lost async_write（）是一个通用函数，第一个参数可以是满足以下条件的任何类型。通常，这是公开异步写入的任何类型（）方法。我看了这个页面，他似乎声明了一个
数据包
，但我似乎在任何名称空间下都找不到
数据包
，
boost:：asio:：ip:：tcp；
？我有点期待他在
异步写入
函数中发送的
数据包
是boost-asio的一部分。我忘了问，有什么办法改变吗使用
socket\uu.remote\u endpoint（）.address（）.
的套接字地址？我尝试了
socket\uu.remote\u endpoint（）.address（“127.0.0.1”）
，但编译时运气不佳。我假设端口的编码也会类似。