Comment puis-je éviter les boucles «for» avec une condition «if» à l'intérieur avec C ++?

Avec presque tout le code que j'écris, je suis souvent confronté à des problèmes de réduction d'ensembles sur des collections qui finissent par se retrouver avec des conditions naïves «si» à l'intérieur. Voici un exemple simple:

for(int i=0; i<myCollection.size(); i++)
{
     if (myCollection[i] == SOMETHING)
     {
           DoStuff();
     }
}

Avec les langages fonctionnels, je peux résoudre le problème en réduisant la collection à une autre collection (facilement) et ensuite effectuer toutes les opérations sur mon ensemble réduit. En pseudocode:

newCollection <- myCollection where <x=true
map DoStuff newCollection

Et dans d'autres variantes C, comme C #, je pourrais réduire avec une clause where comme

foreach (var x in myCollection.Where(c=> c == SOMETHING)) 
{
   DoStuff();
}

Ou mieux (du moins à mes yeux)

myCollection.Where(c=>c == Something).ToList().ForEach(d=> DoStuff(d));

Certes, je fais beaucoup de mélange de paradigmes et de style subjectif / basé sur l'opinion, mais je ne peux m'empêcher de penser qu'il me manque quelque chose de vraiment fondamental qui pourrait me permettre d'utiliser cette technique préférée avec C ++. Quelqu'un pourrait-il m'éclairer?

IMHO, il est plus simple et plus lisible d'utiliser une boucle for avec un if à l'intérieur. Cependant, si cela vous ennuie, vous pouvez en utiliser un for_each_ifcomme celui ci-dessous:

template<typename Iter, typename Pred, typename Op> 
void for_each_if(Iter first, Iter last, Pred p, Op op) {
  while(first != last) {
    if (p(*first)) op(*first);
    ++first;
  }
}

Cas d'utilisation:

std::vector<int> v {10, 2, 10, 3};
for_each_if(v.begin(), v.end(), [](int i){ return i > 5; }, [](int &i){ ++i; });

Démo en direct

Boost fournit des plages qui peuvent être utilisées avec des plages basées sur. Les plages ont l'avantage de ne pas copier la structure de données sous-jacente, elles fournissent simplement une «vue» (c'est-à-dire begin(), end()pour la plage et operator++(), operator==()pour l'itérateur). Cela pourrait vous intéresser: http://www.boost.org/libs/range/doc/html/range/reference/adaptors/reference/filtered.html

#include <boost/range/adaptor/filtered.hpp>
#include <iostream>
#include <vector>

struct is_even
{
    bool operator()( int x ) const { return x % 2 == 0; }
};

int main(int argc, const char* argv[])
{
    using namespace boost::adaptors;

    std::vector<int> myCollection{1,2,3,4,5,6,7,8,9};

    for( int i: myCollection | filtered( is_even() ) )
    {
        std::cout << i;
    }
}

Au lieu de créer un nouvel algorithme, comme le fait la réponse acceptée, vous pouvez utiliser un algorithme existant avec une fonction qui applique la condition:

std::for_each(first, last, [](auto&& x){ if (cond(x)) { ... } });

Ou si vous voulez vraiment un nouvel algorithme, au moins le réutiliser for_eachau lieu de dupliquer la logique d'itération:

template<typename Iter, typename Pred, typename Op> 
  void
  for_each_if(Iter first, Iter last, Pred p, Op op) {
    std::for_each(first, last, [&](auto& x) { if (p(x)) op(x); });
  }

L'idée d'éviter

for(...)
    if(...)

construit comme un anti-modèle est trop large.

Il est tout à fait correct de traiter plusieurs éléments qui correspondent à une certaine expression à l'intérieur d'une boucle, et le code ne peut pas être beaucoup plus clair que cela. Si le traitement devient trop volumineux pour tenir à l'écran, c'est une bonne raison d'utiliser un sous-programme, mais le conditionnel est toujours mieux placé à l'intérieur de la boucle, c'est-à-dire

for(...)
    if(...)
        do_process(...);

est largement préférable à

for(...)
    maybe_process(...);

Cela devient un anti-modèle lorsqu'un seul élément correspondra, car il serait alors plus clair de rechercher d'abord l'élément et d'effectuer le traitement en dehors de la boucle.

for(int i = 0; i < size; ++i)
    if(i == 5)

en est un exemple extrême et évident. Plus subtil, et donc plus courant, est un modèle d'usine comme

for(creator &c : creators)
    if(c.name == requested_name)
    {
        unique_ptr<object> obj = c.create_object();
        obj.owner = this;
        return std::move(obj);
    }

C'est difficile à lire, car il n'est pas évident que le code du corps ne sera exécuté qu'une seule fois. Dans ce cas, il serait préférable de séparer la recherche:

creator &lookup(string const &requested_name)
{
    for(creator &c : creators)
        if(c.name == requested_name)
            return c;
}

creator &c = lookup(requested_name);
unique_ptr obj = c.create_object();

