Quel est l'avantage de l'utilisation de la redirection de références dans la gamme à base de boucles for?

const auto& suffirait si je veux effectuer des opérations en lecture seule. Cependant, j'ai heurté

for (auto&& e : v)  //v is non-const

une couple de fois récemment. Cela me fait me demander:

Est-il possible que dans quelque coin obscur cas, il est certain avantage de performance dans l'utilisation de la redirection de références, par rapport à auto& ou const auto&?

(shared_ptr est un suspect pour coin obscur cas)

Mise à jour
Deux exemples que j'ai trouvé dans mes favoris:

Un désavantage de l'utilisation de const référence lors de l'itération sur les types de base?

Je peut facilement effectuer une itération sur les valeurs d'une carte à l'aide d'une gamme à base de boucle?

Merci de se concentrer sur la question: pourquoi voudrais-je utiliser l'auto&& dans la gamme à base de boucles for?

  • Avez-vous vraiment le voir "souvent"?
  • Je ne suis pas sûr qu'il y a assez contexte de votre question pour moi de mesurer le degré de "fou", il est où vous êtes le voir.
  • Longue histoire courte: pourquoi voudrais-je utiliser auto&& de gamme à base de boucles for?
InformationsquelleAutor Ali | 2012-10-29
  1. 85

    Le seul avantage que je peux voir, c'est quand la séquence renvoie un itérateur proxy de référence et vous avez besoin pour fonctionner sur cette référence non const façon. Par exemple, considérons:

    #include <vector>

int main()
{
    std::vector<bool> v(10);
    for (auto& e : v)
        e = true;
}

    Cela ne veut pas compiler, car rvalue vector<bool>::reference retourné à partir de la iterator ne se lient pas à un non-const lvalue de référence. Mais cela va fonctionner:

    #include <vector>

int main()
{
    std::vector<bool> v(10);
    for (auto&& e : v)
        e = true;
}

    Tout cela étant dit, je n'aurais pas le code de cette façon, à moins que vous saviez que vous nécessaire pour satisfaire un tel cas d'utilisation. I. e. Je ne voudrais pas le faire gratuitement car il ne amener les gens à se demander ce que vous faites. Et si je l'ai fait faire, il ne serait pas mal d'ajouter un commentaire pourquoi:

    #include <vector>

int main()
{
    std::vector<bool> v(10);
    //using auto&& so that I can handle the rvalue reference
    //  returned for the vector<bool> case
    for (auto&& e : v)
        e = true;
}

    Modifier

    Ce dernier cas de la mine devrait vraiment être un modèle pour le sens. Si vous connaissez la boucle est toujours la manipulation d'un proxy de référence, puis auto fonctionnerait ainsi que auto&&. Mais lorsque la boucle a été parfois traiter les non-proxy références et parfois proxy-références, alors je pense que auto&& allait devenir la solution de choix.

    • D'autre part, il n'y a pas explicite désavantage, est-il? (Hormis susceptibles de créer la confusion de personnes, dont je ne pense pas beaucoup la peine de mentionner, personnellement).
    • C'est un point intéressant. Sans doute il n'y a pas moyen d'encourager la plage-for à préférer T::const_iterator? Je crois begin() et end() sont utilisés. Semble ressembler un peu à une surveillance, à l'exception que vous pouvez utiliser rvalue refs. Alors oui c'est peut-être la réponse.
    • Un autre terme pour l'écriture de code inutilement confond personnes est: l'écriture confuscated code. Il est préférable de faire votre code aussi simple que possible, mais pas plus. Cela aidera à garder le nombre de bogues vers le bas. Cela étant dit, comme && devient plus familier, alors peut-être 5 ans à partir de maintenant, les gens s'attendent à une auto&& idiome (en supposant qu'il ne fait pas de mal). Je ne sais pas si ça va se produire ou non. Mais simple est dans l'œil de celui qui regarde, et si vous écrivez pour plus que juste vous-même, prenez vos lecteurs en compte.
    • Je préfère const auto& quand je veux le compilateur pour m'aider à vérifier que je n'ai pas modifier accidentellement les éléments dans la séquence.
    • T> T const& as_const(T const& v){ return v; } et for(auto& e : as_const(v)) ....
    • Ah, mais const T::iterator n'est pas T::const_iterator, droit? par exemple est-ce que réellement le travail dans ce cas? Je suppose que c'est une autre question. Ressemble à "oui", mais je ne sais pas pourquoi.
    • Personnellement, j'aime utiliser auto&& génériques de code où j'ai besoin de modifier les éléments de la séquence. Si je ne le fais pas, je vais juste coller à auto const&.
    • C'est grâce à des passionnés comme vous, constamment expérimenter et de faire pression pour de meilleures façons de faire les choses, que le C++ continue d'évoluer. Je vous remercie. 🙂
    • de déléguer à l'appel de membre begin, qui est surchargé sur const.
    • Pourquoi n'est-ce pas auto&& e une rvalue et n'est donc pas possible d'être affecté? il est littéralement apparaissant sur le côté gauche ici..
    • 7e paragraphe de cet article: open-std.org/jtc1/sc22/wg21/docs/papers/2002/... "Même si nommée références rvalue ..."
    • merci, je justed regardé une présentation de Scott Meyers à ce sujet et il a été très utile, avec ce et de réaliser que j'avais mal compris rvalue vs référence rvalue. Je ne comprends pas pourquoi des références universelles n'étaient pas réellement d'une part, une partie de la série avec un nouveau jeton comme &&&?
    • C'était un appel de jugement faite à l'époque: Tuer deux oiseaux avec une pierre.
    • Le haut exemple compile très bien dans VS2015u2.
    • Avec des avertissements sur, il dit qu'il utilise une extension pour le compiler. Il est dangereux d'extension dont l'utilisation principale est la compatibilité avec des pré-C++98 du code.
    • tenez-vous bien, ce serait que l'extension de réellement faire? cheat auto& en auto&& derrière notre dos?
    • Je ne sais pas vraiment. Presque tout ce que je sais à propos de VS, j'ai glaner ici: webcompiler.cloudapp.net
    • "[...] alors peut-être 5 ans à partir de maintenant, les gens s'attendent à une auto&& idiome [ ... ]", 7 ans plus tard pour(auto&& x : y) est encore très confus, et certainement pas attendue d'un idiome.

    InformationsquelleAutor Howard Hinnant
  2. 25

    À l'aide de auto&& ou des références universelles avec une gamme à base de for-boucle a l'avantage que vous rend ce que vous obtenez. Pour la plupart des types d'itérateurs vous aurez probablement obtenir un T& ou un T const& pour certains type de T. Le cas intéressant est celui où le déréférencement d'un itérateur, les rendements temporaire: C++ 2011 suis détendue, les exigences et les itérateurs ne sont pas forcément nécessaires pour obtenir une lvalue. L'utilisation de références universelles correspond à l'argument de transfert std::for_each():

    template <typename InIt, typename F>
