C ++ Nouvel opérateur

En C ++, le terme «déploiement de mémoire dynamique» fait référence à l'attribution manuelle du stockage par un programmeur. Le tas est l'endroit où la mémoire partagée distribuée est déployée, tandis que la pile est l'endroit où les variables non statiques et locales acquièrent des ressources de mémoire.

Applications

• L'allocation du stockage de la taille dynamique, qui n'est pas réalisable avec le stockage alloué au compilateur en dehors des tableaux variables, est une utilisation de l'allocation de mémoire dynamique.
• Le principal avantage est la polyvalence qu'il donne aux programmeurs. Nous avons une autonomie absolue pour allouer et libérer la mémoire au besoin et comme il n'est plus nécessaire. Cette polyvalence est utile dans de nombreuses situations.

Comment C ++ alloue-t-il et traite-t-il la mémoire?

Les méthodes malloc () et calloc () en C ++ sont utilisées pour modifier dynamiquement la mémoire à l'exécution. Tandis que la méthode libre () est utilisée pour libérer la mémoire qui a été allouée. Ces méthodes sont fournies par C ++ avec les deux opérateurs «nouveaux» et «supprimer» qui facilitent l'allocation et la libération de la mémoire.

La corrélation entre le «nouveau» mot-clé et le «nouveau» opérateur nouveau

Ces deux choses sont différentes les unes des autres.

Deux événements ont lieu: Distribution de la mémoire et formation d'objets. Les deux sont gérés par le «nouveau» mot-clé. Appeler l'opérateur et appeler le constructeur lui-même sont les procédures pour allouer le stockage. L'opérateur «nouveau» ne prendra aucune responsabilité pour invoquer le constructeur, mais il vous permet d'ajuster la stratégie d'allocation de stockage. Le nouveau mot-clé a cette responsabilité. Appeler le constructeur sans utiliser l'opérateur nouveau est possible.

Nouvel opérateur

La demande d'allocation de mémoire sur le stockage ouvert est indiquée par le nouvel opérateur. Si suffisamment de mémoire est accessible, un nouvel opérateur traite les données. Ensuite, l'initialise et donne à l'objet pointeur l'adresse de la mémoire récemment allouée et configurée.

Exemple 1

Nous exécutons ce code pour montrer comment les opérateurs nouveaux et supprimés peuvent être utilisés; La mémoire sera allouée et publiée dynamiquement.

#inclure
Utilisation de Namespace Std;
int main ()

int * a = null;
a = new (nothrow) int;
si (!un)
couter << "Memory is not allocated\n";
autre

* a = 45;
couter << "Value of a: " << *a << endl;

Float * C = nouveau flotteur (67.84);
couter << "Value of c: " << *c << endl;
int x = 6;
int * b = new (nothrow) int [x];
si (!b)
couter << "Memory is not allocated\n";
autre

pour (int j = 0; j < x; j++)
b [j] = j + 1;
couter << "A chunk of memory containing values: ";
pour (int j = 0; j < x; j++)
couter << b[j] << " ";

supprimer a;
supprimer c;
supprimer [] b;
retour 0;

Les bibliothèques requises seraient intégrées. Ensuite, l'espace de noms standard sera ajouté en tant que «MST». Ici, la fonction principale () serait invoquée. Nous initialiserions un pointeur et définissons ce pointeur sur «null». Demandons de stocker les variables utilisées pour un «nouvel» opérateur. Le type de données de «A» sera «entier». La condition «if-else» s'appliquerait. Si la condition définie est satisfaite, l'instruction «cout» affichera le texte que «la mémoire n'est pas allouée». Sinon, nous stockons la valeur du pointeur.

Ensuite, la commande 'cout' montre la valeur du pointeur. Maintenant, nous demandons un bloc de mémoire en utilisant le «nouvel» opérateur. Nous spécifions la valeur à virgule flottante de la variable «C» en utilisant le «nouvel» opérateur. Maintenant, le «cout» imprimera la valeur de la variable «C». Ici, nous spécifions la taille du bloc de mémoire. Nous déclarons une variable «x» et définissons son type de données comme un «entier». Nous construisons un nouveau pointeur nommé «B» et lui fournissons la valeur en utilisant le «nouvel» opérateur.