Il y a toujours un ifdans un for, mais à partir du contexte, il devient clair ce qu'il fait, il n'est pas nécessaire de changer ce code à moins que la recherche ne change (par exemple en a map), et il est immédiatement clair que ce create_object()n'est appelé qu'une seule fois, car il est pas dans une boucle.

Voici une fonction rapide relativement minimale filter.

Il faut un prédicat. Il renvoie un objet fonction qui prend un itérable.

Il renvoie un itérable qui peut être utilisé dans une for(:)boucle.

template<class It>
struct range_t {
  It b, e;
  It begin() const { return b; }
  It end() const { return e; }
  bool empty() const { return begin()==end(); }
};
template<class It>
range_t<It> range( It b, It e ) { return {std::move(b), std::move(e)}; }

template<class It, class F>
struct filter_helper:range_t<It> {
  F f;
  void advance() {
    while(true) {
      (range_t<It>&)*this = range( std::next(this->begin()), this->end() );
      if (this->empty())
        return;
      if (f(*this->begin()))
        return;
    }
  }
  filter_helper(range_t<It> r, F fin):
    range_t<It>(r), f(std::move(fin))
  {
      while(true)
      {
          if (this->empty()) return;
          if (f(*this->begin())) return;
          (range_t<It>&)*this = range( std::next(this->begin()), this->end() );
      }
  }
};

template<class It, class F>
struct filter_psuedo_iterator {
  using iterator_category=std::input_iterator_tag;
  filter_helper<It, F>* helper = nullptr;
  bool m_is_end = true;
  bool is_end() const {
    return m_is_end || !helper || helper->empty();
  }

  void operator++() {
    helper->advance();
  }
  typename std::iterator_traits<It>::reference
  operator*() const {
    return *(helper->begin());
  }
  It base() const {
      if (!helper) return {};
      if (is_end()) return helper->end();
      return helper->begin();
  }
  friend bool operator==(filter_psuedo_iterator const& lhs, filter_psuedo_iterator const& rhs) {
    if (lhs.is_end() && rhs.is_end()) return true;
    if (lhs.is_end() || rhs.is_end()) return false;
    return lhs.helper->begin() == rhs.helper->begin();
  }
  friend bool operator!=(filter_psuedo_iterator const& lhs, filter_psuedo_iterator const& rhs) {
    return !(lhs==rhs);
  }
};
template<class It, class F>
struct filter_range:
  private filter_helper<It, F>,
  range_t<filter_psuedo_iterator<It, F>>
{
  using helper=filter_helper<It, F>;
  using range=range_t<filter_psuedo_iterator<It, F>>;

  using range::begin; using range::end; using range::empty;

  filter_range( range_t<It> r, F f ):
    helper{{r}, std::forward<F>(f)},
    range{ {this, false}, {this, true} }
  {}
};

template<class F>
auto filter( F&& f ) {
    return [f=std::forward<F>(f)](auto&& r)
    {
        using std::begin; using std::end;
        using iterator = decltype(begin(r));
        return filter_range<iterator, std::decay_t<decltype(f)>>{
            range(begin(r), end(r)), f
        };
    };
};

J'ai pris des raccourcis. Une vraie bibliothèque devrait faire de vrais itérateurs, pas lesfor(:) pseudo-façades qualifiantes que j'ai faites.

Au point d'utilisation, cela ressemble à ceci:

int main()
{
  std::vector<int> test = {1,2,3,4,5};
  for( auto i: filter([](auto x){return x%2;})( test ) )
    std::cout << i << '\n';
}

ce qui est plutôt sympa et imprime

1
3
5

Exemple en direct .

Il y a un ajout proposé à C ++ appelé Rangesv3 qui fait ce genre de chose et plus encore. boosta également des gammes de filtres / itérateurs disponibles. boost a également des aides qui rendent l'écriture de ce qui précède beaucoup plus courte.

Un style qui est assez utilisé pour être mentionné, mais qui n'a pas encore été mentionné, est:

for(int i=0; i<myCollection.size(); i++) {
  if (myCollection[i] != SOMETHING)
    continue;

  DoStuff();
}

Avantages:

• Ne modifie pas le niveau d'indentation DoStuff();lorsque la complexité des conditions augmente. Logiquement, DoStuff();devrait être au niveau supérieur de la forboucle, et c'est le cas.
• Indique immédiatement que la boucle itère sur les SOMETHINGs de la collection, sans exiger du lecteur qu'il vérifie qu'il n'y a rien après la fermeture }du ifbloc.
• Ne nécessite aucune bibliothèque ou macros ou fonctions d'assistance.

Désavantages:

• continue, Comme d' autres instructions de contrôle de flux, obtient mal utilisé dans les chemins qui mènent à coder en dur à suivre tant que certaines personnes sont opposés à toute utilisation d'entre eux: il y a un style valide de codage que certains suivi qui évite continue, qui évite breakautre que en a switch, cela évite returnautrement qu'à la fin d'une fonction.

for(auto const &x: myCollection) if(x == something) doStuff();

Cela ressemble beaucoup à une forcompréhension spécifique au C ++ . À toi?

Si DoStuff () dépendait d'une manière ou d'une autre de i dans le futur, je proposerais cette variante de masquage de bits sans branche garantie.

unsigned int times = 0;
const int kSize = sizeof(unsigned int)*8;
for(int i = 0; i < myCollection.size()/kSize; i++){
  unsigned int mask = 0;
  for (int j = 0; j<kSize; j++){
    mask |= (myCollection[i*kSize+j]==SOMETHING) << j;
  }
  times+=popcount(mask);
}

for(int i=0;i<times;i++)
   DoStuff();

Où popcount est une fonction faisant un comptage de population (nombre de bits de comptage = 1). Il y aura une certaine liberté pour mettre des contraintes plus avancées avec i et leurs voisins. Si cela n'est pas nécessaire, nous pouvons dénuder la boucle intérieure et refaire la boucle extérieure

for(int i = 0; i < myCollection.size(); i++)
  times += (myCollection[i]==SOMETHING);

suivi d'un

for(int i=0;i<times;i++)
   DoStuff();

De plus, si vous ne vous souciez pas de réorganiser la collection, std :: partition est bon marché.

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>

void DoStuff(int i)
{
    std::cout << i << '\n';
}

int main()
{
    using namespace std::placeholders;

    std::vector<int> v {1, 2, 5, 0, 9, 5, 5};
    const int SOMETHING = 5;

    std::for_each(v.begin(),
                  std::partition(v.begin(), v.end(),
                                 std::bind(std::equal_to<int> {}, _1, SOMETHING)), // some condition
                  DoStuff); // action
}

Je suis impressionné par la complexité des solutions ci-dessus. J'allais suggérer un simple #define foreach(a,b,c,d) for(a; b; c)if(d)mais il a quelques déficits évidents, par exemple, vous devez vous rappeler d'utiliser des virgules au lieu de points-virgules dans votre boucle, et vous ne pouvez pas utiliser l'opérateur virgule dans aou c.

#include <list>
#include <iostream>

using namespace std; 

#define foreach(a,b,c,d) for(a; b; c)if(d)

int main(){
  list<int> a;

  for(int i=0; i<10; i++)
    a.push_back(i);

  for(auto i=a.begin(); i!=a.end(); i++)
    if((*i)&1)
      cout << *i << ' ';
  cout << endl;

  foreach(auto i=a.begin(), i!=a.end(), i++, (*i)&1)
    cout << *i << ' ';
  cout << endl;

  return 0;
}

Une autre solution au cas où les i: s seraient importants. Celui-ci construit une liste qui remplit les index pour lesquels appeler doStuff (). Encore une fois, le point principal est d'éviter le branchement et de l'échanger contre des coûts arithmétiques pipelinables.

int buffer[someSafeSize];
int cnt = 0; // counter to keep track where we are in list.
for( int i = 0; i < container.size(); i++ ){
   int lDecision = (container[i] == SOMETHING);
   buffer[cnt] = lDecision*i + (1-lDecision)*buffer[cnt];
   cnt += lDecision;
}

for( int i=0; i<cnt; i++ )
   doStuff(buffer[i]); // now we could pass the index or a pointer as an argument.

La ligne «magique» est la ligne de chargement de la mémoire tampon qui calcule arithmétiquement s'il faut garder la valeur et rester en position ou compter la position et ajouter de la valeur. Nous échangeons donc une branche potentielle contre certaines logiques et arithmétiques et peut-être quelques hits de cache. Un scénario typique dans lequel cela serait utile est si doStuff () effectue une petite quantité de calculs pipelinables et que toute branche entre les appels pourrait interrompre ces pipelines.

Ensuite, faites une boucle sur le tampon et exécutez doStuff () jusqu'à ce que nous atteignions cnt. Cette fois, nous aurons le courant i stocké dans le tampon afin que nous puissions l'utiliser dans l'appel à doStuff () si nous en avons besoin.

On peut décrire votre modèle de code comme appliquant une fonction à un sous-ensemble d'une plage, ou en d'autres termes: l'appliquer au résultat de l'application d'un filtre à l'ensemble de la plage.

Ceci est réalisable de la manière la plus simple avec la bibliothèque range-v3 d'Eric Neibler ; même si c'est un peu une horreur, parce que vous voulez travailler avec des indices:

using namespace ranges;
auto mycollection_has_something = 
    [&](std::size_t i) { return myCollection[i] == SOMETHING };
auto filtered_view = 
    views::iota(std::size_t{0}, myCollection.size()) | 
    views::filter(mycollection_has_something);
for (auto i : filtered_view) { DoStuff(); }

Mais si vous êtes prêt à renoncer aux indices, vous obtiendrez:

auto is_something = [&SOMETHING](const decltype(SOMETHING)& x) { return x == SOMETHING };
auto filtered_collection = myCollection | views::filter(is_something);
for (const auto& x : filtered_collection) { DoStuff(); }

ce qui est plus agréable à mon humble avis.

PS - La bibliothèque de plages entre principalement dans le standard C ++ en C ++ 20.

Je mentionnerai juste Mike Acton, il dirait certainement:

Si vous devez le faire, vous avez un problème avec vos données. Triez vos données!