#include 
    
     #include 
     
      #include 
      
       #include 
       
        #include 
        
         #include 
         
          template
          
           class Node {public: Node() = default; ~Node() = default; Node(const Node
           
            & other) = delete; Node
            
             & operator=(const Node
             
              & other) = delete; Node(std::shared_ptr
              
                data_, std::unique_ptr
               
                
                 >&& next_ = nullptr) :data{ data_ }, next{ std::move(next) } { // } Node(Node
                 
                  && other) :data{ std::move(other.data) }, next{ std::move(other.next) } { //move-constructor. } Node
                  
                   & operator=(Node
                   
                    && other) { this->data = std::move(other.data); this->next = std::move(other.next); (other.next).reset(nullptr); return *this; } std::shared_ptr
                    
                      data{ nullptr }; std::unique_ptr
                     
                      
                       > next{ nullptr };};//先进先出(FIFO)template
                       
                        class Queue {public: //注意在默认构造函数的情况下: //创建了一个 empty的 node. 此时首尾都指向这个node. Queue() :head{ new Node
                        
                         {} }, tail{ head.get() } { //default constructor. } template
                         
                           Queue(Types&&... args); Queue(const Queue
                          
                           &) = delete; Queue
                           
                            & operator=(const Queue
                            
                             &) = delete; void push(const T& value); void push(T&& value); bool try_pop(T& value); std::shared_ptr
                             
                               try_pop(); bool wait_pop(T& value); std::shared_ptr
                              
                                wait_pop(); bool empty();private: //用于构造函数. template
                               
                                 void initialList(Ty&& value, Types&&... args); template
                                
                                  void initialList(Ty&& value); inline Node
                                 
                                  * getTail() { std::lock_guard
                                  
                                    lock(this->tailM); return (this->tail); } mutable std::mutex headM{}; mutable std::mutex tailM{}; mutable std::condition_variable conVar{}; std::unique_ptr
                                   
                                    
                                     > head{nullptr}; //队列头部. Node
                                     
                                      * tail{}; //队列尾部.};template
                                      
                                       template
                                       
                                        Queue
                                        
                                         ::Queue(Types&&... args) :head{ new Node
                                         
                                          {} }, tail{head.get()}{ std::lock(this->headM, this->tailM); std::lock_guard
                                          
                                           (this->headM, std::adopt_lock); std::lock_guard
                                           
                                            (this->tailM, std::adopt_lock); this->initialList(std::forward
                                            
                                             (args)...);}template
                                             
                                              template
                                              
                                               void Queue
                                               
                                                ::initialList(Ty&& value){ std::shared_ptr
                                                
                                                  nodeData{ std::make_shared
                                                 
                                                  (std::forward
                                                  
                                                   (value)) }; std::unique_ptr
                                                   
                                                    
                                                     > node{ new Node
                                                     
                                                      {} }; (this->tail)->data = nodeData; Node
                                                      
                                                       * newTail = node.get(); (this->tail)->next = std::move(node); (this->tail) = newTail; newTail = nullptr;}template
                                                       
                                                        template
                                                        
                                                         void Queue
                                                         
                                                          ::initialList(Ty&& value, Types&&... args){ //向queue中插入数据. this->initialList(std::forward
                                                          
                                                           (value)); this->initialList(std::forward
                                                           
                                                            (args)...);}//删除顶部元素并把被删除的值保存到value中.template
                                                            
                                                             bool Queue
                                                             
                                                              ::try_pop(T& value){ std::lock(this->headM, this->tailM); std::lock_guard
                                                              
                                                                lockOne{ this->headM, std::adopt_lock }; if ((this->head).get() == this->getTail()) { return false; } std::unique_ptr
                                                               
                                                                
                                                                 > oldHead{ std::move(this->head) }; value = std::move(*(oldHead->data)); this->head = std::move(oldHead->next); return true; return oldHead;}//删除顶部元素并返回被删除的值.template
                                                                 
                                                                  std::shared_ptr
                                                                  
                                                                    Queue
                                                                   
                                                                    ::try_pop(){ std::lock(this->headM); std::lock_guard
                                                                    
                                                                      lockOne(this->headM, std::adopt_lock); if ((this->head).get() == this->getTail()); std::unique_ptr
                                                                     
                                                                      
                                                                       > oldHead{ std::move(this->head) }; std::shared_ptr
                                                                       
                                                                         nodeData{ std::move(oldHead->data) }; this->head = std::move(oldHead->next); return nodeData;}template
                                                                        
                                                                         bool Queue
                                                                         
                                                                          ::empty(){ std::lock_guard
                                                                          
                                                                           (this->headM); if ((this->head).get() == (this->getTail())) { return true; } return false;}template
                                                                           
                                                                            bool Queue
                                                                            
                                                                             ::wait_pop(T& value){ std::shared_ptr
                                                                             
                                                                               ptrValue{ this->wait_pop() }; if (ptrValue == nullptr) { return false; } else { value = std::move(*ptrValue); return true; }}template
                                                                              
                                                                               void Queue
                                                                               
                                                                                ::push(const T& value){ std::shared_ptr
                                                                                
                                                                                  nodeData{ std::make_shared
                                                                                 
                                                                                  (value) }; std::unique_ptr
                                                                                  
                                                                                   
                                                                                    > node{ new Node
                                                                                    
                                                                                     {} }; { std::lock_guard
                                                                                     
                                                                                       lockGuard(this->tailM); (this->tail)->data = nodeData; Node
                                                                                      
                                                                                       * newTail = node.get(); (this->tail)->next = std::move(node); this->tail = newTail; newTail = nullptr; } (this->conVar).notify_one();}template
                                                                                       
                                                                                        void Queue
                                                                                        
                                                                                         ::push(T&& value){ std::shared_ptr
                                                                                         
                                                                                           nodeData{ std::make_shared
                                                                                          
                                                                                           (std::move(value)) }; std::unique_ptr
                                                                                           
                                                                                            
                                                                                             > node{ new Node
                                                                                             
                                                                                              {} }; { std::lock_guard
                                                                                              
                                                                                                lockGuard{ this->tailM }; (this->tail)->data = nodeData; Node
                                                                                               
                                                                                                * newTail = node.get(); (this->tail)->next = std::move(node); this->tail = newTail; newTail = nullptr; } (this->conVar).notify_one();}template
                                                                                                
                                                                                                 std::shared_ptr
                                                                                                 
                                                                                                   Queue
                                                                                                  
                                                                                                   ::wait_pop(){ std::unique_ptr
                                                                                                   
                                                                                                     uniqueLck(this->headM); (this->conVar).wait(this->headM, [] {return ((this->head.get() == this->getTal()) ? false, true); }); std::shared_ptr
                                                                                                    
                                                                                                      value{ std::move((this->head)->data) }; this->head = std::move((this->head)->next); return value;}int main(){ Queue
                                                                                                     
                                                                                                       que{ 1, 2, 3, 4 }; std::cout << que.empty() << std::endl; que.push(20); return 0;}