Sind die Tage der Übergabe von const std :: string & als Parameter vorbei?

Ich hörte einen letzten Vortrag von Herb Sutter, der vorschlug , dass die Gründe passieren std::vectorund std::stringvon const &weitgehend verschwunden. Er schlug vor, eine Funktion wie die folgende zu schreiben:

std::string do_something ( std::string inval )
{
   std::string return_val;
   // ... do stuff ...
   return return_val;
}

Ich verstehe, dass der return_valWert an dem Punkt ist, an dem die Funktion zurückkehrt, und daher unter Verwendung der Verschiebungssemantik zurückgegeben werden kann, die sehr billig ist. Ist invaljedoch immer noch viel größer als die Größe einer Referenz (die normalerweise als Zeiger implementiert wird). Dies liegt daran, dass a std::stringverschiedene Komponenten enthält, einschließlich eines Zeigers in den Heap und eines Elements char[]für die Optimierung kurzer Zeichenfolgen. Daher scheint es mir immer noch eine gute Idee zu sein, als Referenz zu fungieren.

Kann jemand erklären, warum Herb das gesagt haben könnte?

Der Grund, warum Herb sagte, was er sagte, sind solche Fälle.

Angenommen, ich habe Aeine Funktion B, die die Funktion aufruft , die die Funktion aufruft C. Und Ageht eine Schnur durch Bund in C. Aweiß nicht oder kümmert sich nicht darum C; alles Aweiß ist B. Das heißt, Cist ein Implementierungsdetail von B.

Angenommen, A ist wie folgt definiert:

void A()
{
  B("value");
}

Wenn B und C die Zeichenfolge vorbeikommen const&, sieht es ungefähr so ​​aus:

void B(const std::string &str)
{
  C(str);
}

void C(const std::string &str)
{
  //Do something with `str`. Does not store it.
}

Alles schön und gut. Sie geben nur Hinweise weiter, kein Kopieren, keine Bewegung, alle sind glücklich. Cnimmt ein, const&weil es die Zeichenfolge nicht speichert. Es benutzt es einfach.

Jetzt möchte ich eine einfache Änderung vornehmen: CDie Zeichenfolge muss irgendwo gespeichert werden.

void C(const std::string &str)
{
  //Do something with `str`.
  m_str = str;
}

Hallo, Kopierkonstruktor und mögliche Speicherzuordnung (ignorieren Sie die Short String Optimization (SSO) ). Die Verschiebungssemantik von C ++ 11 soll es ermöglichen, unnötige Kopierkonstruktionen zu entfernen, oder? Und Ageht eine vorübergehende; es gibt keinen Grund , warum Cmüssen sollte kopiert die Daten. Es sollte nur mit dem fliehen, was ihm gegeben wurde.

Außer es kann nicht. Weil es eine braucht const&.

Wenn ich ändere C, um seinen Parameter nach Wert zu nehmen, führt dies nur dazu B, dass die Kopie in diesen Parameter ausgeführt wird. Ich gewinne nichts.

Wenn ich also nur stralle Funktionen als Wert durchlaufen hätte und mich darauf verlassen würde std::move, die Daten zu mischen, hätten wir dieses Problem nicht. Wenn jemand daran festhalten will, kann er es. Wenn nicht, na ja.

Ist es teurer? Ja; Der Übergang zu einem Wert ist teurer als die Verwendung von Referenzen. Ist es billiger als die Kopie? Nicht für kleine Saiten mit SSO. Lohnt es sich zu tun?

Dies hängt von Ihrem Anwendungsfall ab. Wie sehr hassen Sie Speicherzuweisungen?

Sind die Tage der Übergabe von const std :: string & als Parameter vorbei?

Nein . Viele Leute (einschließlich Dave Abrahams) nehmen diesen Rat über den Bereich hinaus an, für den er gilt, und vereinfachen ihn, um ihn auf alle std::string Parameter anzuwenden. Die ständige Übergabe std::stringvon Werten ist keine "Best Practice" für alle beliebigen Parameter und Anwendungen, da diese optimiert werden Vorträge / Artikel konzentrieren sich nur auf eine begrenzte Anzahl von Fällen .

