Allocation dynamique C++ de tableaux avec exemple

Qu'est-ce qu'un tableau dynamique ?

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

Une fois qu'un tableau a été créé, sa taille ne peut pas être modifié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 de mémoire d'un certain facteur en cas de besoin.

Dans ce tutoriel C++, vous apprendrez

• Qu'est-ce qu'un tableau dynamique ?
• Facteurs impactant les performances des baies dynamiques
• Le nouveau mot clé
• Initialisation des tableaux alloués dynamiquement
• Redimensionnement des tableaux
• Suppression dynamique des tableaux

Facteurs impactant les performances des baies dynamiques

La taille initiale de la baie et son facteur de croissance déterminent ses performances. Notez les points suivants :

1. Si un tableau a une petite taille et un petit facteur de croissance, il continuera à réallouer de la mémoire plus souvent. Cela réduira les performances de la baie.
2. Si un tableau a une grande taille et un grand facteur de croissance, il aura une énorme quantité de mémoire inutilisée. De ce fait, les opérations de redimensionnement peuvent prendre plus de temps. Cela réduira les performances de la baie.

Le nouveau mot clé

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

Syntaxe :

Le nouveau mot-clé prend la syntaxe suivante :

pointer_variable = new data_type;

Le pointer_variable est le nom de la variable pointeur.

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

Le mot-clé renvoie ensuite un pointeur vers le premier élément. Après avoir créé le tableau dynamique, nous pouvons le supprimer à l'aide du 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. Incluez 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. Appelez la fonction main(). La logique du programme doit être ajoutée dans le corps de la fonction.
4. Déclarez deux variables entières x et n.
5. Imprimer du texte sur la console invitant l'utilisateur à entrer la valeur de la variable n.
6. Lire la saisie de l'utilisateur depuis le clavier et l'affecter à la variable n.
7. Déclarez un tableau pour contenir un total de n entiers et affectez-le à la variable de pointeur *arr.
8. Imprimer un message invitant l'utilisateur à entrer n nombre d'éléments.
9. Utilisez une boucle for pour créer une variable de boucle x afin de parcourir les éléments saisis par l'utilisateur.
10. Lire les éléments saisis par l'utilisateur et les stocker dans le tableau arr.
11. Fin du corps de la boucle for.
12. Imprimez du texte sur la console.
13. Utilisez une boucle for pour créer une variable de boucle x afin de parcourir les éléments du tableau.
14. Imprimez les valeurs contenues dans le tableau nommé arr sur la console.
15. Fin du corps de la boucle for.
16. Le programme doit renvoyer une valeur en cas de réussite.
17. Fin du corps de la fonction main().

REMARQUE :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 lors de 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, la longueur indique le nombre d'éléments à ajouter au tableau. Comme nous devons initialiser le tableau à 0, celui-ci doit rester vide.

Nous pouvons initialiser un tableau dynamique à l'aide d'une liste d'initialisation. Créons un exemple qui le démontre.

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. Incluez le fichier d'en-tête iostream dans notre programme pour utiliser ses fonctions.
2. Incluez l'espace de noms std dans notre programme pour utiliser ses classes sans l'appeler.
3. Appelez la fonction main(). La logique du programme doit être ajoutée dans le corps de la fonction.
4. Déclarez une variable entière nommée x.
5. Déclarez un tableau dynamique nommé tableau à l'aide d'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. Imprimez du texte sur la console. Le endl est un mot-clé C++ qui signifie ligne de fin. Il déplace le curseur à la phrase suivante.
7. Utilisez une boucle for pour parcourir les éléments du tableau.
8. Imprime le contenu du tableau nommé tableau sur la console.
9. Fin du corps de la boucle for.
10. Le programme doit renvoyer une valeur en cas de réussite.
11. Fin du corps de la fonction main().

Redimensionner les tableaux

La longueur d'un tableau dynamique est définie pendant le temps d'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 dynamiquement un nouveau tableau, en copiant les éléments, puis en effaçant l'ancien tableau.

Remarque :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 objectif atteint. L'instruction de suppression peut vous aider à accomplir cela. L'espace mémoire libéré peut alors ê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é.

Remarque :

Pour supprimer un tableau dynamique de la mémoire de l'ordinateur, vous devez utiliser delete[] au lieu de delete. Le [] demande au CPU de supprimer plusieurs variables plutôt qu'une seule. L'utilisation de delete au lieu de delete[] lorsqu'il s'agit d'un tableau dynamique peut entraîner des problèmes. Des exemples de tels problèmes incluent les fuites de mémoire, la corruption de données, les 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. Appelez la fonction main(). La logique du programme doit être ajoutée dans le corps de la fonction.
4. Déclarez deux variables x et n du type de données entier.
5. Imprimez du texte sur la console. Le texte demandera à l'utilisateur d'indiquer le nombre de chiffres qu'il saisira.
6. Lire les entrées de l'utilisateur à partir du clavier. La valeur d'entrée sera affectée à la variable n.
7. Déclarer une variable de pointeur *arr. Le tableau arr réservera de la mémoire pour stocker un total de n entiers.
8. Imprimer un message sur la console invitant l'utilisateur à entrer n chiffres.
9. Créez une boucle for et la variable de boucle x pour parcourir les nombres saisis 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. Imprimez du texte sur la console.
13. Utilisez une boucle for et la variable de boucle x pour parcourir le contenu du tableau arr.
14. Imprimez les valeurs du tableau arr sur la console.
15. Fin du corps de la boucle for.
16. Imprimer une ligne vide sur la console.
17. Libérez la mémoire du tableau arr.
18. Le programme renverra 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ée.
• Avec ces types de tableaux, la taille de la mémoire est déterminée au moment de la compilation.
• Les tableaux dynamiques sont différents. Leurs tailles peuvent être modifiées pendant l'exécution.
• Dans les tableaux dynamiques, la taille est déterminée lors de l'exécution.
• Les tableaux dynamiques en C++ sont déclarés à l'aide du nouveau mot-clé.
• Nous utilisons des crochets pour spécifier le nombre d'éléments à stocker dans le tableau dynamique.
• Une fois le tableau terminé, nous pouvons libérer de la mémoire à l'aide de l'opérateur de suppression.
• Utilisez l'opérateur de suppression avec [] pour libérer la mémoire de tous les éléments du tableau.
• Une suppression 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 à l'aide d'un initialiseur de liste, nous n'utilisons pas l'opérateur "=".