Czy pętla „for” oparta na zakresach unieważnia wiele prostych algorytmów?

Rozwiązanie algorytmu:

std::generate(numbers.begin(), numbers.end(), rand);

Rozwiązanie for-loop oparte na zakresie:

for (int& x : numbers) x = rand();

Dlaczego miałbym chcieć używać bardziej szczegółowych std::generatepętli for opartych na zakresie w C ++ 11?

Pierwsza wersja

std::generate(numbers.begin(), numbers.end(), rand);

mówi nam, że chcesz wygenerować sekwencję wartości.

W drugiej wersji czytelnik będzie musiał sam to rozgryźć.

Oszczędność na pisaniu jest zwykle nieoptymalna, ponieważ najczęściej tracona jest na czasie czytania. Większość kodu jest czytana znacznie częściej niż jest wpisywana.

To, czy pętla for jest oparta na zakresie, czy nie, w ogóle nie robi różnicy, tylko upraszcza kod wewnątrz nawiasów. Algorytmy są wyraźniejsze, ponieważ pokazują zamiar .

Osobiście moje pierwsze czytanie:

std::generate(numbers.begin(), numbers.end(), rand);

to „przypisujemy wszystko w zakresie. Zakres to numbers. Przypisane wartości są losowe”.

Moja pierwsza lektura:

for (int& x : numbers) x = rand();

to „robimy coś dla wszystkiego w zakresie. Zakres wynosi numbers. To, co robimy, to przypisywanie losowej wartości”.

Te są cholernie podobne, ale nie identyczne. Jednym z możliwych powodów, dla których mógłbym chcieć sprowokować pierwsze czytanie, jest to, że uważam, że najważniejszym faktem dotyczącym tego kodu jest to, że przypisuje on zakres. Więc jest twoje "dlaczego miałbym chcieć ...". Używam, generateponieważ w C ++ std::generateoznacza „przypisanie zakresu”. Tak przy okazji std::copy, różnica między nimi polega na tym, z czego przypisujesz.

Istnieją jednak czynniki mylące. Pętle for oparte na zakresie mają z natury bardziej bezpośredni sposób wyrażania, że ​​jest to zakres numbers, niż robią to algorytmy oparte na iteratorach. Dlatego ludzie pracują na bibliotekach algorytmów opartych na zakresach: boost::range::generate(numbers, rand);wygląda lepiej niż std::generatewersja.

W przeciwieństwie do tego, int&w twoim zakresie pętli for jest zmarszczka. A co jeśli typ wartości zakresu nie jest int, to robimy tutaj coś irytująco subtelnego, co zależy od tego, czy można go zamienić na int&, podczas gdy generatekod zależy tylko od powrotu z randprzypisania do elementu. Nawet jeśli typ wartości to int, nadal mogę przestać myśleć o tym, czy tak jest, czy nie. Stąd auto, co odkłada myślenie o typach, dopóki nie zobaczę, co zostanie przypisane - auto &xmówię „weź odwołanie do elementu zakresu, dowolnego typu, który może mieć”. Powrót w C ++ 03, algorytmy (bo są szablony funkcyjne) były sposób ukryć dokładnych typów, teraz są sposób.

Myślę, że zawsze było tak, że najprostsze algorytmy miały tylko marginalną korzyść w porównaniu z równoważnymi pętlami. Oparte na zakresie pętle for poprawiają pętle (głównie poprzez usunięcie większości kotłów, chociaż jest ich trochę więcej). Tak więc marginesy są coraz ciaśniejsze i być może zmienisz zdanie w niektórych szczególnych przypadkach. Ale nadal istnieje różnica stylu.

Moim zdaniem, efektywny element STL 43: „Preferuj wywołania algorytmów od ręcznie pisanych pętli”. to nadal dobra rada.

Zwykle piszę funkcje opakowujące, aby pozbyć się begin()/ end()hell. Jeśli to zrobisz, Twój przykład będzie wyglądał następująco:

my_util::generate(numbers, rand);

Uważam, że pokonuje zakres oparty na pętli, zarówno pod względem komunikowania intencji, jak i czytelności.

Powiedziawszy to, muszę przyznać, że w C ++ 98 niektóre wywołania algorytmu STL dawały kod, którego nie można było wypowiedzieć, a następująca po tym fraza „Preferuj wywołania algorytmu zamiast ręcznie pisanych pętli” nie wydawała się dobrym pomysłem. Na szczęście lambdy to zmieniły.

Rozważmy następujący przykład z Herba Suttera: Lambdas, Lambdas Everywhere .

Zadanie: znajdź pierwszy element w v, czyli > xi < y.

Bez lambd:

auto i = find_if( v.begin(), v.end(),
bind( logical_and<bool>(),
bind(greater<int>(), _1, x),
bind(less<int>(), _1, y) ) );