Wenn Sie einen Wert zurückgeben, den Parameter mutieren oder den Wert übernehmen, kann das Übergeben eines Werts teures Kopieren sparen und syntaktischen Komfort bieten.

Wie immer spart das Übergeben einer const-Referenz viel Kopieren, wenn Sie keine Kopie benötigen .

Nun zum konkreten Beispiel:

Inval ist jedoch immer noch viel größer als die Größe einer Referenz (die normalerweise als Zeiger implementiert wird). Dies liegt daran, dass ein std :: string verschiedene Komponenten enthält, einschließlich eines Zeigers in den Heap und eines Mitglieds char [] für die Optimierung kurzer Strings. Daher scheint es mir immer noch eine gute Idee zu sein, als Referenz zu fungieren. Kann jemand erklären, warum Herb das gesagt haben könnte?

Wenn die Stapelgröße ein Problem darstellt (und vorausgesetzt, dass dies nicht inline / optimiert ist), return_val+ inval> return_val- IOW, kann die maximale Stapelnutzung reduziert werden, indem hier ein Wert übergeben wird (Hinweis: Übervereinfachung von ABIs). In der Zwischenzeit kann das Übergeben einer const-Referenz die Optimierungen deaktivieren. Der Hauptgrund hierbei ist nicht, das Stapelwachstum zu vermeiden, sondern sicherzustellen, dass die Optimierung dort durchgeführt werden kann, wo sie anwendbar ist .

Die Tage des Vergehens der Konstantenreferenz sind noch nicht vorbei - die Regeln sind nur komplizierter als früher. Wenn die Leistung wichtig ist, sollten Sie überlegen, wie Sie diese Typen übergeben, basierend auf den Details, die Sie in Ihren Implementierungen verwenden.

Dies hängt stark von der Implementierung des Compilers ab.

Dies hängt jedoch auch davon ab, was Sie verwenden.

Betrachten wir die nächsten Funktionen:

bool foo1( const std::string v )
{
  return v.empty();
}
bool foo2( const std::string & v )
{
  return v.empty();
}

Diese Funktionen werden in einer separaten Kompilierungseinheit implementiert, um Inlining zu vermeiden. Dann:
1. Wenn Sie diesen beiden Funktionen ein Literal übergeben, werden Sie keinen großen Unterschied in der Leistung feststellen. In beiden Fällen muss ein String-Objekt erstellt werden.
2. Wenn Sie ein anderes std :: string-Objekt übergeben, foo2wird es eine Outperformance erzielen foo1, da foo1eine tiefe Kopie erstellt wird.

Auf meinem PC mit g ++ 4.6.1 habe ich folgende Ergebnisse erhalten:

• Variable durch Referenz: 1000000000 Iterationen -> verstrichene Zeit: 2.25912 Sek
• variabel nach Wert: 1000000000 Iterationen -> verstrichene Zeit: 27,2259 Sek
• Literal durch Bezugnahme: 100000000 Iterationen -> verstrichene Zeit: 9.10319 Sek
• Literal nach Wert: 100000000 Iterationen -> verstrichene Zeit: 8,62659 Sek

Kurze Antwort: NEIN! Lange Antwort:

• Wenn Sie die Zeichenfolge nicht ändern (behandeln ist schreibgeschützt), übergeben Sie sie als const ref&.
  (Das muss const ref&offensichtlich im Rahmen bleiben, während die Funktion, die es verwendet, ausgeführt wird.)
• Wenn Sie vorhaben, es zu ändern, oder wenn Sie wissen, dass es außerhalb des Gültigkeitsbereichs (Threads) liegt , übergeben Sie es als value, kopieren Sie nicht das const ref&Innere Ihres Funktionskörpers.

