Veraltet die bereichsbasierte 'for'-Schleife viele einfache Algorithmen?

Algorithmuslösung:

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

Bereichsbasierte For-Loop-Lösung:

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

Warum sollte ich std::generatein C ++ 11 die ausführlicheren for-range-basierten for-Schleifen verwenden wollen?

Die erste Version

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

teilt uns mit, dass Sie eine Folge von Werten generieren möchten.

In der zweiten Version muss der Leser das selbst herausfinden.

Das Speichern beim Tippen ist normalerweise nicht optimal, da es meistens in der Lesezeit verloren geht. Der meiste Code wird viel mehr gelesen als eingegeben.

Ob die for-Schleife bereichsbasiert ist oder nicht, macht überhaupt keinen Unterschied, sie vereinfacht nur den Code in der Klammer. Algorithmen sind klarer, da sie die Absicht zeigen .

Persönlich meine erste Lektüre von:

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

ist "Wir weisen alles in einem Bereich zu. Der Bereich ist numbers weisen . Die zugewiesenen Werte sind zufällig".

Meine erste Lektüre von:

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

ist "wir machen etwas mit allem in einem Bereich. Der Bereich ist numbers . Wir weisen einen zufälligen Wert zu."

Die sind verdammt ähnlich, aber nicht identisch. Ein plausibler Grund, warum ich die erste Lesung provozieren möchte, ist, dass ich denke, dass die wichtigste Tatsache an diesem Code ist, dass er dem Bereich zugeordnet ist. Also gibt es dein "Warum sollte ich ...". Ich benutze, generateweil in C ++ std::generate"Bereichszuweisung" bedeutet. Wie übrigensstd::copy ist der Unterschied zwischen den beiden, was Sie zuweisen.

Es gibt jedoch verwirrende Faktoren. Bereichsbasierte for-Schleifen haben eine von Natur aus direktere Möglichkeit, den Bereich auszudrücken numbers, als iteratorbasierte Algorithmen. Deshalb arbeiten die Leute an bereichsbasierten Algorithmusbibliotheken: boost::range::generate(numbers, rand);Sieht besser aus als diestd::generate Version.

Im Gegensatz dazu ist int&in Ihrer bereichsbasierten for-Schleife eine Falte. Was ist, wenn der Werttyp des Bereichs nicht der Fall ist? intDann machen wir hier etwas ärgerlich Feines, das davon abhängt, ob er konvertierbar ist int&, während der generateCode nur von der Rückkehr abhängt, randwenn er dem Element zugewiesen werden kann. Selbst wenn der Werttyp ist int, könnte ich immer noch darüber nachdenken, ob dies der Fall ist oder nicht. Daher autowird das Nachdenken über die Typen verschoben, bis ich sehe, was zugewiesen wird - mit der auto &xAussage "Nehmen Sie einen Verweis auf das Bereichselement, welchen Typ auch immer". Zurück in C ++ 03 waren Algorithmen (weil sie Funktionsvorlagen sind) der Weg, um exakte Typen zu verbergen, jetzt sind sie ein Weg.

Ich denke, es war schon immer so, dass die einfachsten Algorithmen nur einen geringfügigen Vorteil gegenüber den äquivalenten Schleifen haben. Range-based for-Schleifen verbessern Schleifen (hauptsächlich durch Entfernen des größten Teils der Boilerplate, obwohl sie etwas mehr enthalten). Die Ränder werden also enger und vielleicht ändern Sie Ihre Meinung in bestimmten Fällen. Aber da gibt es immer noch einen Stilunterschied.

Meiner Meinung nach Effective STL Item 43: "Bevorzugen Sie Algorithmusaufrufe gegenüber handgeschriebenen Schleifen." ist immer noch ein guter Rat.

Normalerweise schreibe ich Wrapper-Funktionen, um die begin()/ end()Hölle loszuwerden . Wenn Sie das tun, sieht Ihr Beispiel folgendermaßen aus:

my_util::generate(numbers, rand);

Ich glaube, es übertrifft den auf Schleifen basierenden Bereich sowohl bei der Kommunikation der Absicht als auch bei der Lesbarkeit.

Trotzdem muss ich zugeben, dass in C ++ 98 einige STL-Algorithmusaufrufe unaussprechlichen Code ergaben und das Befolgen von "Algorithmusaufrufe gegenüber handgeschriebenen Schleifen bevorzugen" keine gute Idee zu sein schien. Zum Glück haben Lambdas das geändert.

Betrachten Sie das folgende Beispiel von Herb Sutter: Lambdas, Lambdas Everywhere .

Aufgabe: Finden Sie das erste Element in v, das > xund ist < y.

Ohne Lambdas:

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

Mit Lambda

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

In meiner Meinung nach ist die manuelle Schleife, obwohl Ausführlichkeit reduzieren könnte, fehlt readabitly:

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

