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

[Olli73]

Zitat von Bladefire:

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 von Bladefire:

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 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 von Olli73:

Zitat von Bladefire:

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: object

Zitat von Sir Rufo:

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 New und FreeMem ! Das Äquivalent zu New ist Dispose und das zu FreeMem ist 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 record mit einem String (kein ShortString ) mit Hilfe von FreeMem freigibst, dann hast du ein Memoryleak, weil der Referenzzähler des Strings nicht runtergezählt wird.

Gruß,
Sven

[Sir Rufo]

Zitat von JamesTKirk:

Mix doch bitte nicht New und FreeMem !

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

[Mikkey]

Zitat von JamesTKirk:

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 von JamesTKirk:

Im Gegensatz zu C# hat Delphi dafür ein Pendant: 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 von Mikkey:

Zitat von JamesTKirk:

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

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

Wollte ich auch gerade schreiben.

Zitat von Bladefire:

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 TAuto = record und da gibt es keine automatische Dereferenzierung (Verhält sich ähnlich zu Klassen in C++).