Modo efficiente per restituire un vettore std :: in c ++

Quanti dati vengono copiati, quando si restituisce uno std :: vector in una funzione e quanto grande sarà l'ottimizzazione per posizionare lo std :: vector in free-store (sull'heap) e restituire invece un puntatore, cioè è:

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

più efficiente di:

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

?

In C ++ 11, questo è il modo preferito:

std::vector<X> f();

Cioè, ritorno per valore.

Con C ++ 11, std::vectorha la semantica dello spostamento, il che significa che il vettore locale dichiarato nella funzione verrà spostato al ritorno e in alcuni casi anche lo spostamento può essere eliso dal compilatore.

Dovresti restituire per valore.

Lo standard ha una caratteristica specifica per migliorare l'efficienza del ritorno in valore. Si chiama "copy elision", e più specificamente in questo caso "named return value optimization (NRVO)".

I compilatori non devono implementarlo, ma anche in questo caso i compilatori non devono implementare la funzione inlining (o eseguire alcuna ottimizzazione). Ma le prestazioni delle librerie standard possono essere piuttosto scadenti se i compilatori non si ottimizzano e tutti i compilatori seri implementano inlining e NRVO (e altre ottimizzazioni).

Quando viene applicato NRVO, non ci sarà copia nel seguente codice:

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

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

Ma l'utente potrebbe voler fare questo:

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

L'elisione della copia non impedisce una copia qui perché è un'assegnazione piuttosto che un'inizializzazione. Tuttavia, dovresti comunque restituire per valore. In C ++ 11, l'assegnazione è ottimizzata da qualcosa di diverso, chiamato "semantica di spostamento". In C ++ 03, il codice sopra causa una copia e, sebbene in teoria un ottimizzatore possa essere in grado di evitarlo, in pratica è troppo difficile. Quindi, invece di myvec = f(), in C ++ 03 dovresti scrivere questo:

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

C'è un'altra opzione, che è quella di offrire un'interfaccia più flessibile all'utente:

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

È quindi possibile supportare anche l'interfaccia basata su vettori esistente oltre a ciò:

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

Questo potrebbe essere meno efficiente del codice esistente, se il codice esistente utilizza reserve()in un modo più complesso di una semplice quantità fissa in anticipo. Ma se il codice esistente fondamentalmente richiama push_backil vettore ripetutamente, allora questo codice basato su modello dovrebbe essere altrettanto buono.

È ora che pubblichi una risposta su RVO , anche io ...

Se restituisci un oggetto per valore, il compilatore spesso lo ottimizza in modo che non venga costruito due volte, poiché è superfluo costruirlo nella funzione come temporaneo e quindi copiarlo. Questa si chiama ottimizzazione del valore di ritorno: l'oggetto creato verrà spostato invece di essere copiato.

Un linguaggio comune pre-C ++ 11 consiste nel passare un riferimento all'oggetto da riempire.

Quindi non c'è copia del vettore.

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

Se il compilatore supporta l'ottimizzazione del valore di ritorno denominato ( http://msdn.microsoft.com/en-us/library/ms364057(v=vs.80).aspx ), puoi restituire direttamente il vettore purché non sia presente:

1. Percorsi diversi che restituiscono oggetti con nome diverso
2. Più percorsi di ritorno (anche se lo stesso oggetto con nome viene restituito su tutti i percorsi) con stati EH introdotti.
3. L'oggetto denominato restituito viene referenziato in un blocco asm inline.

NRVO ottimizza le chiamate ridondanti del costruttore di copia e del distruttore e quindi migliora le prestazioni complessive.

Non dovrebbero esserci differenze reali nel tuo esempio.

vector<string> getseq(char * db_file)

E se vuoi stamparlo su main () dovresti farlo in un ciclo.

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

Per quanto bello possa essere il "ritorno per valore", è il tipo di codice che può portare in errore. Considera il seguente programma:

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

• D: Cosa succederà quando verrà eseguito quanto sopra? A: Un coredump.
• D: Perché il compilatore non ha rilevato l'errore? R: Perché il programma è sintatticamente, anche se non semanticamente, corretto.
• D: Cosa succede se modifichi vecFunc () per restituire un riferimento? R: Il programma viene eseguito fino al completamento e produce il risultato atteso.
• D: Qual è la differenza? R: Il compilatore non deve creare e gestire oggetti anonimi. Il programmatore ha indicato al compilatore di utilizzare esattamente un oggetto per l'iteratore e per la determinazione dell'endpoint, piuttosto che due oggetti diversi come fa l'esempio rotto.

Il programma errato di cui sopra non indicherà errori anche se si utilizzano le opzioni di reporting GNU g ++ -Wall -Wextra -Weffc ++

Se è necessario produrre un valore, quanto segue funzionerà al posto di chiamare due volte vecFunc ():

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

Quanto sopra, inoltre, non produce oggetti anonimi durante l'iterazione del ciclo, ma richiede una possibile operazione di copia (che, come alcuni notano, potrebbe essere ottimizzata in alcune circostanze. Ma il metodo di riferimento garantisce che nessuna copia verrà prodotta. Credendo che il compilatore lo farà eseguire RVO non è un sostituto per cercare di costruire il codice più efficiente possibile.Se puoi discutere la necessità che il compilatore esegua RVO, sei in vantaggio.

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