Auf cpp-next.com gab es einen Beitrag mit dem Titel "Willst du Geschwindigkeit, pass by value!" . Die TL; DR:

Richtlinie : Kopieren Sie Ihre Funktionsargumente nicht. Übergeben Sie sie stattdessen als Wert und lassen Sie den Compiler das Kopieren durchführen.

ÜBERSETZUNG von ^

Kopieren Sie Ihre Funktionsargumente nicht --- bedeutet: Wenn Sie den Argumentwert durch Kopieren in eine interne Variable ändern möchten, verwenden Sie stattdessen einfach ein Wertargument .

Also mach das nicht :

std::string function(const std::string& aString){
    auto vString(aString);
    vString.clear();
    return vString;
}

mach das :

std::string function(std::string aString){
    aString.clear();
    return aString;
}

Wenn Sie den Argumentwert in Ihrem Funktionskörper ändern müssen.

Sie müssen nur wissen, wie Sie das Argument im Funktionskörper verwenden möchten. Schreibgeschützt oder NICHT ... und wenn es im Geltungsbereich bleibt.

Wenn Sie keine Kopie benötigen, ist es immer noch vernünftig, sie zu nehmen const &. Zum Beispiel:

bool isprint(std::string const &s) {
    return all_of(begin(s),end(s),(bool(*)(char))isprint);
}

Wenn Sie dies ändern, um die Zeichenfolge nach Wert zu nehmen, wird der Parameter am Ende verschoben oder kopiert, und das ist nicht erforderlich. Das Kopieren / Verschieben ist wahrscheinlich nicht nur teurer, sondern führt auch zu einem neuen potenziellen Fehler. Das Kopieren / Verschieben kann eine Ausnahme auslösen (z. B. kann die Zuordnung während des Kopierens fehlschlagen), während das Verweisen auf einen vorhandenen Wert dies nicht kann.

Wenn Sie noch eine Kopie benötigen dann vorbei und durch den Wert der Rückkehr ist in der Regel (immer?) , Um die beste Option. Tatsächlich würde ich mich in C ++ 03 im Allgemeinen nicht darum kümmern, es sei denn, Sie stellen fest, dass zusätzliche Kopien tatsächlich ein Leistungsproblem verursachen. Copy Elision scheint auf modernen Compilern ziemlich zuverlässig zu sein. Ich denke, die Skepsis und das Bestehen der Leute darauf, dass Sie Ihre Tabelle der Compiler-Unterstützung für RVO überprüfen müssen, ist heutzutage größtenteils veraltet.

Kurz gesagt, C ++ 11 ändert in dieser Hinsicht nichts wirklich, außer Menschen, die der Kopierentscheidung nicht vertrauten.

Fast.

In C ++ 17 haben wir basic_string_view<?>, was uns auf einen engen Anwendungsfall für std::string const&Parameter reduziert.

Das Vorhandensein einer Verschiebungssemantik hat einen Anwendungsfall für beseitigt std::string const&: Wenn Sie den Parameter speichern möchten, std::stringist es optimaler, einen By-Wert zu verwenden, da Sie moveden Parameter verlassen können.

Wenn jemand Ihre Funktion mit einem rohen C aufgerufen hat, "string"bedeutet dies, dass immer nur ein std::stringPuffer zugewiesen wird, im Gegensatz zu zwei std::string const&.

Wenn Sie jedoch keine Kopie erstellen möchten, std::string const&ist das Mitnehmen in C ++ 14 weiterhin hilfreich.

Mit std::string_view, wie Sie die C-Stil erwartet werden so lange nicht Zeichenfolge an eine API sagte passing '\0'Puffer terminierte Charakter, können Sie effizienter erhalten std::stringwie Funktionalität , ohne eine Zuordnung zu riskieren. Eine rohe C-Zeichenfolge kann sogar std::string_viewohne Zuweisung oder Kopieren von Zeichen in eine Zeichenfolge umgewandelt werden.

