Pourquoi l'addition élément par élément dans deux boucles séparées est-elle plus rapide que dans une seule boucle combinée ?

Bonjour à tous ! J'écris en C++ depuis quelques mois et j'ai rencontré un comportement de performance très étrange. J'ai deux tableaux : `a` et `b` de taille 200000000 éléments (environ 800 Mo chacun). Je veux additionner élément par élément et stocker le résultat dans le tableau `c`, puis multiplier chaque élément de `c` par 2 et stocker dans `d`. J'ai écrit deux variantes de code : **Variante 1 (deux boucles séparées) :** ```cpp for (int i = 0; i < n; ++i) { c[i] = a[i] + b[i]; } for (int i = 0; i < n; ++i) { d[i] = c[i] * 2; } ``` **Variante 2 (une seule boucle combinée) :** ```cpp for (int i = 0; i < n; ++i) { c[i] = a[i] + b[i]; d[i] = c[i] * 2; } ``` Je m'attendais à ce que la deuxième variante soit plus rapide, car elle fait tout en un seul passage. Mais en pratique (compilateur MSVC, flags /O2, architecture x64), la première variante est **presque deux fois plus rapide** ! Pourquoi ? Pourtant, dans la deuxième variante, il y a moins d'opérations d'indexation et moins de vérifications de limites. Expliquez, s'il vous plaît, ce qui se passe sous le capot. Est-ce lié