F std::for_each(InIt it, InIt end, F f) {
    for (; it != end; ++it) {
        f(*it); //<---------------------- here
    }
    return f;
}

    La fonction de l'objet f peut traiter T&, T const&, et T différemment. Pourquoi le corps d'une gamme à base de for-boucle serait-elle différente? Bien sûr, à prendre avantage d'avoir déduit le type à l'aide des références universelles vous auriez besoin de les transmettre en conséquence:

    for (auto&& x: range) {
    f(std::forward<decltype(x)>(x));
}

    Bien sûr, à l'aide de std::forward() signifie que vous acceptez toutes les valeurs renvoyées pour être déplacé d'. Si les objets comme cela fait beaucoup de sens dans le non-modèle de code je ne sais pas (encore?). Je peux imaginer que l'utilisation de références universelles peuvent offrir plus d'informations au compilateur de faire la bonne Chose. Dans basées sur des modèles de code, il reste en dehors de toute prise de décision sur ce qui doit se passer avec les objets.

    InformationsquelleAutor Dietmar Kühl
  3. 7

    J'utilise pratiquement toujours auto&&. Pourquoi se faire mordre par une arête cas lorsque vous n'avez pas à? C'est plus court à taper trop, et je ne le trouve plus... transparent. Lorsque vous utilisez auto&& x, alors vous savez que x est exactement *it, à chaque fois.

    • Mon problème est que votre abandon const-ness avec auto&& si const auto& suffit. La question demande le cas du coin où je peux obtenir mordu. Quels sont les cas du coin qui n'ont pas été mentionnés par Dietmar ou Howard encore?
    • Voici une façon de se faire mordre si vous ne utiliser auto&&. Si le type de capture doivent être déplacés dans le corps de la boucle (par exemple), et est modifié à une date ultérieure si elle correspond à un const& type, votre code silencieusement continuer à fonctionner, mais vos mouvements seront venir des copies. Ce code va être très trompeur. Si, toutefois, vous spécifier explicitement le type comme une r-valeur de référence, celui qui a changé le type de conteneur obtiendrez une erreur de compilation car vous avez vraiment, vraiment envie de ces objets déplacés, et non pas copié...
    • Je viens de tomber sur ceci: comment puis-je appliquer une référence rvalue sans spécifier explicitement le type? Quelque chose comme for (std::decay_t<decltype(*v.begin())>&& e: v)? Je pense qu'il y a une meilleure façon ...
    • Cela dépend de ce que ne connaître le type. Comme mentionné ci-dessus, auto&& donnera un "univers de référence", donc rien d'autre que vous obtiendrez un plus spécifique. Si v est supposé être un vector, vous pourriez faire decltype(v)::value_type&&, qui est ce que je suppose que tu voulais en prenant le résultat de operator* sur un itérateur de type. Vous pouvez également faire de decltype(begin(v))::value_type&& pour vérifier l'itérateur de types plutôt que sur le contenant. Si nous avons si peu de perspicacité dans le type, bien, nous pourrions envisager un peu plus clair pour juste aller avec auto&&...
    InformationsquelleAutor Puppy