Wydajny sposób na zwrócenie std :: vector w języku C ++

Ile danych jest kopiowanych, podczas zwracania std :: vector w funkcji i jak duża będzie optymalizacja, aby umieścić std :: vector w wolnym magazynie (na stercie) i zamiast tego zwrócić wskaźnik, tj. Jest:

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

bardziej wydajny niż:

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

?

W C ++ 11 jest to preferowany sposób:

std::vector<X> f();

Oznacza to, że zwraca wartość.

W C ++ 11 std::vectorma semantykę ruchu, co oznacza, że lokalny wektor zadeklarowany w funkcji zostanie przeniesiony po powrocie, aw niektórych przypadkach kompilator może wyeliminować nawet ruch.

Powinieneś zwrócić według wartości.

Standard ma specyficzną funkcję poprawiającą efektywność zwrotu wartości. Nazywa się to „elizją kopiowania”, a dokładniej w tym przypadku „nazwaną optymalizacją wartości zwracanej (NRVO)”.

Kompilatory nie muszą tego implementować, ale z drugiej strony kompilatory nie muszą implementować funkcji inlining (ani w ogóle wykonywać jakiejkolwiek optymalizacji). Ale wydajność standardowych bibliotek może być dość słaba, jeśli kompilatory nie optymalizują, a wszystkie poważne kompilatory implementują inlining i NRVO (i inne optymalizacje).

Po zastosowaniu NRVO nie będzie kopiowania w następującym kodzie:

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

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

Ale użytkownik może chcieć to zrobić:

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

Opcja Copy Elision nie zapobiega tutaj kopiowaniu, ponieważ jest to raczej przypisanie niż inicjalizacja. Jednak nadal powinieneś zwracać według wartości. W C ++ 11 przypisanie jest optymalizowane przez coś innego, zwanego „semantyką ruchu”. W C ++ 03 powyższy kod powoduje kopiowanie i chociaż teoretycznie optymalizator mógłby tego uniknąć, w praktyce jest to zbyt trudne. Więc zamiast tego myvec = f()w C ++ 03 powinieneś napisać to:

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

Jest jeszcze jedna opcja, która ma zaoferować użytkownikowi bardziej elastyczny interfejs:

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

Następnie możesz również obsługiwać istniejący interfejs oparty na wektorach:

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

Może to być mniej wydajne niż istniejący kod, jeśli istniejący kod używa reserve()w sposób bardziej złożony niż tylko ustalona z góry kwota. Ale jeśli twój istniejący kod w zasadzie push_backwielokrotnie odwołuje się do wektora, to ten oparty na szablonie kod powinien być równie dobry.

Czas zamieścić odpowiedź na temat RVO , ja też ...

Jeśli zwracasz obiekt według wartości, kompilator często optymalizuje to, aby nie był konstruowany dwukrotnie, ponieważ zbędne jest konstruowanie go w funkcji jako tymczasowego, a następnie kopiowanie. Nazywa się to optymalizacją wartości zwracanych: utworzony obiekt zostanie przeniesiony zamiast kopiowania.

Popularnym idiomem sprzed C ++ 11 jest przekazanie referencji do wypełnianego obiektu.

Wtedy nie ma kopiowania wektora.

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

Jeśli kompilator obsługuje Named Return Value Optimization ( http://msdn.microsoft.com/en-us/library/ms364057(v=vs.80).aspx ), możesz bezpośrednio zwrócić wektor pod warunkiem, że nie ma:

1. Różne ścieżki zwracające różne nazwane obiekty
2. Wiele ścieżek zwrotnych (nawet jeśli ten sam nazwany obiekt jest zwracany na wszystkich ścieżkach) z wprowadzonymi stanami EH.
3. Zwrócony nazwany obiekt odwołuje się do wbudowanego bloku asm.

NRVO optymalizuje nadmiarowy konstruktor kopiujący i wywołania destruktora, a tym samym poprawia ogólną wydajność.

W twoim przykładzie nie powinno być żadnych różnic.

vector<string> getseq(char * db_file)

A jeśli chcesz wydrukować to na main (), powinieneś to zrobić w pętli.

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;
     }
}

Mimo że „zwracanie przez wartość” może być przyjemne, jest to rodzaj kodu, który może prowadzić do błędu. Rozważ następujący program:

    #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;
    };

• P: Co się stanie, gdy powyższe zostanie wykonane? O: Coredump.
• P: Dlaczego kompilator nie złapał błędu? O: Ponieważ program jest poprawny składniowo, choć nie semantycznie.
• P: Co się stanie, jeśli zmodyfikujesz vecFunc (), aby zwrócić odwołanie? Odp .: Program działa do końca i daje oczekiwany wynik.
• P: Jaka jest różnica? O: Kompilator nie musi tworzyć i zarządzać anonimowymi obiektami. Programista poinstruował kompilator, aby używał dokładnie jednego obiektu dla iteratora i do określenia punktu końcowego, a nie dwóch różnych obiektów, jak robi to uszkodzony przykład.

Powyższy błędny program nie wskaże żadnych błędów, nawet jeśli użyje się opcji raportowania GNU g ++ -Wall -Wextra -Weffc ++

Jeśli musisz podać wartość, to zamiast dwukrotnego wywołania vecFunc () zadziałałyby następujące czynności:

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

Powyższe również nie generuje żadnych anonimowych obiektów podczas iteracji pętli, ale wymaga możliwej operacji kopiowania (która, jak niektórzy zauważają, może zostać zoptymalizowana w pewnych okolicznościach. Ale metoda referencyjna gwarantuje, że żadna kopia nie zostanie utworzona. perform RVO nie zastąpi próby zbudowania najbardziej wydajnego kodu, jaki tylko możesz.Jeśli możesz podważyć potrzebę kompilatora do wykonania RVO, jesteś o krok do przodu.

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