如何重構此while循環以擺脫「繼續」？

Question

我有一個處理元素隊列的while (!Queue.empty())循環。有一系列從最高優先級到最低優先級的模式匹配器。匹配模式時，相應的元素將從隊列中移除，並從頂部重新開始匹配（以便優先級最高的匹配器有機會首先執行）。

所以現在它看起來像這樣（簡化版本）：

while (!Queue.empty()) 
{ 
    auto & Element = *Queue.begin(); 

    if (MatchesPatternA(Element)) { // Highest priority, since it's first 
     // Act on it 
     // Remove Element from queue 
     continue; 
    } 
    if (MatchesPatternB(Element)) { 
     // Act on it 
     // Remove Element from queue 
     continue; 
    } 
    if (MatchesPatternC(Element)) { // Lowest priority, since it's last 
     // Act on it 
     // Remove Element from queue 
     continue; 
    } 

    // If we got this far, that means no pattern was matched, so 
    // Remove Element from queue 
} 

這工作，但我想重構這個循環中的一些方法，以消除使用關鍵字continue的。

爲什麼？因爲如果我想外部匹配一個外部函數的模式，它顯然會中斷。例如。

void ExternalMatching(...) 
{ 
    if (MatchesPatternB(Element)) { 
     // Act on it 
     // Remove Element from queue 
     continue;  // This won't work here 
    } 
} 

while (!Queue.empty()) 
{ 
    auto & Element = *Queue.begin(); 

    if (MatchesPatternA(Element)) { 
     // Act on it 
     // Remove Element from queue 
     continue; 
    } 
    ExternalMatching(...); 
    if (MatchesPatternC(Element)) { 
     // Act on it 
     // Remove Element from queue 
     continue; 
    } 

    // If we got this far, that means no pattern was matched, so 
    // Remove Element from queue 
} 

我不希望有寫重複的，如果像if (ExternalMatching(...)) { ... continue; }聲明，我寧願找到表達這種邏輯更清潔的方式。

這種簡化的例子可能使它看起來像一個好主意，使模式匹配更普遍的，而不是不同MatchesPatternA，MatchesPatternB，MatchesPatternC等功能。但在我的情況下，模式非常複雜，我還沒有準備好推廣它們。所以我想保留那部分，分開功能。

任何優雅的想法？謝謝！

Answer 1

如果您有權訪問C++ 11，我想推薦其他解決方案。基礎我創建了一個可以在運行時調整的處理程序和操作的容器。根據您的要求，它可能是您的設計的專家或認同。這是它：

#include <functional> 

typedef std::pair<std::function<bool(const ElementType &)>, 
        std::function<void(ElementType &)> > HandlerData; 
typedef std::vector<HandlerData> HandlerList; 


HandlerList get_handlers() 
{ 
    HandlerList handlers; 
    handlers.emplace_back([](const ElementType &el){ return MatchesPatternA(el); }, 
         [](ElementType &el){ /* Action */ }); 
    handlers.emplace_back([](const ElementType &el){ return MatchesPatternB(el); }, 
         [](ElementType &el){ /* Action */ }); 
    handlers.emplace_back([](const ElementType &el){ return MatchesPatternC(el); }, 
         [](ElementType &el){ /* Action */ }); 
    return handlers; 
} 


int main() 
{ 
    auto handlers = get_handlers(); 
    while(!Queue.empty()) { 
    auto &Element = *Queue.begin(); 

    for(auto &h : handlers) { 
     // check if handler matches the element 
     if(h.first(Element)) { 
     // act on element 
     h.second(Element); 
     break; 
     } 
    } 

    // remove element 
    Queue.pop_front(); 
    } 
} 

Answer 2

考慮的接口：

class IMatchPattern 
{ 
public: 
    virtual bool MatchesPattern(const Element& e) = 0; 
}; 

然後就可以實現組織IMatchPattern對象的容器，以允許迭代訪問每個模式匹配方法。

Answer 3

我會建議使用，做的模式匹配（但對結果不作爲）一個函數，然後一組作用於不同的選項功能：

enum EventType { 
    A, B, C //, D, ... 
}; 

while (!queue.empty()) { 
    auto & event = queue.front(); 
    EventType e = eventType(event); // Internally does MatchesPattern* 
            // and returns the match 
    switch (e) { 
    case A: 
     processA(event); 
     break; 
    case B: 
     processB(event); 

這樣，你清楚地分開從處理匹配，循環只是一個簡單的調度程序

Answer 4

您可以更改您的ExternalMatching返回bool，表示處理已完成。這樣，來電者將能夠繼續評估是否有必要：

bool ExternalMatching(...) 
{ 
    if (MatchesPatternB(Element) { 
     // Act on it 
     // Remove Element from queue 
     return true; 
    } 
    return false; 
} 

現在你可以這樣調用：

if (ExternalMatchin1(...)) continue; 
if (ExternalMatchin2(...)) continue; 
... 
if (ExternalMatchingN(...)) continue; 

Answer 5

我想建議，將採取元素，並創建一個工廠函數一個合適的處理程序並將接口指針返回給處理程序。

while (!Queue.empty()) 
{ 
    auto & Element = *Queue.begin(); 
    // get the appropriate handler object pointer e.g. 
    IPatternHandler *handler = Factory.GetHandler(Element); 
    handler->handle(); 
    // clean up handler appropriately 
} 

Answer 6

好吧，我結束了重寫循環更類似於這個。

巨大的感謝和信用去Yuushi，dasblinkenlight，大衛羅德里格斯的幫助;這個答案是基於他們的答案的組合。

bool ExternalMatching(...) 
{ 
    bool Match; 

    if ((Match = MatchesPatternX(Element))) { 
     // Act on it 
    } else if ((Match = MatchesPatternY(Element))) { 
     // Act on it 
    } 

    return Match; 
} 

while (!Queue.empty()) 
{ 
    auto & Element = Queue.front(); 

    if (MatchesPatternA(Element)) { // Highest priority, since it's first 
     // Act on it 
    } else if (MatchesPatternB(Element)) { 
     // Act on it 
    } else if (ExternalMatching(...)) { 
    } else if (MatchesPatternC(Element)) { // Lowest priority, since it's last 
     // Act on it 
    } 

    // Remove Element from queue 
} 

現在，我知道有進一步提升的空間，看到Mateusz Pusz和邁克爾噓的答案。但是，這足以回答我原來的問題，現在就可以做到。我會考慮在將來改進它。

如果你好奇，想看看真正的代碼（非精簡版），在這裏看到：

https://github.com/shurcooL/Conception/blob/38f731ccc199d5391f46d8fce3cf9a9092f38c65/src/App.cpp#L592

再次感謝大家！