Zu diesem Zeitpunkt wird verwendet, std::string const&wenn Sie den Datengroßhandel nicht kopieren und ihn an eine API im C-Stil weiterleiten, die einen nullterminierten Puffer erwartet, und Sie die übergeordneten Zeichenfolgenfunktionen benötigen, die std::stringbereitgestellt werden. In der Praxis ist dies eine seltene Reihe von Anforderungen.

std::stringist kein Plain Old Data (POD) , und seine Rohgröße ist nicht die relevanteste Sache überhaupt. Wenn Sie beispielsweise eine Zeichenfolge übergeben, die über der Länge von SSO liegt und auf dem Heap zugewiesen ist, würde ich erwarten, dass der Kopierkonstruktor den SSO-Speicher nicht kopiert.

Der Grund, warum dies empfohlen wird, liegt darin, dass invales aus dem Argumentausdruck aufgebaut ist und daher immer entsprechend verschoben oder kopiert wird. Es gibt keinen Leistungsverlust, vorausgesetzt, Sie benötigen das Eigentum an dem Argument. Wenn Sie dies nicht tun, könnte eine constReferenz immer noch der bessere Weg sein.

Ich habe die Antwort von dieser Frage hier kopiert / eingefügt und die Namen und die Schreibweise geändert, um sie an diese Frage anzupassen.

Hier ist Code, um zu messen, was gefragt wird:

#include <iostream>

struct string
{
    string() {}
    string(const string&) {std::cout << "string(const string&)\n";}
    string& operator=(const string&) {std::cout << "string& operator=(const string&)\n";return *this;}
#if (__has_feature(cxx_rvalue_references))
    string(string&&) {std::cout << "string(string&&)\n";}
    string& operator=(string&&) {std::cout << "string& operator=(string&&)\n";return *this;}
#endif

};

#if PROCESS == 1

string
do_something(string inval)
{
    // do stuff
    return inval;
}

#elif PROCESS == 2

string
do_something(const string& inval)
{
    string return_val = inval;
    // do stuff
    return return_val; 
}

#if (__has_feature(cxx_rvalue_references))

string
do_something(string&& inval)
{
    // do stuff
    return std::move(inval);
}

#endif

#endif

string source() {return string();}

int main()
{
    std::cout << "do_something with lvalue:\n\n";
    string x;
    string t = do_something(x);
#if (__has_feature(cxx_rvalue_references))
    std::cout << "\ndo_something with xvalue:\n\n";
    string u = do_something(std::move(x));
#endif
    std::cout << "\ndo_something with prvalue:\n\n";
    string v = do_something(source());
}

Für mich ergibt dies:

$ clang++ -std=c++11 -stdlib=libc++ -DPROCESS=1 test.cpp
$ a.out
do_something with lvalue:

string(const string&)
string(string&&)

do_something with xvalue:

string(string&&)
string(string&&)

do_something with prvalue:

string(string&&)
$ clang++ -std=c++11 -stdlib=libc++ -DPROCESS=2 test.cpp
$ a.out
do_something with lvalue:

string(const string&)

do_something with xvalue:

string(string&&)

do_something with prvalue:

string(string&&)

Die folgende Tabelle fasst meine Ergebnisse zusammen (mit clang -std = c ++ 11). Die erste Zahl ist die Anzahl der Kopierkonstruktionen und die zweite Zahl ist die Anzahl der Verschiebungskonstruktionen:

+----+--------+--------+---------+
|    | lvalue | xvalue | prvalue |
+----+--------+--------+---------+
| p1 |  1/1   |  0/2   |   0/1   |
+----+--------+--------+---------+
| p2 |  1/0   |  0/1   |   0/1   |
+----+--------+--------+---------+

Die Pass-by-Value-Lösung erfordert nur eine Überladung, kostet jedoch eine zusätzliche Bewegungskonstruktion, wenn l-Werte und x-Werte übergeben werden. Dies kann für eine bestimmte Situation akzeptabel sein oder auch nicht. Beide Lösungen haben Vor- und Nachteile.

