Jaka jest zaleta używania odwołań do przekazywania w pętlach opartych na zakresach?

const auto&wystarczy, jeśli chcę wykonywać operacje tylko do odczytu. Jednak wpadłem na

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

ostatnio kilka razy. To sprawia, że ​​zastanawiam się:

Czy to możliwe, że w niektórych niejasnych przypadkach narożnych korzystanie z odniesień do przekazywania przynosi pewne korzyści w zakresie wydajności w porównaniu z auto&lub const auto&?

( shared_ptrjest podejrzany o niejasne sprawy narożne)

Zaktualizuj Dwa przykłady, które znalazłem w moich ulubionych:

Czy są jakieś wady używania odwołania do const podczas iteracji po typach podstawowych?
Czy mogę łatwo iterować wartości mapy za pomocą pętli for opartej na zakresie?

Skoncentruj się na pytaniu: dlaczego miałbym chcieć używać auto && w oparciu o zakres dla pętli?

Jedyną zaletą, jaką widzę, jest to, że iterator sekwencji zwraca referencję proxy i musisz operować na tym odwołaniu w sposób inny niż stały. Weźmy na przykład pod uwagę:

#include <vector>

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

To się nie kompiluje, ponieważ rvalue vector<bool>::referencezwrócony z iteratornie będzie wiązał się z odwołaniem do wartości l-wartości innej niż stała. Ale to zadziała:

#include <vector>

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

Biorąc to wszystko pod uwagę, nie kodowałbym w ten sposób, gdybyś nie wiedział, że musisz spełnić taki przypadek użycia. Tzn. Nie zrobiłbym tego bezinteresownie, ponieważ powoduje to , że ludzie zastanawiają się, co zamierzasz. A gdybym to zrobił, nie zaszkodziłoby dodać komentarz wyjaśniający, dlaczego:

#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;
}

Edytować

Ten mój ostatni przypadek naprawdę powinien być szablonem, który ma sens. Jeśli wiesz, że pętla zawsze obsługuje odwołanie do serwera proxy, autodziałałaby równie dobrze auto&&. Ale kiedy pętla czasami obsługiwała odwołania niebędące proxy, a czasami odwołania proxy, myślę, że auto&&byłoby to preferowane rozwiązanie.

Korzystanie auto&&lub odniesienia uniwersalne z zakresu oparte for-loop ma tę zaletę, że oddaje to, co dostajesz. W przypadku większości typów iteratorów prawdopodobnie otrzymasz a T&lub a T const&dla jakiegoś typu T. Ciekawym przypadkiem jest sytuacja, w której dereferencja iteratora daje tymczasowe: C ++ 2011 ma łagodne wymagania, a iteratory niekoniecznie są wymagane do uzyskania lwartości. Użycie odwołań uniwersalnych odpowiada przekazywaniu argumentów w 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;
}

Przedmiotem funkcji fmożna leczyć T&, T const&lub Tw inny sposób. Dlaczego fortreść pętli opartej na zakresie miałaby być inna? Oczywiście, aby faktycznie skorzystać z wywnioskowania typu przy użyciu uniwersalnych odwołań, musisz je odpowiednio przekazać:

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

Oczywiście użycie std::forward()oznacza, że ​​akceptujesz wszystkie zwrócone wartości, z których chcesz przenieść. Czy takie obiekty mają sens w kodzie innym niż szablon, którego nie wiem (jeszcze?). Mogę sobie wyobrazić, że użycie uniwersalnych odwołań może dostarczyć kompilatorowi więcej informacji, aby wykonać właściwą rzecz. W kodzie opartym na szablonach nie podejmuje żadnych decyzji dotyczących tego, co powinno się stać z obiektami.

Praktycznie zawsze używam auto&&. Po co dać się ugryźć przez skrajny przypadek, kiedy nie musisz? Jest też krótszy do pisania i po prostu uważam, że jest bardziej ... przejrzysty. Kiedy używasz auto&& x, wiesz, że xtak jest za *itkażdym razem.