utiliser la fonction à l'intérieur de la boucle qui renvoie le vecteur

Question

J'ai une fonction myfun qui va retourner un vecteur.

vector<double> myfun(const size_t k, const size_t i){ 
    vector<double> v(k); 
    // do some computation with remaining arguments 
    return v; 
} 

Ensuite, je vais l'utiliser dans la boucle pour mettre à jour v et utiliser v pour obtenir un résultat.

int main(){ 
    size_t N = 100; // iteration size 
    size_t n = 10; // size of v 
    vector<double> result(N); 
    vector<double> v(n); 
    for(size_t i = 0; i<N; i++){ 
     v = myfun(n,i); // compute for each iteration 
     result[i] = compute_some_value(v); 
    } 
} 

Alors, ma question est:

• Est-ce que v effectivement alloué à l'intérieur de myfun chaque fois qu'il est appelé?
• Si c'est le cas, que devient le v?
• Aussi, est-il préférable d'utiliser juste utiliser l'adresse comme void myfun(some_args, vector<double> &v) pour l'argument de sortie v?

Answer 1

Est-ce que v est réellement alloué à l'intérieur de myfun chaque fois qu'il est appelé?

Oui

Si elle le fait, ce qui se passe à l'ancienne v?

Il est écrasé.

Aussi, est-il préférable d'utiliser simplement utiliser l'adresse comme myfun vide (some_args, vecteur & v) pour l'argument de sortie v?

Oui, il est préférable de passer le vecteur par référence en fonction de vos opérations.

Vous pouvez le faire de cette façon

double compute_some_value(vector<double> & v, const size_t i) { 
    v.clear(); // use if required 
    // do some computation with remaining arguments and return 
} 

int main() { 
    size_t N = 100; // iteration size 
    size_t n = 10; // size of v 
    vector<double> result(N), v(n); 
    for (size_t i = 0; i < N; i++) { 
     result[i] = compute_some_value(v, i); 
    } 
} 

Answer 2

Est-ce que v effectivement alloué à l'intérieur de myfun chaque fois qu'il est appelé?

Oui

Si elle le fait, ce qui se passe à l'ancienne v?

Lorsque v est hors de portée, le destructeur est appelé et l'objet est détruit. C'est pourquoi vous n'avez pas vraiment besoin d'appeler le destructeur d'une classe explicitement.

Aussi, est-il préférable d'utiliser simplement utiliser l'adresse comme myfun vide (some_args, vecteur & v) pour l'argument de sortie v?

Cela dépend vraiment de votre cas d'utilisation. Si cela concerne des problèmes de mémoire, il vaut mieux passer la référence.