C ++ Changer la taille du tableau

Une fois qu'un tableau a été alloué, il n'y a pas de mécanisme intégré pour le redimensionner dans le langage de programmation C ++. Par conséquent, nous pouvons éviter ce problème en générant dynamiquement un nouveau tableau, en copie sur le contenu, puis en supprimant l'ancien tableau. Cet article se concentre sur la façon d'allouer la mémoire dynamiquement dans un tableau et d'ajuster la taille du tableau en fonction de l'entrée utilisateur. Il s'agit d'une stratégie très importante dans la programmation car elle assure une utilisation efficace de la mémoire. Lorsque nous essayons d'insérer un nouvel élément dans un tableau dynamique, il augmente automatiquement jusqu'à ce qu'il n'y ait plus de stockage pour le nouvel élément. En règle générale, la région double la taille.

Qu'est-ce qu'un tableau dynamique?

Un tableau dynamique est identique à un tableau standard en apparence, mais sa taille peut être modifiée pendant que le code s'exécute. Les composants dynamiques du tableau prennent un bloc de mémoire contigu. Une fois qu'un tableau a été défini, il n'est pas possible de modifier sa taille. En revanche, un tableau dynamique n'est pas comme un tableau statique. Même après avoir été occupée, un tableau dynamique peut étendre sa taille. Les éléments peuvent être ajoutés constamment à la position finale du tableau dynamique en utilisant l'espace réservé jusqu'à ce qu'il soit entièrement occupé.

Facteurs clés du tableau dynamique en C ++:

La performance du tableau est déterminée par sa taille de départ et son facteur de croissance. Prenez note des points suivants:

• Si un tableau est de taille modeste et a un facteur de croissance plus lent, il continuera de réaffecter la mémoire plus souvent. En conséquence, la performance du tableau en souffrira.
• Si un tableau est plus grand et a un facteur de croissance élevé, il aura une grande quantité de mémoire inutilisée. En conséquence, les processus de redimensionnement peuvent prendre plus de temps. La performance du tableau en souffrira également en conséquence

Exemple 1:

Le nouveau mot-clé est utilisé pour créer un tableau dynamique dans le programme C ++ suivant. Après cela, le mot-clé renvoie une référence au premier élément. La section d'en-tête a le fichier de bibliothèque iOStream inclus pour utiliser ses méthodes. Le fichier d'espace de noms est également inclus, ce qui permet d'utiliser sa classe sans être appelé. Ensuite, la fonction principale est invoquée dans laquelle nous avons déclaré deux variables «p» et «num» du type de données entier.

Dans l'étape suivante, l'instruction COUT imprime l'instruction «Entrez les numéros». La commande CIN prend les entrées de l'utilisateur et l'attribue à la variable «num». L'étape suivante a la variable de pointeur «tableau» qui contient les valeurs entières de la variable «num». Le numéro entré de l'utilisateur sera imprimé à l'aide de la commande cout. Ensuite nous avons pour condition de boucle qui itéère sur chaque élément entré par l'utilisateur. Le tableau comme «tableau» est déclaré dans la commande CIN qui lit l'entrée entrée par l'utilisateur.

Après la fin de la boucle, l'instruction «Vos numéros sont» imprimeront sur l'écran de la console. Encore une fois, nous avons un pour condition de boucle Mais cette fois c'est pour condition de boucle itérer sur un éventail d'éléments. Notez que nous avons permis à un utilisateur de définir la taille du tableau. En conséquence, la taille du tableau est définie lors de l'exécution.