Herb Sutter ist zusammen mit Bjarne Stroustroup immer noch in der Empfehlung const std::string&, einen Parametertyp zu empfehlen . Siehe https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#Rf-in .

In keiner der anderen Antworten wird eine Falle erwähnt: Wenn Sie ein String-Literal an einen const std::string&Parameter übergeben, wird ein Verweis auf eine temporäre Zeichenfolge übergeben, die im laufenden Betrieb erstellt wurde, um die Zeichen des Literals zu speichern. Wenn Sie diese Referenz dann speichern, ist sie ungültig, sobald die Zuordnung der temporären Zeichenfolge aufgehoben wird. Um sicher zu gehen, müssen Sie eine Kopie speichern , nicht die Referenz. Das Problem ergibt sich aus der Tatsache, dass Zeichenfolgenliterale const char[N]Typen sind, für die eine Heraufstufung erforderlich ist std::string.

Der folgende Code zeigt die pitfall und die Abhilfe, zusammen mit einer geringen Effizienz Option - mit einem Überlastung const char*Verfahren, wie bei beschriebenen gibt es einen Weg , um eine Stringliteral als Referenz in C ++ passieren .

(Hinweis: Sutter & Stroustroup empfehlen, dass Sie, wenn Sie eine Kopie des Strings behalten, auch eine überladene Funktion mit einem && -Parameter und std :: move () bereitstellen.)

#include <string>
#include <iostream>
class WidgetBadRef {
public:
    WidgetBadRef(const std::string& s) : myStrRef(s)  // copy the reference...
    {}

    const std::string& myStrRef;    // might be a reference to a temporary (oops!)
};

class WidgetSafeCopy {
public:
    WidgetSafeCopy(const std::string& s) : myStrCopy(s)
            // constructor for string references; copy the string
    {std::cout << "const std::string& constructor\n";}

    WidgetSafeCopy(const char* cs) : myStrCopy(cs)
            // constructor for string literals (and char arrays);
            // for minor efficiency only;
            // create the std::string directly from the chars
    {std::cout << "const char * constructor\n";}

    const std::string myStrCopy;    // save a copy, not a reference!
};

int main() {
    WidgetBadRef w1("First string");
    WidgetSafeCopy w2("Second string"); // uses the const char* constructor, no temp string
    WidgetSafeCopy w3(w2.myStrCopy);    // uses the String reference constructor
    std::cout << w1.myStrRef << "\n";   // garbage out
    std::cout << w2.myStrCopy << "\n";  // OK
    std::cout << w3.myStrCopy << "\n";  // OK
}

AUSGABE:

const char * constructor
const std::string& constructor

Second string
Second string

IMO mit der C ++ - Referenz für std::stringist eine schnelle und kurze lokale Optimierung, während die Verwendung der Übergabe von Werten eine bessere globale Optimierung sein könnte (oder nicht).

Die Antwort lautet also: Es hängt von den Umständen ab:

1. Wenn Sie den gesamten Code von außen nach innen schreiben, wissen Sie, was der Code tut, und können die Referenz verwenden const std::string &.
2. Wenn Sie den Bibliothekscode schreiben oder stark Bibliothekscode verwenden, in dem Zeichenfolgen übergeben werden, gewinnen Sie wahrscheinlich mehr im globalen Sinne, wenn Sie dem std::stringVerhalten des Kopierkonstruktors vertrauen .

Siehe "Herb Sutter" Zurück zu den Grundlagen! Grundlagen des modernen C ++ - Stils . Unter anderem bespricht er die in der Vergangenheit gegebenen Ratschläge zur Parameterübergabe und neue Ideen, die mit C ++ 11 einhergehen, und befasst sich speziell mit dem Idee, Zeichenfolgen nach Wert zu übergeben.

