Maîtriser l'allocation de tableaux dynamiques en C++ : Guide pratique avec exemples de code

Qu'est-ce qu'un tableau dynamique ?

Un tableau dynamique est assez similaire à un tableau régulier, mais sa taille est modifiable pendant l'exécution du programme. Les éléments d'un tableau dynamique occupent un bloc de mémoire contigu.

Une fois qu'un tableau a été créé, sa taille ne peut pas être changée. Cependant, un tableau dynamique est différent. Un tableau dynamique peut augmenter sa taille même après avoir été rempli.

Lors de la création d'un tableau, une quantité prédéterminée de mémoire lui est allouée. Ce n'est pas le cas avec un tableau dynamique car il augmente sa taille mémoire par un certain facteur quand il y a un besoin.

Dans ce tutoriel C++, vous apprendrez :

• Qu'est-ce qu'un tableau dynamique ?
• Facteurs impactant la performance des tableaux dynamiques
• Le mot-clé new
• Initialisation des tableaux alloués dynamiquement
• Redimensionnement des tableaux
• Suppression dynamique des tableaux

Facteurs impactant la performance des tableaux dynamiques

La taille initiale du tableau et son facteur de croissance déterminent sa performance. Notez les points suivants :

1. Si un tableau a une petite taille et un petit facteur de croissance, il continuera à réallouer la mémoire plus souvent. Cela réduira la performance du tableau.
2. Si un tableau a une grande taille et un grand facteur de croissance, il aura un énorme morceau de mémoire inutilisée. À cause de cela, les opérations de redimensionnement peuvent prendre plus de temps. Cela réduira la performance du tableau.

Le mot-clé new

En C++, nous pouvons créer un tableau dynamique en utilisant le mot-clé new. Le nombre d'éléments à allouer est spécifié entre crochets. Le nom du type doit précéder cela. Le nombre demandé d'éléments sera alloué.

Syntaxe :

Le mot-clé new prend la syntaxe suivante :

variable_pointeur = new type_donnee[taille];

La variable_pointeur est le nom de la variable pointeur.

Le type_donnee doit être un type de données C++ valide.

Le mot-clé retourne alors un pointeur vers le premier élément. Après avoir créé le tableau dynamique, nous pouvons le supprimer en utilisant le mot-clé delete.

Exemple 1 :

#include<iostream>
using namespace std;
int main() {
    int x, n;
    cout << "Enter the number of items:" << "\n";
    cin >> n;
    int *arr = new int[n];
    cout << "Enter " << n << " items" << endl;
    for (x = 0; x < n; x++) {
        cin >> arr[x];
    }
    cout << "You entered: ";
    for (x = 0; x < n; x++) {
        cout << arr[x] << " ";
    }
    return 0;
}

Sortie :

Voici une capture d'écran du code :

Explication du code :

1. Inclure le fichier d'en-tête iostream dans notre programme pour utiliser ses fonctions.
2. Inclure l'espace de noms std dans notre programme afin d'utiliser ses classes sans l'appeler.
3. Appeler la fonction main(). La logique du programme doit être ajoutée dans le corps de la fonction.
4. Déclarer deux variables entières x et n.
5. Afficher du texte sur la console invitant l'utilisateur à entrer la valeur de la variable n.
6. Lire l'entrée utilisateur depuis le clavier et l'assigner à la variable n.
7. Déclarer un tableau pour contenir un total de n entiers et l'assigner à la variable pointeur *arr.
8. Afficher un message invitant l'utilisateur à entrer n éléments.
9. Utiliser une boucle for pour créer une variable de boucle x pour itérer sur les éléments entrés par l'utilisateur.
10. Lire les éléments entrés par l'utilisateur et les stocker dans le tableau arr.
11. Fin du corps de la boucle for.
12. Afficher du texte sur la console.
13. Utiliser une boucle for pour créer une variable de boucle x pour itérer sur les éléments du tableau.
14. Afficher les valeurs contenues dans le tableau nommé arr sur la console.
15. Fin du corps de la boucle for.
16. Le programme doit retourner une valeur à l'issue d'une exécution réussie.
17. Fin du corps de la fonction main().

NOTE : Dans l'exemple ci-dessus, l'utilisateur est autorisé à spécifier n'importe quelle taille pour le tableau pendant l'exécution. Cela signifie que la taille du tableau est déterminée pendant l'exécution.

Initialisation des tableaux alloués dynamiquement

Il est facile d'initialiser un tableau dynamique à 0.

Syntaxe :

int *array{ new int[length]{} };

Dans la syntaxe ci-dessus, length désigne le nombre d'éléments à ajouter au tableau. Comme nous devons initialiser le tableau à 0, cela doit être laissé vide.

Nous pouvons initialiser un tableau dynamique en utilisant une liste d'initialisation. Créons un exemple qui démontre cela.

Exemple 2 :

#include <iostream>
using namespace std;
int main(void) {
    int x;
    int *array{ new int[5]{ 10, 7, 15, 3, 11 } };
    cout << "Array elements: " << endl;
    for (x = 0; x < 5; x++) {
        cout << array[x] << endl;
    }
    return 0;
}

Sortie :

Voici une capture d'écran du code :

Explication du code :

