Le new mot-clé et No Match for Operator Error en C++

1. le new mot-clé en C++
2. Erreurs courantes avec le mot clé new en C++

Cet article traitera de l’utilisation du mot-clé new en C++. Les programmeurs débutants commettent généralement de nombreuses erreurs en utilisant le mot-clé new.

Nous discuterons également de certaines des erreurs les plus courantes qu’ils commettent et de leurs correctifs potentiels.

le new mot-clé en C++

Le mot-clé new est utilisé comme un opérateur qui demande au système d’exploitation d’allouer de l’espace sur la mémoire Heap. Si cette quantité de mémoire requise est disponible sur le tas, elle est allouée et l’adresse de cette mémoire allouée et initialisée est renvoyée dans la variable de pointeur.

La syntaxe d’utilisation du mot-clé new est la suivante :

datatype pointer_variable_name = new datatype;

Ce type de données peut également être un type de données implicite ou n’importe quel nom de classe. Lorsque nous créons une variable pointeur d’une classe avec le mot-clé new, le constructeur de la classe est appelé et de la mémoire est allouée sur le tas.

Si nous n’utilisons pas de mot clé new et que la variable est initialisée sur la pile, cette variable est automatiquement détruite lorsqu’elle sort de la portée. Mais ce n’est pas le cas avec les variables de tas.

Les variables de tas ne sont pas détruites automatiquement ; ils doivent plutôt être détruits manuellement à l’aide de l’opérateur delete ; sinon, ils deviennent suspendus dans la mémoire, ce qui provoque des problèmes de fuite de mémoire.

Regardons l’exemple ci-dessous.

#include <iostream>
using namespace std;

int main() {
  int *intPtr = new int;
  *intPtr = 10;
  cout << "Value of Integer pointer is: " << *intPtr << endl;
  delete intPtr;
  return 0;
}

Production:

Value of Integer pointer is: 10

Erreurs courantes avec le mot clé new en C++

Dans certaines situations, les programmeurs ne l’initialisent pas avec des données correctes et utilisent les données non allouées, ce qui entraîne des données inconnues ou indésirables qui peuvent perturber l’exécution du programme. Par exemple, il y a 2 situations :

int *ptr = new int;      // situation 1
int *ptr2 = new int[5];  // situation 2

Dans la première situation, la mémoire est allouée à la seule variable, et dans la seconde situation, la mémoire est allouée à 5 variables entières, c’est-à-dire qu’un tableau de 5 indices est créé sur le tas.

Supposons que nous accédions à ptr[3] en déclarant le pointeur en utilisant la première situation. Dans ce cas, nous accédons à un espace non alloué qui peut entraîner une erreur inconnue car nous ne savons pas ce qui a été placé précédemment sur cet emplacement mémoire.

Par conséquent, nous devons être très prudents lors de l’allocation et de l’utilisation de la mémoire allouée sur le tas.

Considérez une situation où nous avons un pointeur pour une classe et nous devons créer un tableau d’objets de classe.

class Students {
  int roll_num;
  string name;
};
int main() {
  Students *student_list = new Students[10];
  for (int k = 0; k < 10; k++) {
    student_list[k] = new Students();  // line 10
  }
}

Dans l’extrait de code ci-dessus, à la ligne 10, nous initialisons l’objet à chaque index du tableau. Mais cette ligne produira une erreur comme celle-ci :

/tmp/qqnmmMnApj.cpp: In function 'int main()':
/tmp/qqnmmMnApj.cpp:14:40: error: no match for 'operator=' (operand types are 'Students' and 'Students*')
   14 |         student_list[k] = new Students();
      |                                        ^

En effet, chaque index du tableau student_list est un objet de la classe Students, et non le pointeur de la classe Students. Par conséquent, nous n’avons pas besoin d’un mot-clé new pour l’initialiser.

Il doit être initialisé comme ceci :

student_list[k] = Students();

Une autre erreur courante consiste à accéder à un emplacement mémoire déjà supprimé ou libéré. Il existe certaines situations où une fonction libère la mémoire allouée du tas à l’aide de l’opérateur delete, et à tout autre point du programme, vous essayez d’accéder à cet emplacement.

Cela peut provoquer une erreur et est très difficile à retracer, en particulier lorsque vous travaillez sur des projets plus importants. Prenons l’exemple ci-dessous.

int main() {
  int *p = new int;
  *p = 5;
  cout << "before deletion: " << *p << endl;
  delete p;
  cout << "After deletion: " << *p << endl;
}

Production:

before deletion: 5
After deletion: 0

Nous pouvons voir dans la sortie qu’après suppression, la valeur est effacée de la mémoire ; par conséquent, il renvoie zéro. Dans les projets plus importants, cela peut provoquer des erreurs indésirables lors de l’exécution, car il peut arriver qu’un emplacement de mémoire libéré soit acquis par un autre programme et contienne d’autres données susceptibles de perturber la logique de votre programme.