C++ Struct nach Delphi portieren

[Zacherl]

Hey,

ich habe hier ein etwas komplexeres C++ Struct, welches ich gerne nach Delphi portieren würde:

Code:

struct HPOLY
{
   HPOLY() : m_nWorldIndex(0xFFFFFFFF), m_nPolyIndex(0xFFFFFFFF) {}
   HPOLY(__int32 nWorldIndex, __int32 nPolyIndex) : m_nWorldIndex(nWorldIndex), m_nPolyIndex(nPolyIndex) {}
   HPOLY(const HPOLY& hPoly) : m_nWorldIndex(hPoly.m_nWorldIndex), m_nPolyIndex(hPoly.m_nPolyIndex) {}
   
   HPOLY &operator=(const HPOLY &hOther)
   {
      m_nWorldIndex = hOther.m_nWorldIndex;
      m_nPolyIndex = hOther.m_nPolyIndex;
      return *this;
   }

   bool operator==(const HPOLY &hOther) const
   {
      return (m_nWorldIndex == hOther.m_nWorldIndex) && (m_nPolyIndex == hOther.m_nPolyIndex);
   }
   bool operator!=(const HPOLY &hOther) const
   {
      return (m_nWorldIndex != hOther.m_nWorldIndex) || (m_nPolyIndex != hOther.m_nPolyIndex);
   }
   __int32 m_nPolyIndex, m_nWorldIndex;
};

Allerdings habe ich keine Ahnung, was die wiederholte deklaration von HPOLY im Struct selbst bedeuten soll und ebenso weiß ich nicht, wie die Struct Operatoren in Delphi umgesetzt werden können.

Ich hoffe irgendein C Kenner kann mir da weiterhelfen.

Viele Grüße
Zacherl

[himitsu]

Also, der Record selber sieht so aus, von den Daten her:

Delphi-Quellcode:

HPOLY = record
  m_nPolyIndex, m_nWorldIndex: LongInt;
end;

HPOLY() wäre wohl eine Art Constructor, welches bei Delphi-Records nicht gibt, bzw. welches nicht nötig ist, da man es ja manuell aufrufen muß, denn eine automatische Initialisierung gibt es leider nicht :cry:
Da wirst'e dir wohl besser eine Init-Prozedur draus machen müssen.

Die nächsten zwei HPOLY( sind och sowas, nut mir Parametern zur Initialisiereung,
also nochein Init, aber mit

Delphi-Quellcode:

m_nPolyIndex, m_nWorldIndex: LongInt;

als Parameter,
das 3. HPOLY( kannst'e eigentlich weglassen, da es nur den record kopiert, was Delphi automatisch macht.

und danach kommen dann ein paar Klassenoperatoren (class operator ).

[add]

Delphi-Quellcode:

HPOLY = record
  FPolyIndex, FWorldIndex: LongInt;
  procedure Init;
  procedure Init(PolyIndex, WorldIndex: LongInt);
  procedure Init(const Source: HPOLY);
//class operator Implicit(const Source: HPOLY): HPOLY;
  class operator Equal   (const Source: HPOLY): Boolean;
  class operator NotEqual(const Source: HPOLY): Boolean;
end;

Delphi-Quellcode:

HPOLY = record
  FPolyIndex, FWorldIndex: LongInt;
  class function Init: HPOLY;
  class function Init(PolyIndex, WorldIndex: LongInt): HPOLY;
  class function Init(const Source: HPOLY): HPOLY;
//class operator Implicit(const Source: HPOLY): HPOLY;
  class operator Equal   (const Source: HPOLY): Boolean;
  class operator NotEqual(const Source: HPOLY): Boolean;
end;

Delphi-Quellcode:

HPOLY = record
  FPolyIndex, FWorldIndex: LongInt;
  constructor Create;
  constructor Create(PolyIndex, WorldIndex: LongInt);
  constructor Create(const Source: HPOLY);
//class operator Implicit(const Source: HPOLY): HPOLY;
  class operator Equal   (const Source: HPOLY): Boolean;
  class operator NotEqual(const Source: HPOLY): Boolean;
end;

[Zacherl]

Vielen Dank für deine Erklärung. Dass es sich um Konstruktoren handelt, da wär ich nie drauf gekommen :D Hatte da eher spontan auf variante Records getippt ^^

[himitsu]

Hab oben mal was nacheditiert.

PS: Warum werden beim Editieren über den Inlineeditor keine neuen Beiträge geladen, wenn zwischendurch geantwortet wurde?

Nee, das Meiste sind einfach nur "Methoden"/Funktionen.
Du kannst das Verhalten aber auch gerne in einen eigenen Variant-Typ verpacken, aber dein D2010 kennt ja schon die Record-Operatoren, so daß man es quasi fast komplett direkt übersetzen und so belassen kann.

[Zacherl]

Wow danke dir recht herzlich :) Ich teste das zu Hause direkt mal im Einsatz. Beeinflussen class operator Felder eigentlich die Größe des Records?
Würde ich z.b. jetzt einen Record mit einer normalen Methode erstellen, wäre dieser ja 4 Bytes groß. Ich frage nur, weil dieser Record zu einer anderen Anwendung kompatibel gelesen / gespeichert werden soll. Da wäre es natürlich blöd, wenn durch die class operators die Größe verfälscht wird.

[Neutral General]

Hallo,

Delphi-Quellcode:

type 
  TTest = record
    A: Integer;
    procedure Blubb;
    class function X: Integer; static;
  end;

// SizeOf(TTest) = 4

:arrow: Nein, die Größe wird nicht verändert ;)

