und C++ Speicherreservierung von Instanzen/Obijekten // (MS visual studio 2013)

[Bladefire]

Hallo,

ich lerne gerade ein bisschen C++, jedoch verstehe ich die Speicherreservierung von Obijekten/Instanzen nicht so ganz.

Am besten zeige ich es an einem Beispiel:

// CKlasse ist eine Klasse und hat eine memberfunktion namens "anzahl()"

c++
___

Code:

int aktuelleanzahl = 0;

CKlasse *Klassenvariable = NULL;

Klassenvariable = new CKlasse // der Klassenvariable wird eine (referenz?) adresse zugewiesen.

aktuelleanzahl = Klassenvariable.anzahl(); // Wieso braucht man hier kein "*"? Ich dachte das man sonst nur auf die speicherdresse(?) zugreifen kann.

delete aktuelleanzahl;

  // Beispiel aus einem anderen Tuturial
/* 
int *zahl = Null;

zahl = new int;

*zahl = 100; //! hier braucht man den "*" wieder. warum hier schon aber bei "aktuelleanzahl = Klassenvariable.anzahl();" nicht?

delete zahl;
*/

Wie kann man dies am besten mit Delphi vergleichen?
Delphi:

Delphi-Quellcode:

var
anzahl: integer;
Klassenvariablenname: TKlasse;
begin
    Klassenvariablenname := TKlasse.Create()
    anzahl := Klassenvariablenname.anzahl;
    anzahl.free;
end;

- Bitte beantwortet mir meine zwischenfragen die ich neben den quellcode als kommentar geschrieben habe.

- Bitte beantwortet mir diese Frage: Welche Zeilen von Delphi wären die gleichen wie in c++? z. B:
("Klassenvariablenname := TKlasse.Create()" in delphi ist das gleiche wie "CKlasse *Klassenvariable = NULL;")

- Bitte beantwortet mir diese Frage: Welche Zeilen von c++ wären die gleichen wie in delphi? z. B:
"CKlasse *Klassenvariable = NULL;" in delphi ist das gleiche wie ("Klassenvariablenname := TKlasse.Create()")

Bitte fragt nach wenn ihr nicht genau verstanden habt was ich eigentlich will (habe es ein bisschen kompliziert ausgedrückt)

Danke für eure mühen.

Lg Simon

[Sir Rufo]

Es wäre herzallerliebst, wenn du Quelltext auch in Code-Tags/Delphi-Tags setzen würdest.

Und via Google findet man z.B. das hier
http://de.m.wikibooks.org/wiki/C++-P...emente/_Zeiger

[Bladefire]

Danke für deine schnelle antwort.

Leider löst der link mein problem nicht. Bis jetzt konnte ich alles in c++ mit delphi vergleichen. Nun würde ich gerne wissen wie man den jeweiligen Quellcode den ich oben angegeben habe, in der jeweils anderen sprache schreibt.

Lg Simon

[Mikkey]

Du solltest die Begriffe Referenz und Zeiger nicht durcheinanderbringen.

Zitat:

Wieso braucht man hier kein "*"?

Man braucht es! Wenn irgendein schrottiger Compiler den Zugriff ohne erlaubt, dann solltest Du das als Fehler betrachten. ein Zeiger ist ein Zeiger und muss auch so benutzt werden.

Normalerweise verwendet man in C++ aber statt "*" und "." "->", dann wird auch besser deutlich, was man da tut.

Code:

pKlassenvariable->anzahl();

[Sir Rufo]

Hier mal dein C++ Code in Delphi gefasst

Delphi-Quellcode:

program dp_181230;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  System.SysUtils;

type
  CKlasse = class
  public
    function anzahl : Integer;
  end;

  { CKlasse }

function CKlasse.anzahl : Integer;
begin
  Result := 42;
end;

procedure Foo;
var
  aktuelleanzahl : Integer; // eine einfache Variable
  Klassenvariable : CKlasse; // eine Klassen-Referenz-Variable
  zahl : PInteger; // Ein Zeiger auf einen Integer
