每个客户端的boost :: asio独立数组

Question

我学习了C ++，现在我想继续学习一些网络编程。我决定使用boost :: asio，因为它是多平台的。我写了这个简单的程序：

客户端：

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

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

enum { max_length = 1000000 };

int main(int argc, char* argv[])
{
    while(1)
      {

  try
  {
    if (argc != 3)
    {
      std::cerr << "Usage: blocking_tcp_echo_client <host> <port>\n";
      return 1;
    }

    boost::asio::io_service io_service;

    tcp::resolver resolver(io_service);
    tcp::resolver::query query(tcp::v4(), argv[1], argv[2]);
    tcp::resolver::iterator iterator = resolver.resolve(query);

    tcp::socket s(io_service);
    s.connect(*iterator);

    using namespace std; // For strlen.

    std::cout << "Enter message: ";
    char request[max_length];
    std::cin.getline(request, max_length);
    if (request == "\n")
      continue;

    size_t request_length = strlen(request);
    boost::asio::write(s, boost::asio::buffer(request, request_length));

    char reply[max_length];
    boost::system::error_code error;
    size_t reply_length = s.read_some(boost::asio::buffer(reply), error);

   if (error == boost::asio::error::eof)
     break; // Connection closed cleanly by peer.
   else if (error)
     throw boost::system::system_error(error); // Some other error.




    std::cout << "Reply is: ";
    std::cout.write(reply, reply_length);

    std::cout << "\n";
  }
  catch (std::exception& e)
  {
    std::cerr << "Exception: " << e.what() << "\n";
    exit(1);
  }
  }

  return 0;
}

服务器：

#include <cstdlib>
#include <iostream>
#include <boost/bind.hpp>
#include <boost/smart_ptr.hpp>
#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include <boost/regex.hpp> 
#include <boost/lexical_cast.hpp>
#include <string>

using boost::asio::ip::tcp;
const int max_length = 1000000;

std::string user_array[100];

typedef boost::shared_ptr<tcp::socket> socket_ptr;

unsigned short analyze_user_request(std::string& user_request, short unsigned* ID, std::string* request_value)
{
  // function returns:
  // 0: if user request is incorrect
  // 1: if user requests "PUT" operation
  // 2: if user requests "GET" operation
  // Furthermore, if request is correct, its value (i.e. ID number and/or string) is saved to short unsigned and string values passed by pointers. 

 boost::regex exp("^[[:space:]]*(PUT|GET)[[:space:]]+([[:digit:]]{1,2})(?:[[:space:]]+(.*))?$");

  boost::smatch what; 
  if (regex_match(user_request, what, exp, boost::match_extra)) 
   { 
     short unsigned id_number = boost::lexical_cast<short unsigned>(what[2]);

     if (what[1] == "PUT")
       {
         boost::regex exp1("^[a-zA-Z0-9]+$");
     std::string value = boost::lexical_cast<std::string>(what[3]);
     if (value.length() > 4095)
       return 0;
     if (!regex_match(value, exp1))
       return 0;
     else
       {
          *request_value = value;
          *ID = id_number;
         return 1;
           }
       }

     if (what[1] == "GET")
       {
     *ID = id_number;
         return 2;
       }

   }

  if (!regex_match(user_request, what, exp, boost::match_extra)) 
    return 0;
   }


void session(socket_ptr sock)
{
  try
  {
    for (;;)
    {
      char data[max_length];

      boost::system::error_code error;
      size_t length = sock->read_some(boost::asio::buffer(data), error);
      if (error == boost::asio::error::eof)
        break; // Connection closed cleanly by peer.
      else if (error)
        throw boost::system::system_error(error); // Some other error.
      // convert buffer data to string for further procession
      std::string line(boost::asio::buffers_begin(boost::asio::buffer(data)), boost::asio::buffers_begin(boost::asio::buffer(data)) + length);
      std::string reply; // will be "QK", "INVALID", or "OK <value>"
           unsigned short vID;

      unsigned short* ID = &vID;
      std::string vrequest_value;
      std::string* request_value = &vrequest_value;

      unsigned short output = analyze_user_request(line, ID, request_value);

      if (output == 1)
    {
    // PUT    
      reply = "OK";
      user_array[*ID] = *request_value;
    }

        else if (output == 2)
      {
        // GET
        reply = user_array[*ID];
        if (reply == "")
          reply = "EMPTY";

      }

    else
      reply = "INVALID";

            boost::system::error_code ignored_error;
            size_t ans_len=reply.length();
        boost::asio::write(*sock, boost::asio::buffer(reply));
    }
  }
  catch (std::exception& e)
  {
    std::cerr << "Exception in thread: " << e.what() << "\n";
  }
}

void server(boost::asio::io_service& io_service, short port)
{
  tcp::acceptor a(io_service, tcp::endpoint(tcp::v4(), port));
  for (;;)
  {
    socket_ptr sock(new tcp::socket(io_service));
    a.accept(*sock);
    boost::thread t(boost::bind(session, sock));
  }
}

int main(int argc, char* argv[])
{
  try
  {
    if (argc != 2)
    {
      std::cerr << "Usage: blocking_tcp_echo_server <port>\n";
      return 1;
    }

    boost::asio::io_service io_service;

    using namespace std; // For atoi.
    server(io_service, atoi(argv[1]));
  }
  catch (std::exception& e)
  {
    std::cerr << "Exception: " << e.what() << "\n";
  }

  return 0;
}

基本上，它是一个允许用户在服务器上存储数据的应用程序。用户可以使用PUT命令后跟ID号和数据值插入新数据，并使用GET命令后跟ID检索数据。用户请求在analyze_user_request函数中处理，随后写入或读取数组。问题是现在所有客户都在使用相同的全局。这意味着如果一个客户端在特定ID下保存某些内容，则所有其他客户端都可以读取它，因为它们访问相同的阵列。我想知道，如何将数组与不同的客户端关联起来，并在新客户端连接时创建一个新数组？

Answer 1

如何将会话数据封装到类中并为每个连接创建单独的会话对象。它大概看起来像这样：

会话类定义：

class Session {
public:
// logic from your session function 
void handleRequests(socket_ptr sock);

private:
// session data here
}

typedef boost::shared_ptr<Session> SessionPtr;

在accept循环中的“server”函数中创建新对象并将其传递给新线程：

SessionPtr newSession(new Session());

boost::thread acceptThread(boost::bind(&Session::handleRequests, newSession, sock));

很抱歉代码中可能出现错误，我离开发环境很远，无法测试。

对于分别处理多个连接的更优雅的解决方案，请参阅boost :: asio示例“聊天服务器”：http://www.boost.org/doc/libs/1_47_0/doc/html/boost_asio/example/chat/chat_server.cpp