Welche C ++ - Redewendungen sind in C ++ 11 veraltet?

Mit dem neuen Standard gibt es neue Wege, Dinge zu tun, und viele sind schöner als die alten Wege, aber der alte Weg ist immer noch in Ordnung. Es ist auch klar, dass der neue Standard aus Gründen der Abwärtskompatibilität offiziell nicht sehr abwertet. Die Frage bleibt also:

Welche alten Codierungsmethoden sind C ++ 11-Stilen definitiv unterlegen, und was können wir jetzt stattdessen tun?

Wenn Sie darauf antworten, können Sie die offensichtlichen Dinge wie "Auto-Variablen verwenden" überspringen.

1. Letzte Klasse : C ++ 11 bietet den finalBezeichner, um die Klassenableitung zu verhindern
2. C ++ 11-Lambdas reduzieren den Bedarf an benannten Funktionsobjektklassen (Funktorklassen) erheblich.
3. Move Constructor : Die magischen Methoden, mit denen std::auto_ptrWerke aufgrund der erstklassigen Unterstützung für rvalue-Referenzen nicht mehr benötigt werden.
4. Safe Bool : Dies wurde bereits erwähnt. Explizite Operatoren von C ++ 11 vermeiden dieses sehr verbreitete C ++ 03-Idiom.
5. Auf Größe verkleinern : Viele C ++ 11 STL-Container bieten eine shrink_to_fit()Elementfunktion, die das Austauschen mit einer temporären Funktion überflüssig machen sollte.
6. Temporäre Basisklasse : Einige alte C ++ - Bibliotheken verwenden diese ziemlich komplexe Sprache. Mit der Bewegungssemantik wird es nicht mehr benötigt.
7. Typensichere Aufzählung Aufzählungen sind in C ++ 11 sehr sicher.
8. Verbieten der Heap-Zuweisung : Die = deleteSyntax ist eine viel direktere Art zu sagen, dass eine bestimmte Funktionalität explizit verweigert wird. Dies gilt für das Verhindern der Heap-Zuweisung (dh =deletefür Mitglieder operator new), das Verhindern von Kopien, die Zuweisung usw.
9. Typedef mit Vorlagen : Alias-Vorlagen in C ++ 11 reduzieren die Notwendigkeit einfacher Typedefs mit Vorlagen. Komplexe Typgeneratoren benötigen jedoch weiterhin Metafunktionen.
10. Einige numerische Berechnungen zur Kompilierungszeit, wie z. B. Fibonacci, können leicht durch verallgemeinerte konstante Ausdrücke ersetzt werden
11. result_of: Die Verwendung der Klassenvorlage result_ofsollte durch ersetzt werden decltype. Ich denke, result_ofverwendet, decltypewenn es verfügbar ist.
12. In-Class-Elementinitialisierer speichern die Eingabe für die Standardinitialisierung nicht statischer Elemente mit Standardwerten.
13. In neuem C ++ 11 NULLsollte Code neu definiert werden als nullptr, aber siehe STLs Vortrag , um zu erfahren, warum sie sich dagegen entschieden haben.
14. Fanatiker von Ausdrucksvorlagen freuen sich über die Syntax der Trailing-Return- Funktion in C ++ 11. Keine 30 Zeilen langen Rückgabetypen mehr!

Ich denke, ich werde dort aufhören!

Zu einem bestimmten Zeitpunkt wurde argumentiert, dass man nach constWert anstatt nur nach Wert zurückkehren sollte:

const A foo();
^^^^^

Dies war in C ++ 98/03 größtenteils harmlos und hat möglicherweise sogar einige Fehler entdeckt, die wie folgt aussahen:

foo() = a;

Die Rückkehr durch constist in C ++ 11 jedoch kontraindiziert, da sie die Bewegungssemantik verhindert:

A a = foo();  // foo will copy into a instead of move into it

Also einfach entspannen und codieren:

A foo();  // return by non-const value

Sobald Sie aufgeben können 0und NULLdafür sind nullptr, tun Sie dies!

In nicht generischem Code ist die Verwendung von 0oder NULLnicht so eine große Sache. Sobald Sie jedoch anfangen, Nullzeigerkonstanten im generischen Code zu übergeben, ändert sich die Situation schnell. Wenn Sie 0an a übergeben, template<class T> func(T) Twird dies als intund nicht als Nullzeigerkonstante abgeleitet. Danach kann es nicht mehr in eine Nullzeigerkonstante konvertiert werden. Dies führt zu einem Sumpf von Problemen, die einfach nicht existieren, wenn das Universum nur verwendet wird nullptr.