Die Benchmarks zeigen, dass das Übergeben von std::strings nach Wert in Fällen, in denen die Funktion es trotzdem kopiert, erheblich langsamer sein kann!

Dies liegt daran, dass Sie es zwingen, immer eine vollständige Kopie zu erstellen (und dann an Ort und Stelle zu verschieben), während die const&Version die alte Zeichenfolge aktualisiert, die möglicherweise den bereits zugewiesenen Puffer wiederverwendet.

Siehe seine Folie 27: Für "Set" -Funktionen ist Option 1 dieselbe wie immer. Option 2 fügt eine Überlastung für die r-Wert-Referenz hinzu, dies führt jedoch zu einer kombinatorischen Explosion, wenn mehrere Parameter vorhanden sind.

Nur für "sink" -Parameter, bei denen eine Zeichenfolge erstellt werden muss (ohne dass der vorhandene Wert geändert wird), ist der Trick zum Übergeben von Werten gültig. Das heißt, Konstruktoren, in denen der Parameter das Mitglied des übereinstimmenden Typs direkt initialisiert.

Wenn Sie sehen möchten, wie tief Sie sich Sorgen machen können, schauen Sie sich die Präsentation von Nicolai Josuttis an und wünschen Sie viel Glück damit ( "Perfekt - Fertig!" N-mal, nachdem Sie einen Fehler in der vorherigen Version gefunden haben. Waren Sie schon einmal dort?)

Dies ist in den Standardrichtlinien auch als ⧺F.15 zusammengefasst .

Wie @ JDługosz in den Kommentaren hervorhebt, gibt Herb in einem anderen (späteren?) Vortrag weitere Ratschläge, siehe ungefähr hier: https://youtu.be/xnqTKD8uD64?t=54m50s .

Sein Rat läuft darauf hinaus, nur Wertparameter für eine Funktion zu verwenden f, die sogenannte Senkenargumente verwendet, vorausgesetzt, Sie verschieben das Konstrukt aus diesen Senkenargumenten.

Dieser allgemeine Ansatz erhöht nur den Overhead eines Verschiebungskonstruktors sowohl für lvalue- als auch für rvalue-Argumente im Vergleich zu einer optimalen Implementierung von fauf lvalue- bzw. rvalue-Argumente zugeschnittenen Argumenten. Um zu sehen, warum dies der Fall ist, nehmen wir an, dass fein Wertparameter verwendet wird, bei dem Tes sich um einen konstruierbaren Typ zum Kopieren und Verschieben handelt:

void f(T x) {
  T y{std::move(x)};
}

Das Aufrufen fmit einem lvalue-Argument führt dazu, dass ein Kopierkonstruktor zum Konstruieren xund ein Verschiebungskonstruktor zum Konstruieren aufgerufen werden y. fWenn Sie dagegen mit einem rvalue-Argument aufrufen, wird ein Verschiebungskonstruktor zum Konstruieren xund ein anderer Verschiebungskonstruktor zum Konstruieren aufgerufen y.

Im Allgemeinen ist die optimale Implementierung von ffor lvalue-Argumenten wie folgt:

void f(const T& x) {
  T y{x};
}

In diesem Fall wird nur ein Kopierkonstruktor zum Konstruieren aufgerufen y. Die optimale Implementierung von ffor rvalue-Argumenten ist im Allgemeinen wiederum wie folgt:

void f(T&& x) {
  T y{std::move(x)};
}

In diesem Fall wird nur ein Verschiebungskonstruktor zum Konstruieren aufgerufen y.

Ein vernünftiger Kompromiss besteht also darin, einen Wertparameter zu verwenden und einen zusätzlichen Zugkonstruktoraufruf für lvalue- oder rvalue-Argumente in Bezug auf die optimale Implementierung durchzuführen, was auch der Ratschlag in Herbs Vortrag ist.