1. Inclure le fichier d'en-tête iostream dans notre programme pour utiliser ses fonctions.
2. Inclure l'espace de noms std dans notre programme pour utiliser ses classes sans l'appeler.
3. Appeler la fonction main(). La logique du programme doit être ajoutée dans le corps de la fonction.
4. Déclarer une variable entière nommée x.
5. Déclarer un tableau dynamique nommé array en utilisant une liste d'initialisation. Le tableau contiendra 5 éléments entiers. Notez que nous n'avons pas utilisé l'opérateur "=" entre la longueur du tableau et la liste d'initialisation.
6. Afficher du texte sur la console. Le endl est un mot-clé C++ qui signifie fin de ligne. Il déplace le curseur à la phrase suivante.
7. Utiliser une boucle for pour itérer sur les éléments du tableau.
8. Afficher le contenu du tableau nommé array sur la console.
9. Fin du corps de la boucle for.
10. Le programme doit retourner une valeur à l'issue d'une exécution réussie.
11. Fin du corps de la fonction main().

Redimensionnement des tableaux

La longueur d'un tableau dynamique est définie au moment de l'allocation.

Cependant, C++ n'a pas de mécanisme intégré pour redimensionner un tableau une fois qu'il a été alloué.

Vous pouvez cependant surmonter ce défi en allouant un nouveau tableau dynamiquement, en copiant les éléments, puis en effaçant l'ancien tableau.

Note : cette technique est sujette aux erreurs, essayez donc de l'éviter.

Suppression dynamique des tableaux

Un tableau dynamique doit être supprimé de la mémoire de l'ordinateur une fois son but accompli. L'instruction delete peut vous aider à accomplir cela. L'espace mémoire libéré peut ensuite être utilisé pour contenir un autre ensemble de données. Cependant, même si vous ne supprimez pas le tableau dynamique de la mémoire de l'ordinateur, il sera supprimé automatiquement une fois le programme terminé.

Note :

Pour supprimer un tableau dynamique de la mémoire de l'ordinateur, vous devez utiliser delete[], au lieu de delete. Les [] instruisent le CPU de supprimer plusieurs variables plutôt qu'une seule variable. L'utilisation de delete au lieu de delete[] lors de la manipulation d'un tableau dynamique peut entraîner des problèmes. Exemples de tels problèmes : fuites de mémoire, corruption de données, plantages, etc.

Exemple 3 :

#include<iostream>
using namespace std;
int main() {
    int x, n;
    cout << "How many numbers will you type?" << "\n";
    cin >> n;
    int *arr = new int[n];
    cout << "Enter " << n << " numbers" << endl;
    for (x = 0; x < n; x++) {
        cin >> arr[x];
    }
    cout << "You typed: ";
    for (x = 0; x < n; x++) {
        cout << arr[x] << " ";
    }
    cout << endl;
    delete [] arr;
    return 0;
}

Sortie :

Voici une capture d'écran du code :

Explication du code :

1. Inclure le fichier d'en-tête iostream dans notre programme afin d'utiliser ses fonctions.
2. Inclure l'espace de noms std dans notre programme afin d'utiliser ses classes sans l'appeler.
3. Appeler la fonction main(). La logique du programme doit être ajoutée dans le corps de la fonction.
4. Déclarer deux variables x et n de type entier.
5. Afficher du texte sur la console. Le texte demandera à l'utilisateur d'indiquer le nombre de nombres qu'il entrera.
6. Lire l'entrée utilisateur depuis le clavier. La valeur d'entrée sera assignée à la variable n.
7. Déclarer une variable pointeur *arr. Le tableau arr réservera de la mémoire pour stocker un total de n entiers.
8. Afficher un message sur la console invitant l'utilisateur à entrer n nombres.
9. Créer une boucle for et la variable de boucle x pour itérer sur les nombres entrés par l'utilisateur.
10. Lire les nombres entrés par l'utilisateur et les stocker dans le tableau arr.
11. Fin du corps de la boucle for.
12. Afficher du texte sur la console.
13. Utiliser une boucle for et la variable de boucle x pour itérer sur le contenu du tableau arr.
14. Afficher les valeurs du tableau arr sur la console.
15. Fin du corps de la boucle for.
16. Afficher une ligne vide sur la console.
17. Libérer la mémoire du tableau arr.
18. Le programme retournera une valeur lorsqu'il se terminera avec succès.
19. Fin du corps de la fonction main().

Résumé :

• Les tableaux réguliers ont une taille fixe. Vous ne pouvez pas modifier leur taille une fois déclarés.
• Avec ces types de tableaux, la taille mémoire est déterminée pendant la compilation.
• Les tableaux dynamiques sont différents. Leurs tailles peuvent être changées pendant l'exécution.
• Dans les tableaux dynamiques, la taille est déterminée pendant l'exécution.
• Les tableaux dynamiques en C++ sont déclarés en utilisant le mot-clé new.
• Nous utilisons des crochets pour spécifier le nombre d'éléments à stocker dans le tableau dynamique.
• Une fois fini avec le tableau, nous pouvons libérer la mémoire en utilisant l'opérateur delete.
• Utilisez l'opérateur delete avec [] pour libérer la mémoire de tous les éléments du tableau.
• Un delete sans [] libère la mémoire d'un seul élément.
• Il n'y a pas de mécanisme intégré pour redimensionner les tableaux C++.
• Pour initialiser un tableau en utilisant un initialiseur de liste, nous n'utilisons pas l'opérateur "=".