begin
  // int aktuelleanzahl = 0;
  aktuelleanzahl := 0;
  // CKlasse *Klassenvariable = NULL;
  Klassenvariable := nil;
  // Klassenvariable = new CKlasse
  Klassenvariable := CKlasse.Create;
  // aktuelleanzahl = Klassenvariable.anzahl();
  aktuelleanzahl := Klassenvariable.anzahl( );
  // delete aktuelleanzahl;
  // DELPHI: Variablen kann man überschreiben, aber der Speicher sollte nicht freigebeben werden

  Klassenvariable.Free; // In Delphi notwendig, sonst Speicherleck

  // int *zahl = Null;
  zahl := nil;
  // zahl = new int;
  new( zahl );
  // *zahl = 100;
  zahl^ := 100;
  // delete zahl;
  FreeMem( zahl );
end;

begin
  ReportMemoryLeaksOnShutdown := True;
  try
    Foo;
  except
    on E : Exception do
      Writeln( E.ClassName, ': ', E.Message );
  end;

end.

In Delphi erfolgt die Dereferenzierung bei Klassen-Referenz-Variablen automatisch, daher ist dort keine explizite Behandlung notwendig.

[Bladefire]

@ Mikkey, ich benute MS visual studio 2013. Möglicherweise habe ich ein falsches beispiel genannt wann man ihn nicht braucht.

Möglicherweise ist hier die verwendung korrekt (wenn ja, warum?):

Code:

#include <iostream>

using namespace std;

class CSpieler
{
private:
   char m_Name[30];
   int m_status;

public:

   void init();
   void zeigedaten();

};

void CSpieler::init()
{
   cout << "Bitte Namen eingeben:" << endl;
   cin.ignore();
   cin.get(m_Name, 29);
   m_status = 10;


}

void CSpieler::zeigedaten()
{
   cout << "Name: " << m_Name << endl;
   cout << "Status: " << m_status << endl;
   cout << endl;


}

int main()
{
   CSpieler *pSpielerliste = NULL;

   int anzahl;

   cout << "Wie viele Spieler?" << endl;
   cin >> anzahl;

   pSpielerliste = new CSpieler[anzahl];

   for (int i = 0; i < anzahl; i++)
   {
      cout << "Spieler " << i + 1 << endl;
      pSpielerliste[i].init();
      cout << endl;
   }

   for (int j = 0; j < anzahl; j++)
   {
      cout << "Spieler: " << j + 1 << endl;
      pSpielerliste[j].zeigedaten();
      cout << endl;
   }

   delete[] pSpielerliste;

}

@ Sir Rufo, herzlichen danke das wollte ich wissen :)

lg Simon

[Mikkey]

Code:

pSpielerliste = new CSpieler[anzahl];

generiert ein Array von Objekten der Typen CSpieler, auf die Elemente eines solchen Arrays greift man (wie in Delphi auch) mit "[..]" zu.

In C werden Arrays und Pointer gleichartig behandelt:

"*Ptr" und "Ptr[0]" geben einen Zugriff auf denselben Speicher mit demselben Typ, ebenso wie
"(*Ptr).Member", "Ptr->Member" und "Ptr[0].Member".

Wenn Du mehr Anforderungen von Code-Transfers von C(++) nach Delphi hast, solltest du Dich mit den C-Grundlagen beschäftigen.

[Bladefire]

Danke für deine hilfe.

Das war alles was ich wissen wollte.

lg simon

[Bladefire]

@ Sir Rufo, mir sind noch 2 kleine fragen zu diesem Thema eingefallen.

In C++ kann man auch eine Klasse ohne den ganzen Zeiger / referenzen kram erstellen. Wie würde das in Delphi aussehen?

Abgesehen davon würde ich gerne wissen ob diese aussage stimmt:

"Wenn man in c++ die klasse ohne den Zeiger erstellt dan wird sie im stack gespeichert (und existiert nur in der funktion in der die klasse erstellt wurde)."?

Code:

Klasse CKlasse;

CKlasse.variable = 10;

Lg Simon

[Mikkey]

Delphi hat dafür kein Pendant, ebensowenig, wie für das Objektarray aus Deinem anderen Beispiel.