Wie @ JDługosz in den Kommentaren hervorhob, ist die Übergabe von Werten nur für Funktionen sinnvoll, die ein Objekt aus dem sink-Argument erstellen. Wenn Sie eine Funktion haben f, die ihr Argument kopiert, hat der Pass-by-Value-Ansatz mehr Overhead als ein allgemeiner Pass-by-Const-Referenzansatz. Der Pass-by-Value-Ansatz für eine Funktion f, die eine Kopie ihres Parameters beibehält, hat folgende Form:

void f(T x) {
  T y{...};
  ...
  y = std::move(x);
}

In diesem Fall gibt es eine Kopierkonstruktion und eine Verschiebungszuweisung für ein lvalue-Argument sowie eine Verschiebungskonstruktion und eine Verschiebungszuweisung für ein rvalue-Argument. Der optimalste Fall für ein lvalue-Argument ist:

void f(const T& x) {
  T y{...};
  ...
  y = x;
}

Dies läuft nur auf eine Zuweisung hinaus, die möglicherweise viel billiger ist als der Kopierkonstruktor plus Verschiebungszuweisung, die für den Pass-by-Value-Ansatz erforderlich ist. Der Grund dafür ist, dass die Zuweisung möglicherweise vorhandenen zugewiesenen Speicher in wiederverwendet yund daher (De-) Zuweisungen verhindert, während der Kopierkonstruktor normalerweise Speicher zuweist.

Für ein rvalue-Argument hat die optimalste Implementierung f, bei der eine Kopie erhalten bleibt, die folgende Form:

void f(T&& x) {
  T y{...};
  ...
  y = std::move(x);
}

Also nur eine Zugzuordnung in diesem Fall. Das Übergeben eines r-Werts an die Version, für fdie eine konstante Referenz erforderlich ist, kostet nur eine Zuweisung anstelle einer Verschiebungszuweisung. Relativ gesehen fist es daher vorzuziehen, in diesem Fall eine konstante Referenz als allgemeine Implementierung zu verwenden.

Im Allgemeinen müssen Sie für eine optimale Implementierung eine perfekte Weiterleitung durchführen, wie im Vortrag gezeigt. Der Nachteil ist eine kombinatorische Explosion der Anzahl der erforderlichen Überladungen, abhängig von der Anzahl der Parameter für den fFall, dass Sie sich für eine Überlastung der Wertekategorie des Arguments entscheiden. Perfekte Weiterleitung hat den Nachteil, dass sie fzu einer Vorlagenfunktion wird, die verhindert, dass sie virtuell wird, und zu wesentlich komplexerem Code führt, wenn Sie ihn zu 100% richtig machen möchten (Einzelheiten finden Sie im Vortrag).

Das Problem ist, dass "const" ein nicht granulares Qualifikationsmerkmal ist. Was normalerweise mit "const string ref" gemeint ist, ist "diese Zeichenfolge nicht ändern", nicht "den Referenzzähler nicht ändern". In C ++ gibt es einfach keine Möglichkeit zu sagen, welche Mitglieder "const" sind. Sie sind entweder alle oder keiner von ihnen.

Um dieses Sprachproblem zu umgehen, könnte STL "C ()" in Ihrem Beispiel trotzdem erlauben, eine verschiebungssemantische Kopie zu erstellen , und die "const" in Bezug auf die Referenzanzahl pflichtbewusst ignorieren (veränderlich). Solange es gut spezifiziert war, wäre dies in Ordnung.

Da STL dies nicht tut, habe ich eine Version eines Strings, der const_casts <> den Referenzzähler entfernt (keine Möglichkeit, etwas in einer Klassenhierarchie rückwirkend veränderbar zu machen), und - siehe da - Sie können cmstrings frei als const-Referenzen übergeben. und machen Sie Kopien davon in tiefen Funktionen, den ganzen Tag, ohne Lecks oder Probleme.

Da C ++ hier keine "abgeleitete Klasse const granularity" bietet, ist es die beste Lösung, eine gute Spezifikation zu schreiben und ein glänzendes neues "const movable string" -Objekt (cmstring) zu erstellen.