CE 12: constructor und Free vertragen sich nicht mit den destructor ?

[paule32.jk]

Hallo,
ich habe folgenden Code:

Delphi-Quellcode:

{$APPTYPE CONSOLE}
program fpcqt;

uses Windows, SysUtils;

var
  DLLHandle: HMODULE;

type
  TMyFunction = procedure(s: PChar; v: DWORD); cdecl;
  TCTOR_QChar = function(s: PChar): uint64; cdecl;
  TDTOR_QChar = procedure(v: uint64); cdecl;
var
  MyFunction: TMyFunction;

  CTOR_QChar: TCTOR_QChar;
  DTOR_QChar: TDTOR_QChar;

type
  QChar = class
  private
    ptr_cc: uint64;
  public
    constructor Create;
    destructor Destroy;
  end;

var
  myQChar: QChar;

constructor QChar.Create;
begin
  ptr_cc := CTOR_QChar(PChar('ctor_QChar'));
  WriteLn(Format('ctor1 ptr: %x',[ptr_cc]));
end;

destructor QChar.Destroy;
begin
  WriteLn('ende');
  WriteLn(Format('dtor1 ptr: %x',[ptr_cc]));
  DTOR_QChar(ptr_cc);
  WriteLn(Format('dtor2 ptr: %x',[ptr_cc]));
end;

