Das new Schlüsselwort und No Match for Operator Error in C++

1. Das Schlüsselwort new in C++
2. Häufige Fehler mit dem Schlüsselwort new in C++

Dieser Artikel behandelt die Verwendung des Schlüsselworts new in C++. Programmieranfänger machen normalerweise viele Fehler, wenn sie das Schlüsselwort new verwenden.

Wir werden auch einige der häufigsten Fehler besprechen, die sie machen, und ihre möglichen Korrekturen.

Das Schlüsselwort new in C++

Das Schlüsselwort new wird als Operator verwendet, der eine Anfrage an das Betriebssystem stellt, um Speicherplatz auf dem Heap-Speicher zuzuweisen. Wenn diese erforderliche Speichermenge auf dem Heap verfügbar ist, wird sie zugewiesen, und die Adresse dieses zugewiesenen und initialisierten Speichers wird in der Zeigervariablen zurückgegeben.

Die Syntax für die Verwendung des Schlüsselworts new lautet:

datatype pointer_variable_name = new datatype;

Dieser Datentyp kann auch ein impliziter Datentyp oder ein beliebiger Klassenname sein. Wenn wir mit dem Schlüsselwort new eine Zeigervariable einer Klasse erstellen, wird der Klassenkonstruktor aufgerufen und dem Heap Speicher zugewiesen.

Wenn wir kein new-Schlüsselwort verwenden und die Variable auf dem Stack initialisiert wird, wird diese Variable automatisch zerstört, wenn sie den Gültigkeitsbereich verlässt. Dies ist jedoch bei Heap-Variablen nicht der Fall.

Heap-Variablen werden nicht automatisch zerstört; Stattdessen müssen sie manuell mit dem Operator delete zerstört werden; Andernfalls baumeln sie im Speicher, was zu Problemen mit Speicherlecks führt.

Schauen wir uns das Beispiel unten an.

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

Ausgabe:

Value of Integer pointer is: 10

Häufige Fehler mit dem Schlüsselwort new in C++

In bestimmten Situationen initialisieren Programmierer es nicht mit korrekten Daten und verwenden die nicht zugeordneten Daten, was zu einigen unbekannten oder unerwünschten Daten führt, die die Programmausführung stören können. Es gibt zum Beispiel 2 Situationen:

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

In der ersten Situation wird Speicher der einzelnen Variablen zugewiesen, und in der zweiten Situation wird Speicher 5 Integer-Variablen zugewiesen, d. h. auf dem Heap wird ein Array von 5 Indizes erstellt.

Angenommen, wir greifen auf ptr[3] zu, indem wir den Zeiger mit der ersten Situation deklarieren. In diesem Fall greifen wir auf einen nicht zugeordneten Speicherplatz zu, was zu einem unbekannten Fehler führen kann, da wir nicht wissen, was zuvor an diesem Speicherplatz abgelegt wurde.

Daher müssen wir beim Zuweisen und Verwenden des auf dem Heap zugewiesenen Speichers sehr vorsichtig sein.

Stellen Sie sich eine Situation vor, in der wir einen Zeiger für eine Klasse haben und ein Array von Klassenobjekten erstellen müssen.

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

Im obigen Codeausschnitt initialisieren wir in Zeile 10 das Objekt an jedem Index des Arrays. Aber diese Zeile wird einen Fehler wie diesen erzeugen:

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

Denn jeder Index des Arrays student_list ist ein Objekt der Klasse Students, nicht der Pointer der Klasse Students. Daher brauchen wir kein new-Schlüsselwort, um es zu initialisieren.

Es sollte wie folgt initialisiert werden:

student_list[k] = Students();

Ein weiterer häufiger Fehler ist der Zugriff auf einen bereits gelöschten oder freigegebenen Speicherplatz. Es gibt bestimmte Situationen, in denen eine Funktion den zugewiesenen Speicher mithilfe des Operators Löschen vom Heap freigibt und Sie an einem anderen Punkt im Programm versuchen, auf diesen Speicherort zuzugreifen.

Dies kann zu Fehlern führen und ist sehr schwer nachzuvollziehen, insbesondere bei der Arbeit an größeren Projekten. Betrachten Sie das folgende Beispiel.

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

Ausgabe:

before deletion: 5
After deletion: 0

Wir können in der Ausgabe sehen, dass der Wert nach dem Löschen aus dem Speicher gelöscht wird; daher gibt es null zurück. In größeren Projekten kann dies zur Laufzeit zu ungewollten Fehlern führen, da freigewordener Speicherplatz unter Umständen von einem anderen Programm übernommen wird und andere Daten enthält, die Ihre Programmlogik stören können.