STL comme conteneur typedef raccourci?

Question

Un modèle commun avec des conteneurs STL est la suivante:

map<Key, Value> map; 
for(map<Key, Value>::iterator iter = map.begin(); iter != map.end(); ++iter) 
{ 
    ... 
} 

Ainsi, afin d'éviter d'écrire la déclaration des paramètres du modèle, nous pouvons le faire quelque part:

typedef map<Key, Value> TNiceNameForAMap; 

Mais si cette carte est utilisée uniquement dans une seule fonction ou pour une seule itération, c'est un surcoût ennuyeux.

Y a-t-il un moyen de contourner ce typedef?

Answer 1

Vous ne savez pas exactement ce que vous entendez par "frais généraux". Si cela simplifie la façon dont vous écrivez votre code, utilisez-le, sinon tenez-vous en à la main.

S'il n'est utilisé que dans une portée restreinte, placez typedef dans la même portée. Ensuite, il n'a pas besoin d'être publié, ou documenté, ou apparaître sur les diagrammes UML. Par exemple (et je ne prétends pas que ce soit le meilleur code jamais à d'autres égards):

int totalSize() { 
    typedef std::map<Key, Value> DeDuplicator; 
    DeDuplicator everything; 

    // Run around the universe finding everything. If we encounter a key 
    // more than once it's only added once. 

    // now compute the total 
    int total = 0; 
    for(DeDuplicator::iterator i = everything.begin(); i <= everything.end(); ++i) { 
     total += i->second.size(); // yeah, yeah, overflow. Whatever. 
    } 
    return total; 
} 

La combinaison avec la suggestion de Ferruccio (si vous utilisez boost), la boucle devient:

BOOST_FOREACH(DeDuplicator::pair p, everything) { 
    total += p.second.size(); 
} 

Et en combinant avec la suggestion de bk1e (si vous utilisez C++ 0x ou avec des fonctionnalités de celui-ci), et en supposant que BOOST_FOREACH interagit avec auto de la manière dont je pense qu'il devrait basé sur le fait qu'il peut normalement gérer les conversions implicites types:

std::map<Key, Value> everything; 
// snipped code to run around... 
int total = 0; 
BOOST_FOREACH(auto p, everything) { 
    total += p.second.size(); 
} 

Pas mal.

Answer 2

Vous pouvez utiliser Boost.Foreach

Answer 3

Personnellement, je pense MyMap :: iterator est plus lisible que carte < int, string > :: iterator ou même std :: carte < int, std :: string > :: itérateur donc je fais toujours le typedef. Le seul surcoût est une ligne de code. Une fois le code compilé, il n'y aura pas de différence de taille ou de vitesse de l'exécutable. C'est juste une question de lisibilité.

Answer 4

Une future version de la norme C++ (connu sous le nom C++0x) présentera un new use for the auto keyword, vous permettant d'écrire quelque chose comme ce qui suit:

map<Key, Value> map; 
for(auto iter = map.begin(); iter != map.end(); ++iter) 
{ 
    ... 
} 

Answer 5

Si l'typedef est locale à une seule fonction, il ne même besoin d'être un joli nom. Utilisez X ou MAP, comme dans un modèle.

Answer 6

C++ 0x offrira également une boucle à base de distance, ce qui est similaire à itératif pour la boucle dans d'autres langages.

Malheureusement, GCC n'implémente pas encore la plage de valeurs pour (mais implémentent automatiquement).

Editer: En attendant, pensez aussi à typer l'itérateur.Il ne contourne pas le typedef à usage unique (sauf si vous mettez cela dans un en-tête, ce qui est toujours une option), mais il raccourcit le code résultant de one :: iterator.

Answer 7

Au cours des dernières années, j'ai vraiment essayé de ne plus utiliser de boucles écrites manuellement plutôt que d'utiliser les algorithmes STL. Votre code ci-dessus peut être modifié à:

struct DoLoopBody { 
    template <typename ValueType> 
    inline void operator()(ValueType v) const { 
    // ... 
    } 
}; 

std::for_each (map.begin(), map.end(), DoLoopBody()); 

Malheureusement, la DoLoopBody de classe ne peut pas être une classe locale, qui est souvent citée comme un inconvénient. Cependant, je vois cela comme un avantage en ce que le corps de la boucle peut maintenant être testé unitairement de manière isolée.