In C# wurde das auch abgeschafft. Beide Sprachen bieten wegen der automatischen Dereferenzierung nicht die Syntax, um Objektreferenzen von Objektvariablen zu unterscheiden.

[Olli73]

Zitat:

Zitat von Bladefire (Beitrag 1267013)

In C++ kann man auch eine Klasse ohne den ganzen Zeiger / referenzen kram erstellen. Wie würde das in Delphi aussehen?

Wie schon von Mikkey geschrieben, gibt es dafür in Delphi und C# kein Pendant, da dort Objekte (Instanzen von Klassen) immer nur eine Referenz auf einen Speicherbereich sind und man dadurch den Vorteil hat, es nicht explizit dereferenzieren zu müssen (Der Nachteil ist, man muss die Objekte immer selber erstellen / Speicher anfordern (create) und bei Delphi unter Windows auch wieder freigeben).

Am Ehesten kannst due es mir Records in Delphi vergleichen.

[Bladefire]

Danke, eure antworten haben mir sehr geholfen.

Ich möchte noch ein kleines beispiel einfügen das mir beim unterscheiden von obijektvariablen und obijektreferenzen geholfen hat:

Zitat:

sagen wir mal, ein Auto belegt 100 Bytes.

Auto myCar("BMW");
Compiler legt 100 Bytes auf dem Stack an und ruft dann den Konstruktor auf, dem er die Adresse des Anfangs des neuen Speichers übergibt.

Auto* myCar;
Compiler legt 4 Bytes auf dem Stack an
myCar = new Auto("BMW");
Compiler legt 100 Bytes auf dem Freispeicher an und ruft dann den Konstruktor auf, dem er die Adresse des Anfangs des neuen Speichers übergibt. Diese Adresse ist auch der Rückgabewert von new und wird in die 4 bytes auf dem Stack kopiert.

Quelle: http://www.c-plusplus.de/forum/155621-full - volkard

Also wird in delphi von natur aus alles bis auf den Zeiger im heap gespeichert?

[Sir Rufo]

Zitat:

Zitat von Bladefire (Beitrag 1267027)

Also wird in delphi von natur aus alles bis auf den Zeiger im heap gespeichert?

Wenn du Klassen-Instanzen in Delphi damit meinst, ja.

Wenn du das mit dem von C++ vergleichen möchtest, dann liegst du völlig falsch, denn in Delphi entspricht das den Records.

Delphi-Quellcode:

type
  THersteller = string[99];
  PAuto = ^TAuto;

  TAuto = record
    Hersteller : THersteller;
    constructor Create( Hersteller : THersteller );
  end;

  { TAuto }

constructor TAuto.Create( Hersteller : THersteller );
begin
  Self.Hersteller := Hersteller;
end;

procedure Test2;
var
  myCar : TAuto;
begin
  myCar := TAuto.Create( 'BMW' );
  Writeln( SizeOf( myCar ) ); // -> 100
end;

procedure Test3;
var
  myCar : PAuto;
begin
  myCar := New( PAuto );
  try
    myCar^ := TAuto.Create( 'BMW' );
    Writeln( SizeOf( myCar ) ); // -> 4
  finally
    Dispose( myCar );
  end;
end;

[JamesTKirk]

Die C++ Speicherverwaltung lässt sich am besten mit Delphi's

Delphi-Quellcode:

object

Typ vergleichen:

Delphi-Quellcode:

type
  CKlasse = object
    function anzahl: LongInt;
  end;
  PCKlasse = ^CKlasse;

function CKlasse.anzahl: LongInt;
begin
  anzahl := 42;
end;

var
  aktuelleanzahl: LongInt;
  Klassenvariable: PCKlasse;
begin
  aktuelleanzahl := 0;

  Klassenvariable := Nil;

  (* es gibt noch ne spezielle New() Syntax um Konstruktoren mit
   * Parametern aufzurufen, die müsste ich aber erstmal noch
   * nachschauen... :/
   *)
  New(Klassenvariable); 

  (* hier wundere ich mich gerade, dass dein C++ Compiler sich nicht
   * darüber beschwert, dass es Klassenvariable->anzahl() heißen
   * muss... :/
   *)
  aktuelleanzahl := Klassenvariable^.anzahl;

  Dispose(Klassenvariable);
