Rupture dans la boucle std :: for_each

Question

Lors de l'utilisation de l'algorithme std :: for_each, comment rompre quand une certaine condition est satisfaite?

Answer 1

Vous pouvez utiliser l'algorithme find_if, qui arrête et renvoie l'itérateur dans lequel la condition de prédicat appliquée à l'élément itéré retourne true. Votre prédicat doit donc être modifié pour renvoyer un booléen en tant que condition de continuation/pause.

Cependant, il s'agit d'un hack, vous pouvez donc utiliser les algorithmes.

Une autre méthode consiste à utiliser BOOST_FOREACH.

Answer 2

Vous ne pouvez pas le faire, sauf si vous lancez une exception, ce qui n'est pas une bonne idée car vous ne faites pas de contrôle de flux avec des exceptions.

Mise à jour: apparemment Boost a un for_each_if que peut aider, mais vous n'utilisez pas Boost.

Answer 3

Vous pouvez rompre for_each() en lançant une exception de votre foncteur. Cependant, ce n'est souvent pas une bonne idée, et il existe des alternatives.

Vous pouvez conserver l'état dans votre foncteur. Si vous détectez la condition 'break', placez simplement un drapeau dans votre foncteur et ensuite, pour chaque itération suivante, revenez simplement sans faire le truc de votre foncteur. Évidemment, cela n'arrêtera pas l'itération, ce qui pourrait être coûteux pour les grandes collections, mais cela empêchera au moins le travail d'être effectué.

Si votre collection est triée, vous pouvez trouver() l'élément que vous voulez casser, puis faites for_each de begin() à l'élément find() retourné. Pour finir, vous pouvez implémenter un for_each_if(). Cela n'arrêtera pas à nouveau l'itération mais n'évaluera pas votre foncteur qui fait le travail si le prédicat évalue à faux. Voici 2 saveurs de for_each_xxx(), une qui prend une valeur et effectue le travail si l'opérateur ==() évalue à vrai, et un autre qui prend deux foncteurs; celui qui effectue une comparaison ala find_if(), et l'autre qui effectue le travail si l'opérateur de comparaison évalue à vrai.

/* --- 

    For each 
    25.1.1 

     template< class InputIterator, class Function, class T> 
      Function for_each_equal(InputIterator first, InputIterator last, const T& value, Function f) 

     template< class InputIterator, class Function, class Predicate > 
      Function for_each_if(InputIterator first, InputIterator last, Predicate pred, Function f) 

    Requires: 

     T is of type EqualityComparable (20.1.1) 

    Effects:  

     Applies f to each dereferenced iterator i in the range [first, last) where one of the following conditions hold: 

      1: *i == value 
      2: pred(*i) != false 

    Returns:  

     f 

    Complexity: 

     At most last - first applications of f 

    --- */ 

    template< class InputIterator, class Function, class Predicate > 
    Function for_each_if(InputIterator first, 
         InputIterator last, 
         Predicate pred, 
         Function f) 
    { 
     for(; first != last; ++first) 
     { 
      if(pred(*first)) 
       f(*first); 
     } 
     return f; 
    }; 

    template< class InputIterator, class Function, class T> 
    Function for_each_equal(InputIterator first, 
          InputIterator last, 
          const T& value, 
          Function f) 
    { 
     for(; first != last; ++first) 
     { 
      if(*first == value) 
       f(*first); 
     } 
     return f; 
    }; 

Answer 4

Vous déclenchez une exception. Que ce soit ou non une bonne idée est une question de style, pace @Dan, mais peut-être plus d'un problème avec votre conception. for_each est destiné à une sorte de style de programmation fonctionnelle, qui suppose implicitement que votre fonction peut être appliquée uniformément à travers l'ensemble. Donc, si vous avez besoin de casser, cela pourrait être une condition inhabituelle, et donc digne d'une exception.

L'autre solution, et une solution plus "fonctionnelle", consiste à écrire votre fonction de sorte que si elle ne devrait pas avoir d'effet sur certaines applications, alors écrivez-la sans effet. Ainsi, par exemple, si vous avez une fonction de sommation, ajoutez 0 dans les cas où vous auriez "rompu".

Answer 5

Si vous voulez faire des actions alors que la condition n'est pas satisfaite, peut-être vous avez besoin de changer l'algorithme sur quelque chose comme std::find_if?

Answer 6

Comme déjà montré par d'autres, il est seulement réalisable avec des solutions de contournement que IMHO obscurcir le code. Donc, mes suggestions sont de changer le for_each dans une boucle for normale. Cela le rendra plus visible pour les autres que vous utilisez pause (et peut-être même continuer).

Answer 7

Vous pouvez utiliser std :: any_of (ou std :: all_of ou std :: none_of), par exemple. comme ceci:

std::vector<int> a; 
// ...  
std::all_of(a.begin(), a.end(), [&](int val) { 
    // return false if you want to break, true otherwise 
    }); 

Cependant, cette solution est inutile (les valeurs de retour ne sont pas vraiment utilisés pour quoi que ce soit), et vous êtes mieux d'écrire vous propre boucle.