Effiziente Möglichkeit, einen std :: vector in c ++ zurückzugeben

Wie viele Daten werden kopiert, wenn ein std :: vector in einer Funktion zurückgegeben wird und wie groß die Optimierung sein wird, um den std :: vector im Free-Store (auf dem Heap) zu platzieren und stattdessen einen Zeiger zurückzugeben, dh:

std::vector *f()
{
  std::vector *result = new std::vector();
  /*
    Insert elements into result
  */
  return result;
} 

effizienter als:

std::vector f()
{
  std::vector result;
  /*
    Insert elements into result
  */
  return result;
} 

?

In C ++ 11 ist dies der bevorzugte Weg:

std::vector<X> f();

Das heißt, Rückgabe nach Wert.

Hat in C ++ 11 std::vectoreine Verschiebungssemantik, was bedeutet, dass der in Ihrer Funktion deklarierte lokale Vektor bei der Rückgabe verschoben wird und in einigen Fällen sogar die Verschiebung vom Compiler entfernt werden kann.

Sie sollten nach Wert zurückkehren.

Der Standard verfügt über eine spezielle Funktion zur Verbesserung der Effizienz der Wertrendite. Es heißt "Copy Elision" und in diesem Fall "Named Return Value Optimization (NRVO)".

Compiler müssen es nicht implementieren, aber dann wieder Compiler nicht haben Funktion zu implementieren inlining (oder jede Optimierung überhaupt durchführen). Die Leistung der Standardbibliotheken kann jedoch ziemlich schlecht sein, wenn Compiler nicht optimieren und alle seriösen Compiler Inlining und NRVO (und andere Optimierungen) implementieren.

Wenn NRVO angewendet wird, wird der folgende Code nicht kopiert:

std::vector<int> f() {
    std::vector<int> result;
    ... populate the vector ...
    return result;
}

std::vector<int> myvec = f();

Der Benutzer möchte dies jedoch möglicherweise tun:

std::vector<int> myvec;
... some time later ...
myvec = f();

Die Kopierelision verhindert hier keine Kopie, da es sich eher um eine Zuweisung als um eine Initialisierung handelt. Sie sollten jedoch weiterhin nach Wert zurückkehren. In C ++ 11 wird die Zuweisung durch etwas anderes optimiert, das als "Verschiebungssemantik" bezeichnet wird. In C ++ 03 verursacht der obige Code eine Kopie, und obwohl theoretisch ein Optimierer dies möglicherweise vermeiden kann, ist es in der Praxis zu schwierig. myvec = f()In C ++ 03 sollten Sie stattdessen Folgendes schreiben:

std::vector<int> myvec;
... some time later ...
f().swap(myvec);

Es gibt eine weitere Option, die dem Benutzer eine flexiblere Benutzeroberfläche bietet:

template <typename OutputIterator> void f(OutputIterator it) {
    ... write elements to the iterator like this ...
    *it++ = 0;
    *it++ = 1;
}

Darüber hinaus können Sie die vorhandene vektorbasierte Schnittstelle unterstützen:

std::vector<int> f() {
    std::vector<int> result;
    f(std::back_inserter(result));
    return result;
}

Dies ist möglicherweise weniger effizient als Ihr vorhandener Code, wenn Ihr vorhandener Code reserve()komplexer ist als nur ein fester Betrag im Voraus. Wenn Ihr vorhandener Code push_backden Vektor jedoch grundsätzlich wiederholt aufruft , sollte dieser vorlagenbasierte Code genauso gut sein.

Es ist Zeit, dass ich eine Antwort über RVO poste , ich auch ...

Wenn Sie ein Objekt nach Wert zurückgeben, optimiert der Compiler dies häufig, damit es nicht zweimal erstellt wird, da es überflüssig ist, es in der Funktion als temporär zu erstellen und dann zu kopieren. Dies wird als Rückgabewertoptimierung bezeichnet: Das erstellte Objekt wird verschoben, anstatt kopiert zu werden.

Eine gängige Sprache vor C ++ 11 besteht darin, einen Verweis auf das zu füllende Objekt zu übergeben.

Dann erfolgt keine Kopie des Vektors.