end.

Zitat:

Zitat von Olli73 (Beitrag 1267025)

Zitat:

Zitat von Bladefire (Beitrag 1267013)

In C++ kann man auch eine Klasse ohne den ganzen Zeiger / referenzen kram erstellen. Wie würde das in Delphi aussehen?

Wie schon von Mikkey geschrieben, gibt es dafür in Delphi und C# kein Pendant, da dort Objekte (Instanzen von Klassen) immer nur eine Referenz auf einen Speicherbereich sind und man dadurch den Vorteil hat, es nicht explizit dereferenzieren zu müssen (Der Nachteil ist, man muss die Objekte immer selber erstellen / Speicher anfordern (create) und bei Delphi unter Windows auch wieder freigeben).

Am Ehesten kannst due es mir Records in Delphi vergleichen.

Im Gegensatz zu C# hat Delphi dafür ein Pendant:

Delphi-Quellcode:

object

;)

Zitat:

Zitat von Sir Rufo (Beitrag 1267043)

Delphi-Quellcode:

procedure Test3;
var
  myCar : PAuto;
begin
  myCar := New( PAuto );
  try
    myCar^ := TAuto.Create( 'BMW' );
    Writeln( SizeOf( myCar ) ); // -> 4
  finally
    FreeMem( myCar );
  end;
end;

Mix doch bitte nicht

Delphi-Quellcode:

New

und

Delphi-Quellcode:

FreeMem

! Das Äquivalent zu

Delphi-Quellcode:

New

ist

Delphi-Quellcode:

Dispose

und das zu

Delphi-Quellcode:

FreeMem

ist

Delphi-Quellcode:

GetMem

und es gibt einen wichtigen Unterschied zwischen den beiden Paaren: erstes kümmert sich um die Initialisierung/Finalisierung von Managed Typen (Strings (AnsiString, UnicodeString), Interfaces, Dynamische Arrays), aber das zweite Paar macht das nicht. Wenn du also ein

Delphi-Quellcode:

record

mit einem

Delphi-Quellcode:

String

(kein

Delphi-Quellcode:

ShortString

) mit Hilfe von

Delphi-Quellcode:

FreeMem

freigibst, dann hast du ein Memoryleak, weil der Referenzzähler des Strings nicht runtergezählt wird.

Gruß,
Sven

[Sir Rufo]

Zitat:

Zitat von JamesTKirk (Beitrag 1267095)

Mix doch bitte nicht

Delphi-Quellcode:

New

und

Delphi-Quellcode:

FreeMem

!

Musst mich ja nicht gleich so anschreien :D - hast ja recht, und ich habe es in meinem Code auch geändert, merci

[Mikkey]

Zitat:

Zitat von JamesTKirk (Beitrag 1267095)

Code:

  (* hier wundere ich mich gerade, dass dein C++ Compiler sich nicht
   * darüber beschwert, dass es Klassenvariable->anzahl() heißen
   * muss... :/
   *)

Es mag C++-Compiler geben, die (ähnlich wie Delphi beim '@' in Methodenparametern) das Sternchen generös einfügen.

Zitat:

Zitat von JamesTKirk (Beitrag 1267095)

Im Gegensatz zu C# hat Delphi dafür ein Pendant:

Delphi-Quellcode:

object

;)

Und (abgesehen davon, dass 'object' als veraltet gekennzeichnet wird) wie stellst Du dann echte Referenzvariablen dar:

Code:

{
  CKlasse obj(..);
  CKlasse* ptrObj = new CKlasse(..);
  CKlasse& refObj = *ptrObj;
}

?

[Bladefire]

Danke für eure zahlreichen antworten.

@ Sir Rufus: Ich verstehe nicht was records damit zu tun haben, ich dachte das wäre sowas wie struct(c++) nur für delphi.

Delphi-Quellcode:

procedure Test2;
var
  myCar : TAuto;
