Discussion :

[Matthieu76]

Bonjour, quelle est le mieux et pourquoi ? Quelle est le plus rapide ? (Et venez pas faire c**** à dire que la vitesse c'est pas le plus important et bla bla bla lisibilité bla bla bla. Je le sais très bien)

SOLUTION 1 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
for(unsigned int i = 0; i < v.size(); i++) // D’ailleurs, i++ ou ++i ?
{
        v[i] = 1;
}

SOLUTION 2 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
for (auto& i : v) // Convertie en solution 3 à la compilation ?
{
        i = 1;
}

SOLUTION 3 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
for (std::vector<int>::iterator i = myvector.begin() ; i != myvector.end(); i++)
{
        *i = 1;
}

Je sais que ce sujet à été maintes et maintes fois traiter mais je voulais votre avis sur la question.

Et sinon dans quelle ordre est-il péférable de parcourir un vector, de 0 à size ou de size à 0 ?

[JolyLoic]

La 1 et la 3 présentent le risque que le compilateur ne sorte pas de la boucle le calcul de v.size() / v.end().
Mais je crois que globalement les différences, s'il y en a, vont être minimes, et que si tu en es à ce niveau de finesse, il y aura probablement d'autres choses qui vaudront le coup d'être regardées (vector de structures / structure de vectors, vectorisation des instructions...), et les resultats peuvent dépendre de la situation (donc, mesurer, mesurer et mesurer).

Pour ta deuxième question, je ne sais pas trop. J'aurais tendance à penser sans aucune preuve qu'aller de 0 à n est plus courant, dont probablement mieux optimisé.

[Bktero]

Je dirais la 2, à cause d'une expérimentation que j'ai faite ces jours-ci (https://gradot.wordpress.com/2018/02...-ce-quil-fait/) où gcc optimisait (un peu) mieux un parcours de tableau avec cette écriture.

L'écriture 2 est sans ambiguïté pour le compilateur qui peut alors appliquer toutes les optimisations à sa disposition.

[dalfab]

Ici j'utiliserais plutôt une quatrième option :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

std::fill( begin(v), end(v), 1 );

Si le compilateur fait son boulot correctement, toutes les 4 devraient donner exactement le même code. La première préconise l'utilisation d'index, les 3 autres l'utilisation d'itérateurs, mais le compilateur peut voir qu'il n'y a aucun effet de bord et choisir son moyen d'itérer.
Les 4 ajoutent inutilement une contrainte de faire une mise à jour dans l'ordre. L'optimiseur pourrait ici effectuer une mise à jour en partant de la fin car cela est parfois un peu plus optimal (on peut ôter une contrainte sur un registre processeur) à condition qu'il détecte qu'ici il n'y a aucun effet de bord.
On pourrait "aider" l'optimiseur en utilisant std::fill( std::execution::par_unseq , begin(v), end(v), 1 ); pour mieux signifier que l'on se fout ici de la chronologie, mais là c'est peut être risqué quand on voit que des optimiseurs n'arrivent pas à voir que les 4 premiers cas sont vraiment identiques, et pourrait ici compliquer inutilement le code.

[LittleWhite]

Bonjour,

La solution avec std::fill est intéressante, notamment car cela pourrait être parallélisé par l'implémenteur. J'ose croire que c'est vers quoi les nouvelles version tendent, non ?
Par contre, ce n'est pas un parcours générique, c'est un remplissage .

[Matthieu76]

Par contre, ce n'est pas un parcours générique, c'est un remplissage .

Oui, ma question s'orientait plus sur le parcours du vector que sur le remplissage de celui-ci.

La solution 2 me parait effectivement la mieux mais je suis obligé d'utiliser sur la solution 1 quand il y a 2 vectors dans ma boucle c'est pour cela que dans mon code j'utilise tout le temps la solution 1, en plus je la trouve plus compréhensible car dans mon code j'ai des variables du genre numberOfNeurons = neurons.size().

Avec des trucs du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
for(unsigned int i = 0; i < numberOfNeurons; i++)
{
    result[i] = neurons[i].calculateOutput();
}

Es-ce que cette implémentation est correct ? Avez-vous autre chose de mieux à proposer ?

Personnellement je préfère ne pas mélanger les implémentations, du coup j'utilise tout le temps la solution 1.