C++ Allocation dynamique de tableaux avec exemple

Lors de la création d’un tableau, une quantité de mémoire prédéterminée lui est allouée. Ce n'est pas le cas d'un tableau dynamique car il augmente la taille de sa mémoire d'un certain facteur lorsque cela est nécessaire.

Facteurs ayant un impact sur les performances des tableaux dynamiques

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

1. Si une baie a une petite taille et un faible facteur de croissance, elle 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 facteur de croissance important, il aura une énorme quantité de mémoire inutilisée. Pour cette raison, les opérations de redimensionnement peuvent prendre plus de temps. Cela réduira les performances de la baie.

Le nouveau mot-clé

In 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 d'éléments demandé sera alloué.

Syntaxe

Le mot-clé new prend la syntaxe suivante :

pointer_variable = new data_type;

La variable pointer_variable est le nom du variable de pointeur.

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

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 son fonctions.
2. Incluez 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. Imprimez du texte sur la console invitant l'utilisateur à saisir la valeur de la variable n.
6. Lisez les entrées de l'utilisateur à partir du clavier et attribuez-les à la variable n.
7. Déclarez un tableau pour contenir un total de n entiers et attribuez-le à la variable pointeur *arr.
8. Imprime un message invitant l'utilisateur à saisir n nombre d'éléments.
9. Utilisez une boucle for pour créer une variable de boucle x pour 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 du pour la boucle.
12. Imprimez du texte sur la console.
13. Utilisez une boucle for pour créer une variable de boucle x pour 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 de la valeur une fois terminé.
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 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, la longueur indique le nombre d'éléments à ajouter au tableau. Puisque 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 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. 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é array à 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. La fin est un C++ mot-clé qui signifie fin de ligne. Il déplace le curseur vers la phrase suivante.
7. Utilisez une boucle for pour parcourir les éléments du tableau.
8. Imprimez le contenu du tableau nommé array sur la console.
9. Fin du corps de la boucle for.
10. Le programme doit renvoyer de la valeur une fois terminé.
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.

Toutefois, 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 de tableaux

Un tableau dynamique doit être supprimé de la mémoire de l'ordinateur une fois son objectif rempli. L'instruction delete peut vous aider à y parvenir. 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 automatiquement supprimé 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 processeur de supprimer plusieurs variables plutôt qu'une seule variable. 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 des 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. Incluez le fichier d'en-tête iostream dans notre programme afin d'utiliser ses fonctions.
2. Incluez 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 de 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éclarez une variable de pointeur *arr. Le tableau arr réservera de la mémoire pour stocker un total de n entiers.
8. Imprimez un message sur la console invitant l'utilisateur à saisir 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 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 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. Imprimez une ligne vide sur la console.
17. Libérez la mémoire du tableau arr.
18. Le programme renverra une valeur une fois terminé 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.
• Tableaux dynamiques dans C++ sont déclarés à l’aide du mot-clé new.
• Nous utilisons des crochets pour spécifier le nombre d'éléments à stocker dans le tableau dynamique.
• Une fois terminé avec le tableau, nous pouvons libérer de la mémoire en utilisant l'opérateur delete.
• 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 C++ tableaux.
• Pour initialiser un tableau à l'aide d'un initialiseur de liste, nous n'utilisons pas l'opérateur « = ».