Question

我为不明确的标题表示歉意，但我将在此处尝试进一步阐述：

我有一个包含（其中包括）控件和TCP服务器类的应用程序。 TCP和控件类之间的通信是通过以下实现完成的：

#include <boost/signals2.hpp>                                                                        

// T - Observable object type                                                                        
// S - Function signature                                                                            
template <class T, typename S> class observer {                                                      
        using F = std::function<S>;                                                                  

      public:                                                                                        
        void register_notifier(T &obj, F f)                                                          
        {                                                                                            
                connection_ = obj.connect_notifier(std::forward<F>(f));                              
        }                                                                                            

      protected:                                                                                     
        boost::signals2::scoped_connection connection_;                                              
};                                                                                                   

// S - Function signature                                                                            
template <typename S> class observable {                                                             
      public:                                                                                        
        boost::signals2::scoped_connection connect_notifier(std::function<S> f)                      
        {                                                                                            
                return notify.connect(std::move(f));                                                 
        }                                                                                            

      protected:                                                                                     
        boost::signals2::signal<S> notify;                                                           
};

其中TCP服务器类是可观察的，而控件类是观察者。

TCP服务器在与控件类不同的线程上运行，并使用boost :: asio :: async_read。每当收到消息时，服务器对象都会通过“ notify”成员发送通知，从而触发在控件类中注册的回调，然后等待读取下一条消息。

问题是我需要以某种方式安全有效地存储当前存储在TCP服务器缓冲区中的数据，并将其传递给控制类，然后再由下一条消息覆盖。

即：

inline void ctl::tcp::server::handle_data_read(/* ... */)                                  
{                                                                                                    
        if (!error) {                                                                                 
                /* .... */
                notify(/* ? */); // Using a pointer to the buffer
                                 // would obviously fail as it
                                 // is overridden in the next read                    
        }
        /* .... */                                                                                            
}

到目前为止，这些是我对解决方案的想法：

分配堆内存并使用传递指针 unique_ptr，但我不确定boost.signals2是否可移动。
使用无序映射（对象之间共享），用于将整数索引映射到对象的unique_ptr 数据类型（std::unordered_map<int, std::unique_ptr<data_type>>），然后只传递元素的索引，并将其“弹出”到控件中类回调，但感觉像是过大了。

我真正在寻找的是一个简单有效的解决方案，可以在线程之间传递每个消息的TCP缓冲区内容。

注意：如果完全错误，我也欢迎重新设计对象之间的通信方法的建议。

使用boost.signals2在线程之间传递数据

0 个答案: