Comment un itérateur personnalisé peut-il simplifier l'itération via des conteneurs imbriqués ?

Aplatir des conteneurs imbriqués avec un itérateur personnalisé

Introduction

Itérer dans des conteneurs imbriqués peut souvent être une tâche fastidieuse et sujette aux erreurs. Pour simplifier ce processus, nous explorons le concept d'itérateur « d'aplatissement », qui nous permet de traiter une hiérarchie de conteneurs comme une séquence unique et aplatie.

Problème

Supposons que nous ayons un ensemble de vecteurs contenant des entiers, et nous voulons les parcourir comme une liste unique et contiguë. Un simple std::vecteur> pourrait ne pas suffire, car cela nécessite de naviguer séparément dans chaque vecteur imbriqué.

Custom flattening_iterator

Pour résoudre ce problème, nous pouvons créer un itérateur personnalisé, flattening_iterator, qui parcourt les conteneurs imbriqués de manière séquentielle. Cet itérateur :

• Prend en entrée un itérateur vers le conteneur le plus externe.
• Garde une trace de la position actuelle dans les conteneurs les plus externes et les plus internes.
• Avances l'itérateur en se déplaçant progressivement à travers les conteneurs imbriqués jusqu'à ce qu'il atteigne la fin ou rencontre un espace vide le plus interne conteneur.

Implémentation

Le flattening_iterator est implémenté comme suit :

template <typename OuterIterator>
class flattening_iterator
{
public:
    // ... iterator category, value type, etc.
    
    flattening_iterator(outer_iterator it) : outer_it_(it), outer_end_(it) { }
    flattening_iterator(outer_iterator it, outer_iterator end) : outer_it_(it), outer_end_(end) { advance_past_empty_inner_containers(); }
    
    // ... operators for comparison, dereferencing, and advancement
    
private:
    void advance_past_empty_inner_containers()
    {
        // Advance until we find a non-empty innermost container
        while (outer_it_ != outer_end_ && inner_it_ == outer_it_->end())
        {
            ++outer_it_;
            if (outer_it_ != outer_end_)
                inner_it_ = outer_it_->begin();
        }
    }
    
    outer_iterator outer_it_;
    outer_iterator outer_end_;
    inner_iterator inner_it_;
};

Utilisation

Nous pouvons utiliser le flattening_iterator pour aplatir les conteneurs imbriqués comme suit :

std::unordered_set<std::vector<int>> s;

s.insert({});
s.insert({1,2,3,4,5});
s.insert({6,7,8});
s.insert({9,10,11,12});

// Create a flattening iterator and iterate over the flattened set
for (auto it = flatten(s.begin()); it != s.end(); ++it)
{
    std::cout << *it << endl;
}

Cela affichera la liste aplatie des tous les entiers dans les conteneurs imbriqués :

1
2
3
4
5
6
7
8
9
10
11
12

Conclusion

Le flattening_iterator fournit un moyen simple et efficace de parcourir les conteneurs imbriqués en une seule séquence aplatie. Cela simplifie le code et élimine le besoin de structures de boucles imbriquées complexes ou de navigation manuelle dans la hiérarchie imbriquée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!