Daten von C nach PAS und PAS nach C ...

[dummzeuch]

Zitat von paule32.jk:

ah mich deuchtet was ...
der Thomas hat im Quellcode GetProcAddr Pointer verwendet.

jetzt fällt mir gerade ein, das ja der Constructor - egal welche Sprache, ja eine Objekt-Referenz zurückliefert, die dann durchgereicht werden kann...
nicht schlecht sprach Herr Specht.
Danke

Ich reiche keine Pointer auf Instanzen durch sondern nur ein Handle, welches einem Index in ein Array von Instanzen entspricht. Schau Dir den im Vortrag genannten Link auf ein Beispiel bei Embarcadero an, da steht, wie das funktioniert.

Wichtig: Eine C++-Instanz wird automatisch freigegeben, wenn es keine Referenz mehr darauf gibt. Deshalb muss man diese Istanz im Array speichern, bevor die Funktion in der DLL, die die Instanz erzeugt hat, verlassen wird. (Zumindest habe ich das gerade so in Erinnerung, es ist schon wieder eine ganze Weile her, dass ich mich mit dem Kram beschäftigt habe.)

[himitsu]

OK, Objekt vom C++, welches im Delphi durchgereicht wird.

Ober Objekt von Delphi, welches im C++ durchgereicht wird.
Joar, falls dort ARC aktiv wäre, dann hätte man ebenfalls diesen Spaß mit der Referenzzählung.

[paule32.jk]

Hallo Thomas,
ja, das stimmt.
Speicher(variablen) wird solange gehalten bis sie nicht mehr genutzt werden.
Es gibt zwei Arten, wie Variablen gehalten werden:

Heap => innerhalb einer Prozedur/Funktion gültig (lokaler Scope), und:
Stack => überlebt, wenn die Prozedur/Funktion verlassen wird.

Das mit den Array war ja auch so in meine Richtung...
Eine in C++ verwendete std::map< std::string, void* > Insntanzen;

Dann braucht man nur noch in etwa sowas machen: instanzen["foo"] = 0xcafebabe;
und die map im globalen Scope belassen, dann überleben die Pointer.

Aber ich habe gerade ein anderes Problem:

hier verwende ich einen Delphi-PChar:

Delphi-Quellcode:

{$APPTYPE CONSOLE}
program Project1;

uses Windows;

type
  TMyFunction = procedure(s: PChar); cdecl;

var
  DLLHandle: HMODULE;
  MyFunction: TMyFunction;

begin
  DLLHandle := LoadLibrary('foo.dll');
  if DLLHandle = 0 then
  begin
    MessageBox(0,'Error: DLL could not be loaded.','Error',0);
    ExitProcess(1);
  end;
  try
    @MyFunction := GetProcAddress(DLLHandle, 'TestFunction');
    if @MyFunction = nil then
    begin
      MessageBox(0, 'Error: TestFunction not found in DLL.', 'Error', 0);
      ExitProcess(1);
    end;
    MyFunction(PChar('jukel'));
  finally
      FreeLibrary(DLLHandle);
      ExitProcess(0);
  end;
end.

und hier nur einen 0-terminierten C char *:

Code:

#include <windows.h>
#include <iostream>

#ifdef _WIN64
    #define DLL_EXPORT __declspec(dllexport)
#else
    #define DLL_EXPORT
#endif

extern "C" {
DLL_EXPORT void TestFunction(char* func) {
    std::cout << "Func: " << func << std::endl;
}
};

beide Image-Dateien sind im 64-Modus kompiliert.
Aber ich erhalte als Ergebnis (auf der Konsole):

Func: j

[Sinspin]

Was ist denn char in C++ und PChar in Delphi für ein Typ? Haben die die gleiche Anzahl von Bytes je Zeichen?

[himitsu]

der C++ Char ist Byte

(wir könnten es aber auch als AnsiChar ansehn, ohne P)

[paule32.jk]

Hallo,

ich habe gerade hier nachgesehen: Delphi PChar -> C++

dort wird PChar als PWideChar deklariert.

Ich hatte das noch von früheren Delphies und C plus'sers in Erinnerung, das jeweils unter Delphi und C/C++ ein PChar einen char* entsprach - also beide die gleiche Bitbreite hatten. In modernen Sprachen, habe ich gerade mitbekommen, das PChar unter C++ tatsächlich 8-Bit entsprechen und null-terminiert sind.
Aber in modernen Anwendungen PWideChar - also mit 16-Byte pro Zeichen gearbeitet wird, was dann bedeutet, das 2 Zeichen verarbeitet werden. Nach dem eigentlichen Zeichen, auch bei UTF-8, ein null-Byte hinten drann kommt, und ebenfalls null-terminiert wird - aber halt mit null-null-Byte.

Jetzt fällt mir auch ein, das Windows 11 und frühere Versionen schon auf 16-Bit umgestellt haben, so dass in modernen Compilern aus utf-8, das eine Mixtur aus 8 und 16-Bit ist, generell auf 16-Bit breite arbeiten.

Bin halt nicht mehr der jüngste - und nicht mehr ub du dätde.
Schande über mein Haupt - und verzeiht mir

Der Tipp von Sinspin war also goldwert - Danke !

Edit:
Die C++ Version des getesteten Testes ist dann so lauffähig:

Code:

#include <windows.h>
#include <iostream>

#ifdef _WIN64
    #define DLL_EXPORT __declspec(dllexport)
#else
    #define DLL_EXPORT
#endif

extern "C" {
DLL_EXPORT void TestFunction(wchar_t* func) {    
    std::wcout << "Func: " << func << std::endl;
}
};

[himitsu]

Das Delphi-Char ist ein generischer Typ, also compilerabhängig und stellt aktuell einen Alias des WideChar dar. (vor 2009 war es ein AnsiChar)

Das C++-char ist ein statischer Typ, also ist immer 1 Byte groß, ähnlich dem uchar, entgegen dem wchar mit 2 Byte.




Und genau so ein Mist, ist es, weswegen das WinMD an vielen Stellen total verbuggt ist.
https://www.delphipraxis.net/214473-...vor-winmd.html

[paule32.jk]

Hallo,

- schaltet sich damit Microsoft Windows aus, oder:
- ist das ein Problem beim Delphi-Entwickler ?

wenn lezteres, ist das:
- ein Problem der CE Versionen, oder:
- ein Problem aller Versionen ?

wenn lezteres, warum will der Delphi-Enwickler für eine Pro-Version: 1.234 Euro (im Angebot) ?
wenn lezteres, sind denen die russischen Leute abgehauen, weil sie gegen den kapitalistischen Westen ein Dorn im Auge sind ?

Fragen über Fragen...