begin
  myCar := TAuto.Create( 'BMW' );
  Writeln( SizeOf( myCar ) ); // -> 100
end;

Wären die 100 Bytes nicht dank der automatischen derefernzierung trotzdem im heap gespeichert und im stack wird (vom compiler automatisch) ein zeiger darauf hinterlegt? (möglicherweise habe ich es doch falsch verstanden).

Sollte meine oben gennante aussage stimmen, wären dann nicht in delphi selbsterstellte zeiger ziemlich überflüssig?

lg Simon

[Sir Rufo]

Du versuchst hier Birnen mit Äpfel zu vergleichen.

C++ arbeitet anders als Delphi und daher muss man eben diese Besonderheiten berücksichtigen und kann da nicht stumpf 1:1 den Code umsetzen.

Ein Mazda RX-7 und ein Nissan 370ZX zu vergleichen geht schon (starten, fahren, tanken, ...), aber wenn man dann die Motoren auseinandernimmt ist und vergleichen will, hat man ein Problem, denn es sind 2 grundverschiedene Konzepte (Wankel <-> Otto) und trotzdem können beide fahren.

Somit wollte ich nur sagen, dass man das, was du da als C++ Beispiel hattest, in Delphi am ehesten mit Records vergleichen kannst, es ist aber nicht exakt dasselbe.

[Bladefire]

Herzlichen danke,

könntest du mir (oder jemand anderes) auch noch diese frage beantworten:

Delphi-Quellcode:

procedure Test2;
var
  myCar : TAuto;
begin
  myCar := TAuto.Create( 'BMW' );
  Writeln( SizeOf( myCar ) ); // -> 100
end;

Werden die 100 Bytes dank der automatischen derefernzierung im heap gespeichert und im stack wird (vom compiler automatisch) ein zeiger darauf hinterlegt? (möglicherweise habe ich es falsch verstanden).

lg simon

[Olli73]

Zitat:

Zitat von Mikkey (Beitrag 1267099)

Zitat:

Zitat von JamesTKirk (Beitrag 1267095)

Im Gegensatz zu C# hat Delphi dafür ein Pendant:

Delphi-Quellcode:

object

;)

... (abgesehen davon, dass 'object' als veraltet gekennzeichnet wird ...)

Wollte ich auch gerade schreiben.

Zitat:

Zitat von Bladefire (Beitrag 1267143)

Delphi-Quellcode:

procedure Test2;
var
  myCar : TAuto;
begin
  myCar := TAuto.Create( 'BMW' );
  Writeln( SizeOf( myCar ) ); // -> 100
end;

Werden die 100 Bytes dank der automatischen derefernzierung im heap gespeichert und im stack wird (vom compiler automatisch) ein zeiger darauf hinterlegt? (möglicherweise habe ich es falsch verstanden).

Wenn TAuto eine Klasse wäre, hättest du Recht; SirRufo schrieb aber

Delphi-Quellcode:

TAuto = record

und da gibt es keine automatische Dereferenzierung (Verhält sich ähnlich zu Klassen in C++).

[Mikkey]

Zitat:

Zitat von Olli73 (Beitrag 1267164)

Wenn TAuto eine Klasse wäre, hättest du Recht,

Darauf wollte ich auch erst hinweisen, aber
wenn TAuto keine Klasse wäre, würde

Delphi-Quellcode:

myCar := TAuto.Create( 'BMW' );

nicht funktionieren :-D

[Olli73]

Zitat:

Darauf wollte ich auch erst hinweisen, aber
wenn TAuto keine Klasse wäre, würde

Delphi-Quellcode:

myCar := TAuto.Create( 'BMW' );

nicht funktionieren :-D

Was sollte da nicht funktionieren?

[Mikkey]

In meinem Delphi hat ein Record keinen Konstruktor und auch keine Klassenfunktionen, die so tun könnten als ob.

[JamesTKirk]

Zitat:

Zitat von Sir Rufo (Beitrag 1267097)

Zitat:

Zitat von JamesTKirk (Beitrag 1267095)

Mix doch bitte nicht

