Ефективний спосіб повернути std :: vector в c ++

Скільки даних копіюється, коли повертається std :: vector у функцію і наскільки великою буде оптимізація, щоб розмістити std :: vector у вільному сховищі (на купі) і замість нього повернути покажчик, тобто:

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

ефективніше, ніж:

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

?

У C ++ 11 це кращий спосіб:

std::vector<X> f();

Тобто повернення за значенням.

У C ++ 11 std::vectorмає семантику переміщення, що означає, що локальний вектор, оголошений у вашій функції, буде переміщений після повернення, а в деяких випадках компілятор може навіть вилучити цей хід.

Ви повинні повернути за значенням.

Стандарт має специфічну особливість для підвищення ефективності повернення за вартістю. Це називається "копіювати елізію", а конкретніше в даному випадку "названа оптимізація повернутого значення (NRVO)".

Компіляторам не потрібно його реалізовувати, але знову ж таки компіляторам не потрібно реалізовувати функції вбудовування (або взагалі проводити оптимізацію). Але продуктивність стандартних бібліотек може бути досить поганою, якщо компілятори не оптимізують, і всі серйозні компілятори реалізують вбудовані лінії та NRVO (та інші оптимізації).

Коли застосовується NRVO, копіювання в такий код не буде:

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

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

Але користувач може захотіти зробити це:

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

Copy elision не заважає копіювати тут, оскільки це призначення, а не ініціалізація. Однак вам все одно варто повернутись за вартістю. У C ++ 11 призначення оптимізоване чимсь іншим, що називається "семантика переміщення". У C ++ 03 наведений вище код дійсно викликає копію, і хоча теоретично оптимізатор міг би його уникнути, на практиці це занадто складно. Отже, замість myvec = f()C ++ 03 ви повинні написати це:

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

Існує ще один варіант - запропонувати користувачеві більш гнучкий інтерфейс:

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

Потім ви також можете підтримати існуючий векторний інтерфейс:

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

Це може бути менш ефективним, ніж ваш існуючий код, якщо ваш існуючий код використовує reserve()більш складний спосіб, ніж просто фіксована сума. Але якщо ваш існуючий код в основному push_backповторно звертається до вектора, тоді цей код на основі шаблону повинен бути таким же хорошим.

Пора опублікувати відповідь про RVO , я теж ...

Якщо ви повертаєте об'єкт за значенням, компілятор часто оптимізує це, щоб він не будувався двічі, оскільки зайвим буде побудувати його у функції як тимчасовий, а потім скопіювати. Це називається оптимізацією поверненого значення: створений об’єкт буде переміщено, а не скопійовано.

Загальна ідіома, що передує C ++ 11, - це передавання посилання на об'єкт, який заповнюється.

Тоді копіювання вектора не відбувається.

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

Якщо компілятор підтримує іменовану оптимізацію зворотного значення ( http://msdn.microsoft.com/en-us/library/ms364057(v=vs.80).aspx ), ви можете безпосередньо повернути вектор за умови, що його немає:

1. Різні шляхи, що повертають різні іменовані об’єкти
2. Введено кілька шляхів повернення (навіть якщо однаковий іменований об'єкт повертається на всіх шляхах) із введеними станами EH.
3. На іменований об'єкт, що повертається, посилається у вбудованому блоці ASM.

NRVO оптимізує надлишкові виклики конструктора копій та деструкторів і таким чином покращує загальну продуктивність.

У вашому прикладі не повинно бути справжньої різниці.

vector<string> getseq(char * db_file)

І якщо ви хочете роздрукувати його на main (), слід зробити це в циклі.

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

Яким би приємним не було "повернення за значенням", це такий код, який може призвести до помилки. Розглянемо таку програму:

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

• З: Що станеться, коли буде виконано вищезазначене? В: Коредумп.
• З: Чому компілятор не вловив помилку? Відповідь: Оскільки програма синтаксично, хоча і не семантично, правильна.
• З: Що станеться, якщо ви зміните vecFunc (), щоб повернути посилання? В: Програма працює до кінця і дає очікуваний результат.
• З: У чому різниця? Відповідь: Компілятору не потрібно створювати та керувати анонімними об'єктами. Програміст доручив компілятору використовувати рівно один об'єкт для ітератора та для визначення кінцевої точки, а не два різних об'єкти, як це робить розбитий приклад.

Вищенаведена помилкова програма не вказуватиме на помилки, навіть якщо використовується параметри звітування GNU g ++ -Wall -Wextra -Weffc ++

Якщо потрібно створити значення, то замість виклику vecFunc () два рази буде працювати наступне:

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

Вищезазначене також не створює анонімних об'єктів під час ітерації циклу, але вимагає можливої ​​операції копіювання (яка, як зауважують деякі, може бути оптимізована за певних обставин. Але метод посилання гарантує, що копія не буде створена. Вірячи, що компілятор виконувати RVO не може замінити намагання створити найефективніший код, який ви можете.Якщо ви можете заперечити необхідність компілятора робити RVO, ви попереду гри.

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