#inclure
Utilisation de Namespace Std;
int main()
int p, num;
couter<< "Enter the numbers:" num;
int * array = new int (num);
couter<< "Enter " << num << " numbers" <pour (p = 0; p> array [p];

couter<< "Your numbers are: ";
pour (p = 0; p < num; p++)
couter<< Array[p] << " ";

couter<< "\n ";
retour 0;

L'utilisateur est invité à saisir le numéro dans l'invite de la console. Après entrée, le numéro de taille du tableau affiche les nombres de taille de tableau spécifiée. Le tableau résultant est affiché sur l'invite de la console d'Ubuntu.

Exemple 2:

Une liste d'initialisateur peut être utilisée pour définir un tableau dynamique. Illustrons cela avec un exemple pour voir comment cela fonctionne. Tout d'abord, nous avons ajouté le fichier ioStream et le fichier d'espace de noms std dans la section d'en-tête. Après cela, nous avons invoqué la fonction principale. La logique du programme doit être incluse dans le corps de la fonction. Ensuite, nous avons défini une variable comme «A» du type de données entier.

Après avoir déclaré la variable entière, nous avons une déclaration dynamique du tableau comme «ARR» qui utilise une liste d'initialisateur. Nous avons quatre entrées entières dans le tableau. La commande cout imprimera l'énoncé «éléments du tableau» avant d'afficher les éléments du tableau.

Dans l'étape suivante, nous avons A pour boucle qui itéère sur les éléments présents dans un tableau spécifié. Grâce à la commande cout, les éléments du tableau donné seront imprimés sur l'invite de la console.

#inclure
Utilisation de Namespace Std;
int main (void)
int a;
int * arr new int [4] 9, 23, 1, 17;
couter<< "Elements of Array: " <pour (a = 0; a < 4; a++)
couter<
retour 0;

Ce qui suit est le résultat que nous avons obtenu de l'exécution du programme ci-dessus:

Exemple 3:

Une fois l'objectif du tableau dynamique atteint, il doit être supprimé de la mémoire de l'ordinateur. L'expression de suppression peut être utilisée pour faire ce que l'espace mémoire est gratuit et utilisé pour stocker des données supplémentaires. Nous devons utiliser Supprimer [] pour supprimer le tableau dynamique de la mémoire du système. Le support carré [] avec le mot-clé Supprimer les commandes le CPU pour supprimer de nombreuses variables plutôt qu'un seul.

Commençons la mise en œuvre du programme. Nous avons importé le fichier requis dans la section d'en-tête. Ensuite, la fonction principale est appelée. Les variables entières «i» et «non» sont déclarées dans la fonction principale. Après avoir défini ces variables, nous avons l'instruction COUT «numéro d'entrée» qui est pour l'utilisateur de saisir le numéro. Nous obtenons un numéro de l'utilisateur et l'enregistrons dans la variable «non» en utilisant la commande CIN.

Ensuite, déclarez une variable de pointeur «Myarr» qui stocke les entiers dans la mémoire. Le numéro entré par l'utilisateur sera imprimé dans la deuxième commande cout de ce programme. Le pour boucle La déclaration est utilisée pour l'itération sur le numéro entré de l'utilisateur. En fin de compte, nous avons construit la déclaration de suppression [] qui efface le tableau donné dans le programme et libère l'espace dans la mémoire.

#inclure
Utilisation de Namespace Std;
int main()
int i, non;
couter<< "Input Number:" no;
int * myarr = new int (no);
couter<< "Input " << no << " numbers" <pour (i = 0; i> Myarr [i];

couter<< "Input numbers are: ";
pour (i = 0; i< no; i++)
couter<
couter<supprimer [] Myarr;
retour 0;

Lors de l'exécution du programme, nous avons obtenu la sortie suivante. Lorsque le programme est résilié, le tableau sera supprimé.

Exemple 4:

Nous pouvons définir dynamiquement un tableau de pointeur de taille «x», puis allouer la mémoire de la taille «y» dynamiquement pour chaque cul de ligne observé dans l'exemple suivant. Au début, nous avons défini la matrice dans la section d'en-tête. À l'étape suivante, nous avons la fonction principale où nous avons une variable de pointeur «ARR». La variable du pointeur contient le tableau de taille «x».

Maintenant le pour la déclaration de boucle alloue à chaque ligne une taille de mémoire «y». Ensuite, nous avons une boucle imbriquée pour attribuer dynamiquement des valeurs à une mémoire qui a été allouée. La fonction Rand générera un nombre aléatoire pour le tableau 2D. Dans la prochaine boucle imbriquée, nous avons imprimé le tableau 2D via la déclaration std :: cout. À la fin du programme, le tableau 2D spécifié sera effacé de l'espace mémoire alloué car nous avons utilisé la suppression [] à la fin.

#inclure
#define x 3
#define y 4
int main()

int ** arr = new int * [x];
pour (int i = 0; i< X; i++)
arr [i] = new int [y];

pour (int i = 0; i< X; i++)

pour (int j = 0; j < Y; j++)
arr [i] [j] = rand ()% 10;


pour (int i = 0; i< X; i++)

pour (int j = 0; j < Y; j++)
std :: cout<
std :: cout<< std::endl;

pour (int i = 0; i< X; i++)
supprimer [] arr [i];

supprimer [] arr;
retour 0;

Le tableau 2D a été généré et affiché sur l'écran de la console ci-dessous.

Conclusion

Il s'agit du tableau redimensionné en C++. Nous avons appris que les tableaux C ++ n'ont pas de méthode intégrée pour redimensionner. Mais grâce à l'allocation dynamique du tableau en C ++, la taille du tableau peut être modifiée. Nous avons illustré dans l'exemple de modifier la taille du tableau dynamique à l'aide d'un nouveau mot-clé. De plus, nous pouvons utiliser une liste d'initialisateur pour initialiser un tableau. Après le redimensionnement, nous pouvons également libérer de l'espace en mémoire en utilisant la suppression []. Cet article vous montrera comment redimensionner un tableau en C++.