Encore une fois, la condition «if-else» sera utilisée. Dans la déclaration «else», nous avons utilisé la déclaration «pour». Initialement, la variable de boucle «J» serait déclarée et nous définissons la condition. Ensuite, nous augmentons la valeur de la variable de boucle de 1. La commande «cout» serait utilisée pour imprimer la ligne «un morceau de mémoire contenant des valeurs». Encore une fois, nous utiliserons la boucle «pour».

Maintenant, nous allons libérer la mémoire allouée par l'utilisation de l'opérateur «Supprimer». Avant d'ajouter la commande 'return 0', nous libérons le bloc de mémoire allouée en utilisant le tableau.

Nous acquérons ce type de résultat après avoir exécuté le programme susmentionné.

Exemple 2

Dans ce cas, nous utiliserons le «nouvel» opérateur pour différents objets.

#inclure
#inclure
Utilisation de Namespace Std;
int main()

int * l = null;
l = new int ();
int * v = new int (23);
si(!l)

couter<<"bad memory allocation"<
autre

couter<<"memory allocated successfully"<* l = 20;
couter<<"*l = "<<*l<couter<<"*v = "<<*v<
double * arr = null;
arr = nouveau double [20];
si(!arr)
cout<<"memory not allocated"<autre

pour (int k = 0; k<20;k++)
arr [k] = k + 1;
couter<<"arr values : ";
pour (int k = 0; k<20;k++)
couter<< arr[k]<<"\t";

supprimer l;
supprimer v;
supprimer [] arr;
retour 0;

Dans l'illustration est l'intégration des bibliothèques nécessaires . Ensuite, l'espace de noms connu sous le nom de «MST» sera ajouté. La méthode principale () serait appelée. Pour initialiser un pointeur, nous le définissons sur «Null.«La valeur de la variable« i »qui est utilisée pour le« nouvel »opérateur serait stockée ici. Le type de données de cette variable est «entier.«La condition« if-else »sera utilisée. Si la condition spécifiée est remplie, le texte «mauvaise allocation de mémoire» sera affiché par l'instruction «cout». Sinon, nous conservions la valeur du pointeur.

Ensuite, le texte «Mémoire alloué avec succès» s'affiche à l'aide de la commande «cout». La valeur du pointeur serait définie. La valeur du pointeur serait affichée par la commande «cout». Nous avons initialisé le tableau avec le type de données «double» et lui avons donné la valeur «NULL.«En utilisant le« nouvel »opérateur, nous définissons la valeur de ce tableau. Il utilise une déclaration «if-else». Lorsque la condition est remplie, la commande «cout» imprime «Mémoire non allouée.» Sinon, nous avons utilisé des déclarations «pour» imbriquées.

Avant de définir la condition, la variable de boucle «J» serait d'abord spécifiée. Ensuite, nous ajoutons 1 à la valeur de 'J'. Les valeurs du tableau seraient imprimées à l'aide de la commande 'cout'. Nous utiliserions à nouveau la boucle «pour». Maintenant, nous utiliserons l'opérateur de suppression. Nous libérerons la mémoire qui a été allouée. Nous libérons le bloc de la mémoire allouée en utilisant le tableau avant d'ajouter l'instruction "Return 0".

Après implémentation du code susmentionné, nous obtenons le résultat souhaité.

Conclusion

L'utilisation du «nouvel» opérateur est au centre de cet article. Pour les types de données définis par l'utilisateur dans les classes et autres types de données, nous utiliserons le «nouvel» opérateur. Nous avons exécuté deux exemples liés à ce sujet. Le premier exemple montre comment utiliser le «nouveau» opérateur de C ++. La dernière illustration montre comment appliquer le «nouveau» opérateur aux objets.