function check_dllfun(name: String): Pointer;
var p: Pointer;
begin
  p := GetProcAddress(DLLHandle, PChar(name));
  if p = nil then
  begin
    MessageBox(0,
    PChar('Error: Function not found in DLL.' + #13 + name),
    PChar('Error'),
    MB_OK);
    ExitProcess(1);
  end else
  begin
    result := p;
  end;
end;

begin
  DLLHandle := LoadLibrary('fpc-qt.dll');
  if DLLHandle = 0 then
  begin
    MessageBox(0,'Error: DLL could not be loaded.','Error',0);
    ExitProcess(1);
  end;
  try
    @MyFunction := GetProcAddress(DLLHandle, 'addsymbol');

    @CTOR_QChar := check_dllfun('ctor_QChar');
    @DTOR_QChar := check_dllfun('dtor_QChar');

    MyFunction(PChar('jukel'), 2);
    WriteLn('ooo');

    myQChar := QChar.Create;
    myQChar.Free;                 // hier
    WriteLn('oooo');
  finally
      FreeLibrary(DLLHandle);
      ExitProcess(0);
  end;
end.

- wenn ich den constructor QChar.Create aufrufe, dann wird der Delphi CTOR aufgerufen.
- wenn ich aber den destructor durch die Anweisung myQChar.Free; aufrufen möchte, wird der DTOR nicht aufgerufen.
- wenn ich aber den destructor direkt aufrufe, mittels: myQChar.Destroy; wird der DTOR von Delphi aufgerufen.

Hat sich da was geändert, an der Programmierreihenfolge ?
Also, das Free nicht mehr für das "aufräumen" verwendet werden kann ?
wo liegt mein Fehler ?

[himitsu]

override; am Destructor vergessen ... du wolltest nicht, dass der aufgerufen wird, also wurde er nicht.
und inherited; kennst du?

Gibt FreePascal denn keine Meldungen dazu raus?
Delphi macht das.

Zitat:

[dcc32 Warnung] Unit1.pas(31): W1010 Methode 'Destroy' verbirgt virtuelle Methode vom Basistyp 'TObject'

PS: statt #13 besser #10 oder #13#10 oder sLineBreak (oder wie diese Konstante im Lazarus/FPC heißen mag)
ein einzelnes #13 nutzen eigentlich nur der urururalte MAC und im Windows das TRichEdit (z.B. RichEdit50).

[paule32.jk]

ahja, okay.
Du hast recht !
wird als "verbirgt" angezeigt.
Aber der Delphi CE 12 Compiler meldet Erfolg.

kann man irgendwie die Schriftgröße von Delphi Text einschließlich MenuSchrift nicht größer einstellen ?
Ich habe hier einen 1900x1200 Bildschirm, und ich möchte ungern die Schrift-Einstellungen über die Windows-Einstellungen global ändern.

Edit:

Delphi-Quellcode:

function check_dllfun(name: String): Pointer;
var p: Pointer;
begin
  result := nil;
  p := GetProcAddress(DLLHandle, PChar(name));
  if p = nil then
  begin
    MessageBox(0,
    PChar('Error: Function not found in DLL.' + #13 + name),
    PChar('Error'),
    MB_OK);
    ExitProcess(1);
  end;
end;

jetzt funktioniert alles wie erwünscht.

[himitsu]

Erfolg ja. Ist ja nur eine Warning und kein Error oder Fatal.
Eventuell nochmal ein neues "Erzeugen" durchführen? (Shift+F9)


Menüschrift weiß ich jetzt nicht, aber die Editorschrift versteckt sich in den IDE-Optionen und sogar schon im Setup auswählbar ... dort wo das Design (Hell, Dark und Nebellig) gewählt wird.

siehe IDE-Insight
[F6] bzw. im Suchfeld der Optionen
gibt Mehreres zum Thema "schrift"


Beim Start der IDE kann man auch einen Parameter bezüglich HighDPI angeben. Mal im Forum danach suchen?
Im Startmenü nachsehen, dort findet sich ein "Delphi 12 (DPI Unaware)",

[jaenicke]

Ich habe hier gerade kein Delphi, aber die Schriftgröße kann man per Strg + + oder Strg + - verändern und per Strg + 0 auf Standard setzen. In den Optionen findest du die Schriftart unter Editor-Optionen --> Anzeige oder so.

[himitsu]

im D12 unten die TrackBar (beinah glatt vergessen)

und ja, Strg mit + und -
kein Strg+0 und leider auch kein Strg+Scrollrad

Optionen > Editor > Anzeige > Editorschrift

außerdem
Optionen > Editor > Sprache > Insight-Optionen > Editorschriftart verwenden
("Insight" wie CodeCompletion ... nicht wie CodeInsight )


und das Andere war
Optionen > Benutzeroberfläche > IDE-Schriftart
(aber erst nach Neustart)

CodeInsight/HelpInsight, WellcomePage, FormDesigner, Hilfe ... k.A.

[paule32.jk]

Hallo,
in der Dokumentation zu Delphi steht, das char einen WideChar entspricht.
Aber: kann man denn nicht mehr Datentypen, die ein Byte groß sind deklarieren ?
Was ist denn, wenn man Seriale Anwendungen schreiben möchte, die einen älteren Touch haben, und immer nur zwei Bytes in einen Vorgang übertragen (was dann sicherlich bedeuten würde, das die zu übertragende Datenmenge zeitlich um den Faktor 2 sinkt ?).

Delphi-Quellcode:

type
  QChar = class
  private
    ptr_cc: uint64;
  public
    constructor Create; overload;
    constructor Create(c: Char); overload;  // hier
    constructor Create(c: Byte); overload;
    constructor Create(c: AnsiChar); overload;  // und da: entspricht Char
    constructor Create(c: WideChar); overload;  // und nu ? - kein Char, kein AnsiChar, nur Wide ?
    constructor Create(c: DWORD); overload;
    constructor Create(c: Word); overload;
    destructor Destroy; override;
    function isDigit: Boolean;
  end;

[uligerhardt]

Zitat von paule32.jk:

Hallo,
in der Dokumentation zu Delphi steht, das char einen WideChar entspricht.
Aber: kann man denn nicht mehr Datentypen, die ein Byte groß sind deklarieren ?
Was ist denn, wenn man Seriale Anwendungen schreiben möchte, die einen älteren Touch haben, und immer nur zwei Bytes in einen Vorgang übertragen (was dann sicherlich bedeuten würde, das die zu übertragende Datenmenge zeitlich um den Faktor 2 sinkt ?).

Delphi-Quellcode:

type
  QChar = class
  private
    ptr_cc: uint64;
  public
    constructor Create; overload;
    constructor Create(c: Char); overload;  // hier
    constructor Create(c: Byte); overload;
    constructor Create(c: AnsiChar); overload;  // und da: entspricht Char
    constructor Create(c: WideChar); overload;  // und nu ? - kein Char, kein AnsiChar, nur Wide ?
    constructor Create(c: DWORD); overload;
    constructor Create(c: Word); overload;
    destructor Destroy; override;
    function isDigit: Boolean;
  end;

AnsiChar ist der 1-Byte-Typ, das passt schon. Aber Overloads für Char, AnsiChar und WideChar erscheint mir zuviel. Ich würde den für Char streichen und explizit für AnsiChar und WideChar überladen (denke ich ).

[jaenicke]

Zitat von paule32.jk:

Was ist denn, wenn man Seriale Anwendungen schreiben möchte

Dafür gibt es RawByteString, womit keine Zeichensatzumwandlungen usw. passieren, was dafür auch sehr wichtig ist.

[paule32.jk]

weil ich hier schon mit so vielen Datentypen jongliere...
Ich habe gerade gesehen, das auch Delphi generics/templates unterstützt...
Wie kann man denn das mit Templates lösen, weil ich für jeden CTOR den Char-Typ speichern möchte...

Ohne Templates würde bedeuten, das ich mehrere Variablen/Properties halten müsste... ?
Mit Templates könnte ich doch eine interne Klassen-Variable deklarieren, die dann die Unterscheidung macht... ?

Mit dieser Thematik bin ich aber ehrlich gesagt noch sehr grün hinter den Ohren...
Und für sachdienliche Hinweise wie immer dankbar.