Delphi-Quellcode:

New

und

Delphi-Quellcode:

FreeMem

!

Musst mich ja nicht gleich so anschreien :D

Sorry. :oops: Dabei hab ich doch extra klein und mit Bitte geschrieben, damit's nicht so laut wirkt :mrgreen:

Zitat:

Zitat von Sir Rufo (Beitrag 1267097)

- hast ja recht, und ich habe es in meinem Code auch geändert, merci

Danke :)

Zitat:

Zitat von Mikkey (Beitrag 1267099)

Zitat:

Zitat von JamesTKirk (Beitrag 1267095)

Code:

  (* hier wundere ich mich gerade, dass dein C++ Compiler sich nicht
   * darüber beschwert, dass es Klassenvariable->anzahl() heißen
   * muss... :/
   *)

Es mag C++-Compiler geben, die (ähnlich wie Delphi beim '@' in Methodenparametern) das Sternchen generös einfügen.

Und solche Automatismen führen dann dazu, dass Anfänger nicht verstehen, was genau nun vor sich geht... :?

Zitat:

Zitat von Mikkey (Beitrag 1267099)

Zitat:

Zitat von JamesTKirk (Beitrag 1267095)

Im Gegensatz zu C# hat Delphi dafür ein Pendant:

Delphi-Quellcode:

object

;)

Und (abgesehen davon, dass 'object' als veraltet gekennzeichnet wird) wie stellst Du dann echte Referenzvariablen dar:

Code:

{
  CKlasse obj(..);
  CKlasse* ptrObj = new CKlasse(..);
  CKlasse& refObj = *ptrObj;
}

?

Dass

Delphi-Quellcode:

object

in Delphi als veraltet gilt stört mich ehrlich gesagt überhaupt nicht. Ich bin FPC Entwickler und dort ist

Delphi-Quellcode:

object

nach wie vor first-class Citizen (und wird zum Beispiel im Compiler selbst noch hier und da verwendet).
Referenzvariablen lassen sich in der Tat nicht mit Delphi darstellen (außer als Parameter, wo du

Delphi-Quellcode:

var

und in FPC

Delphi-Quellcode:

constref

verwenden kannst). Andererseits sind Referenzvariablen nicht auf Klassen beschränkt und hier geht es ja um die Speicherverwaltung um Klassen und deren Äquivalenzen in Delphi. Und da ist nun mal

Delphi-Quellcode:

object

das was am nähesten rankommt...

Zitat:

Zitat von Bladefire (Beitrag 1267143)

Delphi-Quellcode:

procedure Test2;
var
  myCar : TAuto;
begin
  myCar := TAuto.Create( 'BMW' );
  Writeln( SizeOf( myCar ) ); // -> 100
end;

Werden die 100 Bytes dank der automatischen derefernzierung im heap gespeichert und im stack wird (vom compiler automatisch) ein zeiger darauf hinterlegt? (möglicherweise habe ich es falsch verstanden).

Da

Delphi-Quellcode:

TAuto

ein Record ist, liegt es auf dem Stack. Bei

Delphi-Quellcode:

TAuto.Create

wird (grob gesagt) auf einer temporären Variable vom Typ

Delphi-Quellcode:

TAuto

auf dem Stack gearbeitet, die an

Delphi-Quellcode:

Create

als versteckter Parameter übergeben wird und anschließend an

Delphi-Quellcode:

myCar

zugewiesen wird. Ein Record ist nur dann auf dem Heap, wenn du mit

Delphi-Quellcode:

New

oder

Delphi-Quellcode:

GetMem

und ner Zeigervariablen (

Delphi-Quellcode:

type PAuto = ^TAuto;

) arbeitest.

Zitat:

Zitat von Mikkey (Beitrag 1267178)

In meinem Delphi hat ein Record keinen Konstruktor und auch keine Klassenfunktionen, die so tun könnten als ob.

Ab Delphi 2006 (glaub ich) und Free Pascal 2.6.0 (für (Klassen)Methoden) bzw. 2.7.1 (für Konstruktoren) funktioniert das.

Gruß,
Sven