Pourquoi `push_back` déclenche-t-il plusieurs appels de constructeur de copie dans un vecteur ?

Vector Push_back et le mystère des invocations multiples de constructeurs de copie

Lorsque vous travaillez avec des vecteurs, on peut s'attendre à ce que l'opération push_back ne nécessite qu'une poignée d'appels de constructeur de copie. Cependant, certains cas peuvent révéler un comportement inattendu, comme des appels multiples.

Considérez l'extrait de code suivant :

<code class="cpp">class Myint {
    int my_int;
public:
    Myint() : my_int(0) { /* ... */ }
    Myint(const Myint& x) : my_int(x.my_int) { /* ... */ }
};

int main() {
    vector<Myint> myints;
    Myint x;

    myints.push_back(x); // Call 1
    x.set(1);
    myints.push_back(x); // Call 2
}</code>

Intuitivement, nous nous attendrions à deux appels de constructeur de copie : un pour le premier push_back et un autre pour le second. Cependant, le résultat raconte une autre histoire :

Call 1 (default constructor)
Call 2 (copy constructor: my_int = 0)
Call 3 (copy constructor: my_int = 0)
Call 4 (copy constructor: my_int = 1)

Pourquoi les appels supplémentaires ?

Dynamique vectorielle interne

En interne, un vecteur alloue généralement une certaine quantité de mémoire pour stockage. Lorsque l'espace alloué est épuisé, le vecteur doit réallouer plus de mémoire. Cette réallocation déclenche une copie des éléments existants dans la nouvelle mémoire.

Dans le code donné, le deuxième push_back nécessite une réallocation. Malgré le fait que le constructeur de Myint n'est invoqué que deux fois, le constructeur de copie est utilisé trois fois. En effet, le constructeur de copie est utilisé pour déplacer le premier élément dans la mémoire nouvellement allouée, initialisée avec sa valeur d'origine (my_int = 0), puis le constructeur de copie est à nouveau invoqué pour créer le deuxième élément, initialisé avec la valeur mise à jour ( my_int = 1).

Optimisation des performances

Pour atténuer ces copies inutiles, il est recommandé de :

• Réserver la mémoire : En augmentant la capacité initiale du vecteur, vous pouvez empêcher la réallocation et minimiser les opérations de copie.
• Utilisez Emplace_back : Cette méthode vous permet de construire directement un élément sur place, en évitant les copies ou les déplacements.

Dans ce cas, utiliser la réserve pour pré-allouer de la mémoire réduirait efficacement les appels du constructeur de copie à deux. De plus, emplace_back(0) éliminerait complètement la copie, ce qui entraînerait des performances optimales.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!