La new palabra clave y no coincidencia para el error del operador en C++

1. la new palabra clave en C++
2. Errores comunes con la palabra clave new en C++

Este artículo discutirá el uso de la palabra clave new en C++. Los programadores novatos suelen cometer muchos errores al utilizar la palabra clave new.

También discutiremos algunos de los errores más comunes que cometen y sus posibles soluciones.

la new palabra clave en C++

La palabra clave new se utiliza como un operador que solicita al sistema operativo que asigne algo de espacio en la memoria Heap. Si esa cantidad requerida de memoria está disponible en el montón, se asigna y la dirección de esa memoria asignada e inicializada se devuelve en la variable de puntero.

La sintaxis para usar la palabra clave new es:

datatype pointer_variable_name = new datatype;

Este tipo de datos también puede ser algún tipo de datos implícito o cualquier nombre de clase. Cuando creamos una variable de puntero de una clase con la palabra clave new, se llama al constructor de la clase y se asigna memoria en el montón.

Si no usamos una palabra clave new y la variable se inicializa en la pila, esa variable se destruye automáticamente cuando sale del alcance. Pero este no es el caso con las variables de montón.

Las variables del montón no se destruyen automáticamente; más bien, deben destruirse manualmente usando el operador delete; de lo contrario, quedan colgando en la memoria, lo que provoca problemas de pérdida de memoria.

Veamos el ejemplo a continuación.

#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;
}

Producción :

Value of Integer pointer is: 10

Errores comunes con la palabra clave new en C++

En ciertas situaciones, los programadores no lo inicializan con los datos correctos y utilizan los datos no asignados, lo que da como resultado algunos datos desconocidos o no deseados que pueden perturbar la ejecución del programa. Por ejemplo, hay 2 situaciones:

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

En la primera situación, la memoria se asigna a la única variable, y en la segunda situación, la memoria se asigna a 5 variables enteras, es decir, se crea una matriz de 5 índices en el montón.

Supongamos que accedemos a ptr[3] declarando el puntero usando la primera situación. En ese caso, estamos accediendo a un espacio no asignado que puede generar algún error desconocido porque no sabemos qué se colocó previamente en esa ubicación de memoria.

Por lo tanto, debemos tener mucho cuidado al asignar y usar la memoria asignada en el montón.

Considere una situación en la que tenemos un puntero para una clase y necesitamos crear una matriz de objetos de clase.

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
  }
}

En el fragmento de código anterior, en la línea 10, estamos inicializando el objeto en cada índice de la matriz. Pero esta línea producirá un error como este:

/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();
      |                                        ^

Esto se debe a que cada índice de la matriz student_list es un objeto de la clase Students, no el puntero de la clase Students. Por lo tanto, no necesitamos una palabra clave new para inicializarlo.

Debe inicializarse así:

student_list[k] = Students();

Otro error común es acceder a una ubicación de memoria ya eliminada o liberada. Hay ciertas situaciones en las que alguna función desasigna la memoria asignada del montón mediante el operador delete, y en cualquier otro punto del programa, intenta acceder a esa ubicación.

Esto puede causar un error y es muy difícil de rastrear, especialmente cuando se trabaja en proyectos más grandes. Considere el siguiente ejemplo.

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

Producción :

before deletion: 5
After deletion: 0

Podemos ver en la salida que después de la eliminación, el valor se borra de la memoria; por lo tanto, devuelve cero. En proyectos más grandes, esto puede causar errores no deseados en el tiempo de ejecución porque puede haber un caso en el que algún otro programa adquiera la ubicación de memoria liberada y contenga otros datos que pueden alterar la lógica de su programa.