[Zacherl]

Perfekt danke dir! Konnte leider nicht selbst testen, da hier kein Delphi installiert ist :P

Edit: Moment das verwundert mich jetzt, dass die procedure die Größe auch nicht beeinflusst. :? Argh achso ne da war ich wohl in Gedanken bei den VTable Functions.

[Deep-Sea]

Zitat:

Zitat von himitsu (Beitrag 1080279)

[...] wäre wohl eine Art Constructor, welches bei Delphi-Records nicht gibt [...]

Natürlich kennt Delphi in neueren Versionen erweiterte Records, die auch Konstruktoren haben können?! :shock:

[himitsu]

@Deep-Sea: Njain, es kennt Konstruktoren, aber es nutzt diese nicht automatisch.

Wäre zu schön, wenn bei

Delphi-Quellcode:

var X: HPOLY;

Delphi automatisch den Contructor aufruft, wenn die Variable Initialisiert wird, ebenso den Destructor beim Freigeben und ein "Clone" beim Kopieren.

Technisch wäre es möglich, und ich hatte (vor)letzes Jahr Emba auch diesbezüglich einen Eintrag im QC spendiert, wo ich sogar zeigte, daß es eigentlich sehr einfach zu implementieren wäre und wo man was ändern/erweitern müßte, da Delphi die Grundvoraussetungen schon besitzt (siehe String, dynArray und Interface), aber leider gab es da nie eine Reaktion.

@Zacherl:
Nee, es ändert nicht die Größe.
Diese Operatoren und Record-Methoden sind quasi statische Prozeduren, welche nur über den Typen im Compiler verlinkt sind, aber am Typen sonst Speichertechnisch nichts verändern.
PS: virtuelle Methoden gibt es nicht, welche da was verändern/vergrößern könnten, da Records eh keine Vererbung kennen.

[Deep-Sea]

@himitsu:
Das stimmt natürlich - leider. Aber Konstruktoren an sich gibt es halt schon :-D

[Assarbad]

Zitat:

Zitat von Zacherl (Beitrag 1080280)

Vielen Dank für deine Erklärung. Dass es sich um Konstruktoren handelt, da wär ich nie drauf gekommen :D Hatte da eher spontan auf variante Records getippt ^^

struct und class sind in C++ identisch mit dem einen kleinen Unterschied, daß in einer struct alle Elemente (Funktionen und Daten) implizit public sind und bei class eben private.

Wenn ich jedoch schreibe:

Code:

class foo
{
public:
  foo() {}
}

ist das im Grunde (bis auf die Typisierung) das gleiche wie:

Code:

struct foo
{
public:
  foo() {}
}

[himitsu]

Und was ich in Delphi grade wieder liebe, sind diese Meldungen, für Konstructoren, mit keinen oder nur varianten Parametern:

Delphi-Quellcode:

[DCC Fehler] Unit3.pas(25): E2394 Parameterlose Konstruktoren sind für Record-Typen nicht zulässig
[DCC Fehler] Unit3.pas(37): E2471 Möglicherweise parameterlose Konstruktoren sind in Record-Typen nicht zulässig

Wo mir auch noch keiner plausibel erklären konnte, warum das nicht erlaubt ist.