void f( std::vector & result )
{
  /*
    Insert elements into result
  */
} 

Wenn der Compiler die Optimierung des benannten Rückgabewerts unterstützt ( http://msdn.microsoft.com/en-us/library/ms364057(v=vs.80).aspx ), können Sie den Vektor direkt zurückgeben, sofern keine vorhanden ist:

1. Unterschiedliche Pfade, die unterschiedliche benannte Objekte zurückgeben
2. Mehrere Rückgabepfade (auch wenn auf allen Pfaden dasselbe benannte Objekt zurückgegeben wird) mit eingeführten EH-Zuständen.
3. Das zurückgegebene benannte Objekt wird in einem Inline-ASM-Block referenziert.

NRVO optimiert die redundanten Kopierkonstruktor- und Destruktoraufrufe und verbessert somit die Gesamtleistung.

In Ihrem Beispiel sollte es keinen wirklichen Unterschied geben.

vector<string> getseq(char * db_file)

Und wenn Sie es auf main () drucken möchten, sollten Sie es in einer Schleife tun.

int main() {
     vector<string> str_vec = getseq(argv[1]);
     for(vector<string>::iterator it = str_vec.begin(); it != str_vec.end(); it++) {
         cout << *it << endl;
     }
}

So schön "return by value" auch sein mag, es ist die Art von Code, die einen in einen Fehler führen kann. Betrachten Sie das folgende Programm:

    #include <string>
    #include <vector>
    #include <iostream>
    using namespace std;
    static std::vector<std::string> strings;
    std::vector<std::string> vecFunc(void) { return strings; };
    int main(int argc, char * argv[]){
      // set up the vector of strings to hold however
      // many strings the user provides on the command line
      for(int idx=1; (idx<argc); ++idx){
         strings.push_back(argv[idx]);
      }

      // now, iterate the strings and print them using the vector function
      // as accessor
      for(std::vector<std::string>::interator idx=vecFunc().begin(); (idx!=vecFunc().end()); ++idx){
         cout << "Addr: " << idx->c_str() << std::endl;
         cout << "Val:  " << *idx << std::endl;
      }
    return 0;
    };

• F: Was passiert, wenn das oben genannte ausgeführt wird? A: Ein Coredump.
• F: Warum hat der Compiler den Fehler nicht erkannt? A: Weil das Programm syntaktisch, wenn auch nicht semantisch, korrekt ist.
• F: Was passiert, wenn Sie vecFunc () so ändern, dass eine Referenz zurückgegeben wird? A: Das Programm wird vollständig ausgeführt und liefert das erwartete Ergebnis.
• F: Was ist der Unterschied? A: Der Compiler muss keine anonymen Objekte erstellen und verwalten. Der Programmierer hat den Compiler angewiesen, genau ein Objekt für den Iterator und für die Endpunktbestimmung zu verwenden, anstatt zwei verschiedene Objekte wie im fehlerhaften Beispiel.

Das obige fehlerhafte Programm zeigt keine Fehler an, selbst wenn man die GNU g ++ - Berichtsoptionen -Wall -Wextra -Weffc ++ verwendet

Wenn Sie einen Wert erzeugen müssen, funktioniert Folgendes, anstatt vecFunc () zweimal aufzurufen:

   std::vector<std::string> lclvec(vecFunc());
   for(std::vector<std::string>::iterator idx=lclvec.begin(); (idx!=lclvec.end()); ++idx)...

Das Obige erzeugt auch keine anonymen Objekte während der Iteration der Schleife, erfordert jedoch einen möglichen Kopiervorgang (der, wie einige Hinweise erwähnen, unter bestimmten Umständen wegoptimiert werden kann. Die Referenzmethode garantiert jedoch, dass keine Kopie erzeugt wird RVO ausführen ist kein Ersatz für den Versuch, den effizientesten Code zu erstellen, den Sie können. Wenn Sie die Notwendigkeit für den Compiler, RVO auszuführen, in Frage stellen können, sind Sie dem Spiel voraus.

   vector<string> func1() const
   {
      vector<string> parts;
      return vector<string>(parts.begin(),parts.end()) ;
   }