C ++ 11 ist nicht veraltet 0und NULLals Nullzeigerkonstanten. Aber Sie sollten so codieren, als ob es so wäre.

Sichere Bool-Sprache → explicit operator bool().

Konstrukteure für private Kopien (boost :: noncopyable) → X(const X&) = delete

Simulation der letzten Klasse mit privatem Destruktor und virtueller Vererbung →class X final

Eines der Dinge, die Sie nur vermeiden, grundlegende Algorithmen in C ++ 11 zu schreiben, ist die Verfügbarkeit von Lambdas in Kombination mit den von der Standardbibliothek bereitgestellten Algorithmen.

Ich benutze diese jetzt und es ist unglaublich, wie oft Sie einfach sagen, was Sie tun möchten, indem Sie count_if (), for_each () oder andere Algorithmen verwenden, anstatt die verdammten Schleifen erneut schreiben zu müssen.

Sobald Sie einen C ++ 11-Compiler mit einer vollständigen C ++ 11-Standardbibliothek verwenden, haben Sie keine gute Entschuldigung mehr, keine Standardalgorithmen zum Erstellen Ihrer zu verwenden . Lambda töte es einfach.

Warum?

In der Praxis (nachdem ich diese Art des Schreibens von Algorithmen selbst verwendet habe) fühlt es sich viel einfacher an, etwas zu lesen, das aus einfachen Wörtern besteht, die bedeuten, was getan wird, als mit einigen Schleifen, die Sie entschlüsseln müssen, um die Bedeutung zu kennen. Das automatische Ableiten von Lambda-Argumenten würde jedoch viel dazu beitragen, die Syntax leichter mit einer Raw-Schleife vergleichbar zu machen.

Grundsätzlich sind Lesealgorithmen, die mit Standardalgorithmen erstellt wurden, viel einfacher als Wörter, die die Implementierungsdetails der Schleifen verbergen.

Ich vermute, dass nur übergeordnete Algorithmen berücksichtigt werden müssen, da wir Algorithmen auf niedrigerer Ebene haben, auf denen wir aufbauen können.

Sie müssen swapweniger häufig benutzerdefinierte Versionen implementieren . In C ++ 03 swapist häufig ein effizientes Nicht-Werfen erforderlich, um kostspielige und werfende Kopien zu vermeiden. Da std::swapzwei Kopien verwendet werden, muss dies swaphäufig angepasst werden. In C ++ std::swapAnwendungen move, und so verschiebt sich der Fokus auf die Implementierung effizienter und nicht werfen bewegen Bauer und bewegen Zuweisungsoperatoren. Da für diese der Standard oft in Ordnung ist, ist dies viel weniger Arbeit als in C ++ 03.

Im Allgemeinen ist es schwer vorherzusagen, welche Redewendungen verwendet werden, da sie durch Erfahrung entstehen. Wir können ein "Effective C ++ 11" vielleicht nächstes Jahr und einen "C ++ 11 Coding Standards" erst in drei Jahren erwarten, da die notwendige Erfahrung noch nicht vorhanden ist.

Ich kenne den Namen nicht, aber C ++ 03-Code verwendete häufig das folgende Konstrukt als Ersatz für fehlende Verschiebungszuweisungen:

std::map<Big, Bigger> createBigMap(); // returns by value

void example ()
{
  std::map<Big, Bigger> map;

  // ... some code using map

  createBigMap().swap(map);  // cheap swap
}

Dies verhinderte jegliches Kopieren aufgrund von Kopierentfernung in Kombination mit dem swapObigen.

Als ich bemerkte, dass ein Compiler, der den C ++ 11-Standard verwendet, den folgenden Code nicht mehr fehlerhaft macht:

std::vector<std::vector<int>> a;

für angeblich mit Operator >> begann ich zu tanzen. In den früheren Versionen müsste man tun

std::vector<std::vector<int> > a;

Um die Sache noch schlimmer zu machen, wenn Sie dies jemals debuggen mussten, wissen Sie, wie schrecklich die Fehlermeldungen sind, die daraus entstehen.

Ich weiß jedoch nicht, ob dies für Sie "offensichtlich" war.

Die Rückgabe nach Wert ist kein Problem mehr. Mit der Bewegungssemantik und / oder der Optimierung des Rückgabewerts (compilerabhängig) sind Codierungsfunktionen natürlicher, ohne Overhead oder Kosten (meistens).