Ich würde nicht diese Schleife verwenden zu initialisieren ¹ durch definierte der Bereich Zahlen , denn wenn ich es sehe, scheint es mir , dass es Iterieren über eine Reihe von Zahlen, aber es funktioniert nicht (im Wesentlichen) in der Wirklichkeit, das heißt statt Lesen aus dem Bereich, es schreibt auf den Bereich.

Die Absicht ist viel klarer, wenn Sie verwenden std::generate .

^{1. Initialisieren bedeutet in diesem Zusammenhang , den Elementen des Containers einen sinnvollen Wert zu geben .}

Es gibt einige Dinge, die Sie (einfach) nicht mit bereichsbasierten Schleifen tun können, die Algorithmen, die Iteratoren als Eingabe verwenden, können. Zum Beispiel mit std::generate:

Füllen Sie den Container bis limit(ausgeschlossen, limitist ein gültiger Iterator aktiviert numbers) mit Variablen aus einer Distribution und den Rest mit Variablen aus einer anderen Distribution.

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

Mit Iterator-basierten Algorithmen können Sie den Bereich, in dem Sie arbeiten, besser steuern.

Für den speziellen Fall von std::generatestimme ich den vorherigen Antworten zum Thema Lesbarkeit / Absicht zu. std :: generate scheint mir eine klarere Version zu sein. Aber ich gebe zu, dass dies in gewisser Weise Geschmackssache ist.

Trotzdem habe ich einen weiteren Grund, den std :: -Algorithmus nicht wegzuwerfen - es gibt bestimmte Algorithmen, die auf einige Datentypen spezialisiert sind.

Das einfachste Beispiel wäre std::fill. Die allgemeine Version wird als for-Schleife über den bereitgestellten Bereich implementiert. Diese Version wird beim Instanziieren der Vorlage verwendet. Aber nicht immer. ZB wenn Sie ihm einen Bereich zur Verfügung stellen, der a ist std::vector<int>- oft wird er tatsächlich anrufenmemset unter der Haube , was einen viel schnelleren und besseren Code ergibt.

Also versuche ich hier eine Effizienzkarte zu spielen.

Ihre handgeschriebene Schleife ist möglicherweise so schnell wie eine std :: algorithm-Version, kann jedoch kaum schneller sein. Darüber hinaus ist der std :: -Algorithmus möglicherweise auf bestimmte Container und Typen spezialisiert und erfolgt über die saubere STL-Schnittstelle.

Meine Antwort wäre vielleicht und nein. Wenn wir über C ++ 11 sprechen, dann vielleicht (eher wie nein). Zum Beispiel std::for_eachist es wirklich ärgerlich, es auch mit Lambdas zu benutzen:

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

Die Verwendung von Range-Based für ist jedoch viel besser:

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

Auf der anderen Seite, wenn wir über C ++ 1y sprechen, würde ich argumentieren, dass nein, die Algorithmen nicht durch bereichsbasierte für überholt werden. Im C ++ - Standardkomitee gibt es eine Studiengruppe, die an einem Vorschlag arbeitet, Bereiche zu C ++ hinzuzufügen, und es wird auch an polymorphen Lambdas gearbeitet. Bereiche würden die Notwendigkeit der Verwendung von Iteratorpaaren beseitigen, und polymorphes Lambda würde es Ihnen ermöglichen, den genauen Argumenttyp des Lambda nicht anzugeben. Dies bedeutet, dass std::for_eachdies so verwendet werden könnte (nehmen Sie dies nicht als harte Tatsache, es ist genau so, wie die Träume heute aussehen):

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

Eine Sache, die beachtet werden sollte, ist, dass ein Algorithmus ausdrückt, was getan wird, nicht wie.

Die bereichsbasierte Schleife umfasst die Art und Weise, wie Dinge erledigt werden: Beginnen Sie mit dem ersten, wenden Sie an und gehen Sie bis zum Ende zum nächsten Element. Sogar ein einfacher Algorithmus könnte die Dinge anders machen (zumindest einige Überladungen für bestimmte Container, ohne an den schrecklichen Vektor zu denken), und zumindest ist die Art und Weise, wie dies gemacht wird, nicht das Geschäft der Autoren.

Für mich ist das ein großer Unterschied, kapseln Sie so viel wie möglich ein, und das rechtfertigt den Satz, wenn Sie können, verwenden Sie Algorithmen.

Eine bereichsbasierte for-Schleife ist genau das. Bis natürlich Standard geändert wird.

Algorithmus ist eine Funktion. Eine Funktion, die einige Anforderungen an ihre Parameter stellt. Die Anforderungen sind in einem Standard formuliert, um beispielsweise eine Implementierung zu ermöglichen, die alle verfügbaren Ausführungsthreads nutzt und Sie automatisch beschleunigt.