Fragen von einem "Dummy" - Seite 107

[[Gelöscht]]

mql5:
Destruktoren in MQL5 sind immer virtuell. Alles wird korrekt gelöscht, versuchen Sie, Print(__FUNCSIG__); in Destruktoren zu setzen.

Ich habe es in VC++ gemacht, aber ich denke, die Mechanismen zur Speicherfreigabe sind die gleichen, oder?

[Ilyas]

220Volt:
Ich habe es in VC++ gemacht, aber ich denke, die Mechanismen zur Speicherfreigabe sind die gleichen?

Nein, in C++ muss ein virtueller Destruktor angegeben werden, um ein Objekt korrekt über delete zu löschen.

Aber Ihr Beispiel wird korrekt funktionieren, da Sie nur für die Basisklasse einen virtuellen Destruktor angeben können.

[[Gelöscht]]

Ich werde versuchen, die Idee ein wenig anders zu formulieren:

Gegeben:

• Klasse #1 - sie belegt 100 Bytes im Speicher.
• Klasse #2 - sie ist ein Abkömmling von Klasse #1 und belegt 200 Bytes im Speicher.
• Zeiger auf Klasse 1.

Handlungen:

• Schreiben Sie in den Zeiger die Adresse des Speicherabschnitts, in dem sich eine Instanz der Klasse #2 befindet (rufen Sie new auf)
• Geben Sie den Lötbereich frei, indem Sie die Löschfunktion an die im Zeiger gespeicherte Adresse übergeben.

P.S.: die Abbildung zeigt das Speichermodell )

[[Gelöscht]]

Ich habe Zweifel, weil der Zeiger auf Klasse Nummer eins, aber eigentlich Klasse Nummer zwei im Speicher ist. Bei Destruktoren spielt das eine Rolle, daher habe ich mich gefragt, ob es auch hier ein Problem geben könnte. Ich denke, dass in dieser Situation korrekte Speicherfreigabe nur auftreten kann, wenn es einige Etiketten im Speicher (wie char mit Null-Terminator) oder etwas wie das, das ist, warum ich über Speicherzuweisung gefragt.

[Mykola Demko]

220Volt:
Zweifel, weil der Zeiger auf Klasse Nummer eins und tatsächlich im Speicher Klasse Nummer zwei. Bei Destruktoren spielt das eine Rolle, daher habe ich mich gefragt, ob es auch hier ein Problem geben könnte. Ich denke, dass in einer solchen Situation korrekte Speicherfreigabe nur passieren kann, wenn es einige Etiketten im Speicher (wie char mit Null-Terminator) oder so etwas wie das, das ist, warum ich über Speicherzuweisung gefragt.

Ihr Zweifel liegt daran, dass Sie keine Konstruktoren angegeben haben (es ist wichtig zu verstehen, was in diesem Fall passiert), versuchen Sie, dieses Beispiel auszuführen und Sie werden alles verstehen:

class CFoo
  {
public:
                     CFoo() { Print(__FUNCSIG__); }
                    ~CFoo() { Print(__FUNCSIG__); }
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class CBar : public CFoo
  {
public:
                     CBar() { Print(__FUNCSIG__); }
                    ~CBar() { Print(__FUNCSIG__); }
  };
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnStart()
  {
   CFoo *f=new CBar();

   delete f;
  }
//+------------------------------------------------------------------+

HZ die Konstruktion selbst sowie die Löschung ist gestaffelt, und all diese Informationen werden gespeichert (der virtuelle Zeiger selbst erinnert daran, dass die Klasse als Kompositum aus der Basis und dem Nachkommen konstruiert wurde), und beim Löschen werden die Destruktoren in umgekehrter Reihenfolge aufgerufen, vom späteren zum früheren.

[[Gelöscht]]

Es geht nicht um Destruktoren, sondern um die Klasse selbst, genauer gesagt um die Anzahl der Bytes, die sie belegt. Es stellt sich heraus, dass wir 200 Bytes zuweisen und mir dann sagen, dass ich den Speicher freigeben soll, auf den ein Zeiger zeigt, der ein Objekt der Größe 100 Bytes darstellt.

[Ilyas]

220Volt:
Es geht nicht um Destruktoren, sondern um die Klasse selbst, genauer gesagt darum, wie viele Bytes sie belegt. Es stellt sich heraus, dass wir 200 Bytes zuweisen und mir dann sagen, dass ich den Speicher freigeben soll, auf den der Zeiger zeigt, der das Objekt mit der Größe von 100 Bytes darstellt.

Ich gehe davon aus, dass sich Ihre Frage auf die Funktionsweise des Speicherpools bezieht.
Ja, der Speicherpool weiß, wie lange ein Stück Speicher durch einen Löschaufruf freigegeben wird.
Wo diese Informationen gespeichert werden, hängt von der Implementierung des Pools ab.

Wenn Sie z. B. einen Zeiger auf ein Objekt in C++ geben, das nicht durch new zugewiesen wurde, werden Sie sehen, wie Ihre Anwendung abstürzen wird.

[Mykola Demko]

220Volt:
Es geht nicht um Destruktoren, sondern um die Klasse selbst, genauer gesagt darum, wie viele Bytes sie belegt. Es stellt sich heraus, dass wir 200 Bytes zuweisen und mir dann sagen, dass ich den Speicher freigeben soll, auf den der Zeiger zeigt, der das Objekt mit der Größe von 100 Bytes darstellt.

Ich nehme an, Sie haben meine Probe noch nicht getestet. Sonst hätten Sie diese Fragen nicht gestellt.

[[Gelöscht]]

Ich dachte, ich erinnerte mich, dass Sie Speicher für ein Array von int's zum Beispiel zuweisen können und dann alle von ihnen zu löschen, trotz der Tatsache, dass ein int ist klein, wahrscheinlich das gleiche mit Klassen. Vielen Dank für die Antworten.

[[Gelöscht]]

mql5:
Soweit ich weiß, hat Ihre Frage mit der Funktionsweise des Speicherpools zu tun.
Ja, der Speicherpool weiß, wie lange ein Stück durch einen Löschaufruf freigegeben wird.
Wo diese Informationen gespeichert werden, hängt von der Implementierung des Pools ab.

Wenn Sie z. B. einen Zeiger auf ein Objekt in C++ geben, das nicht über new zugewiesen wurde, werden Sie sehen, wie Ihre Anwendung abstürzen wird.

Das war's schon, danke.