Z lambdą

auto i=find_if( v.begin(), v.end(), [=](int i) { return i > x && i < y; } );

W moim zdaniem, instrukcja pętli, chociaż może zmniejszyć szczegółowość, brakuje readabitly:

for (int& x : numbers) x = rand();

Nie użyłbym tej pętli do zainicjowania ¹ zakresu określonego liczbami , bo kiedy na to patrzę, wydaje mi się, że iteruje po zakresie liczb, ale w rzeczywistości nie (w istocie), tj. Zamiast czytając z zakresu, pisze do zakresu.

Intencja jest znacznie wyraźniejsza, gdy używasz std::generate.

^{1. inicjalizacja w tym kontekście oznacza nadanie znaczącej wartości elementom kontenera.}

Są rzeczy, których nie można zrobić (po prostu) z pętlami opartymi na zakresie, ponieważ algorytmy przyjmują iteratory jako dane wejściowe. Na przykład z std::generate:

Wypełnij kontener do limit(wykluczone, limitto poprawny iterator włączony numbers) zmiennymi z jednej dystrybucji, a resztę zmiennymi z innej dystrybucji.

std::generate(numbers.begin(), limit, rand1);
std::generate(limit, numbers.end(), rand2);

Algorytmy oparte na iteratorze zapewniają lepszą kontrolę nad zakresem, na którym pracujesz.

W konkretnym przypadku std::generatezgadzam się z poprzednimi odpowiedziami dotyczącymi czytelności / intencji. std :: generowanie wydaje mi się bardziej przejrzystą wersją. Ale przyznaję, że to w pewnym sensie kwestia gustu.

To powiedziawszy, mam jeszcze jeden powód, aby nie wyrzucać algorytmu std :: - istnieją pewne algorytmy, które są wyspecjalizowane dla niektórych typów danych.

Najprostszym przykładem byłoby std::fill. Wersja ogólna jest implementowana jako pętla for w podanym zakresie i ta wersja będzie używana podczas tworzenia wystąpienia szablonu. Ale nie zawsze. Np. Jeśli podasz mu zakres, który jest std::vector<int>- często będzie faktycznie wywoływał memsetpod maską, dając znacznie szybszy i lepszy kod.

Więc próbuję zagrać tutaj kartę efektywności.

Twoja odręczna pętla może być tak szybka jak wersja std :: algorytm, ale prawie nie może być szybsza. Co więcej, algorytm std :: może być wyspecjalizowany dla określonych kontenerów i typów i odbywa się to w ramach czystego interfejsu STL.

Moja odpowiedź brzmiałaby może i nie. Jeśli mówimy o C ++ 11, to może (bardziej jak nie). Na przykład std::for_eachjest naprawdę denerwujące w użyciu nawet z lambdami:

std::for_each(c.begin(), c.end(), [&](ExactTypeOfContainedValue& x)
{
    // do stuff with x
});

Ale używanie oparte na zakresie dla jest o wiele lepsze:

for (auto& x : c)
{
    // do stuff with x
}

Z drugiej strony, jeśli mówimy o C ++ 1y, to argumentowałbym, że nie, algorytmy nie zostaną przestarzałe przez zakres oparty na. W komisji normalizacyjnej C ++ istnieje grupa analityczna, która pracuje nad propozycją dodania zakresów do C ++, a także trwają prace nad polimorficznymi lambdami. Zakresy wyeliminowałyby potrzebę używania pary iteratorów, a polimorficzna lambda pozwoliłaby ci nie określać dokładnego typu argumentu lambda. Oznacza to, że std::for_eachmożna go użyć w ten sposób (nie traktuj tego jako twardego faktu, tak po prostu wyglądają sny dzisiaj):

std::for_each(c.range(), [](x)
{
    // do stuff with x
});

Należy zauważyć, że algorytm wyraża to, co się robi, a nie jak.

Pętla oparta na zakresie obejmuje sposób wykonywania czynności: zacznij od pierwszego, zastosuj i przejdź do następnego elementu aż do końca. Nawet prosty algorytm mógłby zrobić coś inaczej (przynajmniej niektóre przeciążenia dla określonych kontenerów, nawet nie myśląc o okropnym wektorze), a przynajmniej sposób, w jaki to się robi, nie jest biznesem pisarza.

Dla mnie to duża różnica, hermetyzuj tyle, ile możesz, a to uzasadnia zdanie, kiedy możesz, użyj algorytmów.

Oparta na zakresie pętla for jest właśnie tym. Dopóki oczywiście nie zmieni się standard.

Algorytm to funkcja. Funkcja, która stawia pewne wymagania swoim parametrom. Wymagania są sformułowane w standardzie, aby umożliwić na przykład implementację, która wykorzystuje wszystkie dostępne wątki wykonawcze i przyspiesza automatycznie.