Large Integer? Welcher Typ in Delphi

[richard_boderich]

moin!

Kann mir jemand mal bitte sagen was ein "Large Integer" in Delphi für ein Typ ist?

mfG Richard

[sirius]

Kannst du bitte selber in der Delphi-Hilfe schauen, welcher "Integer-Typ" dir am liebsten ist.

mfg
sirius

[mkinzler]

Es kommt darauf an, was du als "large Integer" ansiehst.

Cardinal, VLI

[richard_boderich]

@Sirius

Ich denke mal das war jetzt ironisch gemeint oder? Seit wann kann ich mir beim Übersetzen von C Code nach Delphi den
Integertypen aussuchen? Oder ist das wirklich egal? In der MSDN steht LARGE INTEGER

mfG Richard

[mkinzler]

Zitat:

Zitat von richard_boderich

@Sirius

Ich denke mal das war jetzt ironisch gemeint oder? Seit wann kann ich mir beim Übersetzen von C Code nach Delphi den
Integertypen aussuchen? Oder ist das wirklich egal? In der MSDN steht LARGE INTEGER

mfG Richard

Er meinte des passenden anhand des Wertebereiches

[himitsu]

Long Integer = LongInt = Integer(bei Win32)

Large Integer = Int64 = LARGE_INTEGER = LongLong Integer

PS: LargeWord = UInt64


[add]
Und nicht alles steht in der OH (vorallem von einigen "wichtigen" Generic-Typen weiß diese oft garnichts)

[sirius]

Zitat:

Zitat von richard_boderich

@Sirius
Ich denke mal das war jetzt ironisch gemeint oder? Seit wann kann ich mir beim Übersetzen von C Code nach Delphi den
Integertypen aussuchen? Oder ist das wirklich egal? In der MSDN steht LARGE INTEGER
mfG Richard

(wie mkinzler schon sagte:) Nein, das war keineswegs ironisch gemeint. Es sollte nur auf die Delphi-Hilfe hinweisen. Dort stehen (fast) alle ganzzahligen Typen drinn, die du unter Delphi verwenden kannst. Und daran kannst du selber vergleichen, welche Wertebereich deinem Large_Integer entspricht. Ich wusste ja bisher noch nicht einmal, von welcher Programmiersprache du redest. Ich würde zwar bei einem Large_Integer zuerst auf 32 Bit tippen, aber keine Ahnung ob mit oder ohne Vorzeichen.

Code:

Generische Integer-Typen für 32-Bit-Implementationen von Delphi
Typ   Bereich   Format
Integer   -2147483648..2147483647   32 Bit, mit Vorzeichen
Cardinal   0..4294967295            32 Bit, ohne Vorzeichen

Fundamentale Integer-Typen
Typ   Bereich   Format
Shortint   -128..127                      8 Bit, mit Vorzeichen
Smallint   -32768..32767            16 Bit, mit Vorzeichen
Longint   -2147483648..2147483647   32 Bit, mit Vorzeichen
Int64   -2^63..2^63-1            64 Bit, mit Vorzeichen
Byte   0..255                      8 Bit, ohne Vorzeichen
Word   0..65535                     16 Bit, ohne Vorzeichen
Longword   0..4294967295            32 Bit, ohne Vorzeichen

[richard_boderich]

Tja ich weis, aber leider schweigt sich die MSDN zum Wertebereich dieses Types in der zu übersetztenden Strucktur aus.

Suche in der MSDN hat ergeben:

Signed 64 bit integer

das waere also in Delphi der Int64 Typ

mfg Richard

[richard_boderich]

Danke nochmal an alle :)

herzliche Grüße

Richard

[Popov]

Auf die Gefahr jetzt Unsinn zu schreiben, hier mal eine Info. Mit Integer (Typ) wirst du schon auf der richtigen Seite stehen, denn bei Delphi ändert sich der Typ Integer vom System zu System. Bei 8 Bit hat Integer eine andere Größe als bei 16 Bit (z.B. Windows 3.11). Bei 32 Bit (ab Windows 95) hat Integer auch 32 Bit. Bei 64 Bit Systemen (jetzt wette ich mal) hat Integer 64 Bit. Der Typ Integer paßt sich also an. Oft findet man noch in alten Quellcodes LongInt. Das ist wichtig bei Systemen < 32 Bit. Bei 32 Bit Systemen ist LongInt genauso groß wie bei Integer. Bei alten 16 Bit Systemen dagegen größer.

Ich will jetzt nicht wetten, könnte mir aber vorstellen, daß es LongInt oder 64 Bit ist.

Code:

Typ   Bereich   Format
Shortint   -128..127   8 Bit, mit Vorzeichen
Smallint   -32768..32767   16 Bit, mit Vorzeichen
Longint   -2147483648..2147483647   32 Bit, mit Vorzeichen
Int64   -2^63..2^63-1   64 Bit, mit Vorzeichen

//NACHTRAG: das oben Geschriebene bezieht sich auf Compiler für ein System. Somit hat der Integer bei Delphi 1 für 16 Bit Windows 3.x einen anderen Bereicht als ein Integer bei Delphi für ein 32 Bit Windows. Und sollte es einen Compiler für 64 Bit geben, wird Integer wahrscheinlich 64 Bit haben. Mit Systemabhängig meinte ich also den Compiler für ein System. Und da ein 16 Bit Programm auch auf einem 32 Bit System ein 16 Bit Programm bleibt, ändert sich nichts.

[himitsu]

Short = 8 Bit
Small = 16 Bit
Long = 32 Bit
Large = 64 Bit

... is ja eigntlich recht einfach.

Aus solchen Gründen hatte ich mir mal diese Unit zusammengebastelt.
Wird bei anderen zwar nicht laufen (es sei den ihr löscht einiges daraus),
aber die Typendefinitionen (bis 64 Bit) sollten bei den meisten funktinieren.

[Muetze1]

Zitat:

Zitat von Popov

Auf die Gefahr jetzt Unsinn zu schreiben, hier mal eine Info. Mit Integer (Typ) wirst du schon auf der richtigen Seite stehen, denn bei Delphi ändert sich der Typ Integer vom System zu System. Bei 8 Bit hat Integer eine andere Größe als bei 16 Bit (z.B. Windows 3.11). Bei 32 Bit (ab Windows 95) hat Integer auch 32 Bit. Bei 64 Bit Systemen (jetzt wette ich mal) hat Integer 64 Bit. Der Typ Integer paßt sich also an. Oft findet man noch in alten Quellcodes LongInt. Das ist wichtig bei Systemen < 32 Bit. Bei 32 Bit Systemen ist LongInt genauso groß wie bei Integer. Bei alten 16 Bit Systemen dagegen größer.

Das hängt nicht von dem System ab sondern von deinem Compiler. Es ist ja nun nicht so, dass dein Delphi Programm mit Integer auf einem XP64 oder Vista 64 Bit gestartet auf einmal 64 Bit grosse Integer hat...

[Popov]

Zitat:

Zitat von Muetze1

Das hängt nicht von dem System ab sondern von deinem Compiler. Es ist ja nun nicht so, dass dein Delphi Programm mit Integer auf einem XP64 oder Vista 64 Bit gestartet auf einmal 64 Bit grosse Integer hat...

Jup, war auch so gemeint, hab mich nur allgemein ausgedrückt. Dachte, daß es logisch ist.

[himitsu]

@Popov: wir wissen es, aber am Ende spricht deinen Satz jeder Noob nach
... so entstehen viele falsche Überlieferung.

[Popov]

Zitat:

Zitat von himitsu

@Popov: wir wissen es, aber am Ende spricht deinen Satz jeder Noob nach
... so entstehen viele falsche Überlieferung.

Du misst so einem Beitrag zu viel Bedeutung bei. Theoretisch besteht die Möglichkeit, daß das einer wirklich falsch versteht und versucht mit seinem Delphi 1 32 Bit Programme zu schrieben, aber irgendwann merkt er es. Und sollte er es falsch verstanden haben und es irgendwo wiedergeben, wird er drauf aufmerksam gemacht. Also glaube nicht, daß hier eine Katastrophe möglich wäre. Ich hab sogar einen gebeten bei Arbeiten mit Objekten diese mit try finally zu sichern. Er antwortete mir, daß er auf try finally scheißt und ich ihn nicht mit sowas belästigen, sondern nur seine Fragen beantworten soll. An einer anderen Stelle hatte ich einen Streit mit einigen Programmierern, daß die Ini, wenn sie schon genommen wird, nicht in das Programmverzeichnis gehört, sondern in den Anwendungsdatenordner. Ich wurde als Idiot beschimpft der sich nicht in fremde Angelegenheiten einmischen soll und jedem Programmierer überlassen soll wo er seine Ini speichert. Wobei von den Leuten der Programmordner favorisiert worden ist. Foren sind voll mit falschen Informationen, also keine Panik wegen einem Beitrag den ein Nob falsch verstehen könnte.

[richard_boderich]

In der MSDN habe ich jetzt noch dies gefunden.

Delphi-Quellcode:

typedef union _LARGE_INTEGER {  
struct {  
  DWORD LowPart; 
  LONG HighPart;  
}; 

struct { 
  DWORD LowPart;  
  LONG HighPart;  
} u;
  LONGLONG QuadPart;
} 

LARGE_INTEGER,  *PLARGE_INTEGER;

Das sieht mir aber so aus als wäre das in Delphi eher ein Record mit den einzelnen Typen als ein Int64???? Bitte schreibt mal eure
Meinung dazu.

mfG Richard

[mkinzler]

Sollte doch das Selbe sein.

[OregonGhost]

Das ist eine union. Du kannst wahlweise auf low- und high-Part einzeln zugreifen oder auf den LONGLONG, der auf x86 normalerweise ein Int64 ist. Die Struktur belegt praktischerweise genausoviel Platz wie ein Int64 und kann damit im weitesten Sinne gleichbehandelt werden. Du kannst also ruhig Int64 verwenden.

[Muetze1]

Equivalent zu der Union: Int64Rec aus der SysUtils.

[richard_boderich]

@All
Also ich komme hier einfach nicht weiter. Habe mal mein Demoproject angehängt. Ich möchte die Lastwritetime eines RegistryKeys ermitteln. Die Api
funktioniert auch, wie man an dem Keynamen und der Länge sehen kann. Die Keylänge ist ja immer doppelt so groß, wie die Stringlänge, da Unicode (2 Byte -> 1 Char)
Ich hoffe jemand kann mir hier helfen, da ich nun schon fast Zwei Tage an diesem Mist sitze. Die MSDN zitiere ich mittlerweile schon im Schlaf und meine Frau mault
mich auch schon voll, weil sie mich net mehr zu Gesicht bekommt.

Es geht übrigens um diese Strucktur

KEY_BASIC_INFORMATION
The KEY_BASIC_INFORMATION structure defines a subset of the full information that is available for a registry key.

typedef struct _KEY_BASIC_INFORMATION {
LARGE_INTEGER LastWriteTime;
ULONG TitleIndex;
ULONG NameLength;
WCHAR Name[1]; // Variable-length string
} KEY_BASIC_INFORMATION, *PKEY_BASIC_INFORMATION;

mfG Richard

[himitsu]

in Delphi gibt es den Record auch ... der heißt übrigens ganz einfach LARGE_INTEGER / _LARGE_INTEGER :zwinker:

Delphi-Quellcode:

type // aus Unit Windows
  PLargeInteger = ^TLargeInteger;
  _LARGE_INTEGER = record
    case Integer of
    0: (
      LowPart: DWORD;
      HighPart: Longint);
    1: (
      QuadPart: LONGLONG);
  end;
  TLargeInteger = Int64;
  LARGE_INTEGER = _LARGE_INTEGER;

  ULARGE_INTEGER = record
    case Integer of
    0: (
      LowPart: DWORD;
      HighPart: DWORD);
    1: (
      QuadPart: LONGLONG);
  end;
  PULargeInteger = ^TULargeInteger;
  TULargeInteger = ULARGE_INTEGER;

[richard_boderich]

@Himitsu
is jetz nich dein Ernst oder? ;)
Hast du dir die demo mal angeschaut? Wenn ich einen Int64 nehme liefert mir die Funktion nur noch Schwachsinn zurück.
Ich bezweifle, das es mit einer so großen Recordstruktur anders sein wird. Aber ich teste das mal. Entweder ich hab
nen kapitale Bug drinn oder die MSDN ist dort falsch dokumentiert.

mfG Richard

[himitsu]

ohh, da gibt's 'ne Demo :shock: (war nicht im Themen-Rückblick zu sehn -.-'')

ich schau mal rein :???:

[richard_boderich]

@Himitsu
wenn ich Large_Integer nehme kracht es ->Kernel32.dll exeption
Wenn ich Plargeinteger nehm. funktioniert es, jedoch ist in der Strucktur kein Pointer ausgeschrieben.

Ich habe festgestellt, das wenn ich für den Parameter Time von TKBasicInformation einen Int64 nehm füllt windows anscheinend sie Struktur nicht mehr richtig. Tlasttimewrite sollte eigentlich auch 2 Dword beinhalten statt 2 word. jedoch kracht es dann wieder.
Entweder ich lese die Struktur falsch aus, oder es liegt am Typ des Feldes Time? Die Länge und der String werden ja richtig ausgelesen , das habe ich überprüft.

Richard

[himitsu]

also dann ist es wohl ein Fehler im MSDN?

weil LARGE / LONGLONG = 64 Bit :stupid:

Plargeinteger = Pointer/Integer also wieder 32 Bit ... wird die API wohl doch nur 32 Bit haben wollen :gruebel:

und dieses _KEY_BASIC_INFORMATION hätte ich so Übersetzt

Delphi-Quellcode:

TKeyBasicInformation = packed record
  Time: TFileTime;
  TitleIndex: LongWord;
  NameLength: LongWord;
  Name: Array[0..0] of WideChar;
end;

stimmt sozusagen mit deinem überein.



mit KEY_INFORMATION_CLASS mußt du erstmal aufpassen ... entweder du sorgst dafür daß dieses Set 4 Byte groß ist (standardmäßig macht Delphi dieses nur 1 Byte klein)

oder du definierst es so:

Delphi-Quellcode:

type
  KEY_INFORMATION_CLASS = ULONG;

const
  KeyBasicInformation          = 0;
  KeyCachedInformation         = 1;
  KeyNameInformation           = 2;
  KeyNodeInformation           = 3;
  KeyFullInformation           = 4;
  KeyVirtualizationInformation = 5;

ich mach's gern auch so ... da sieht man den Zusammenhang

Delphi-Quellcode:

type  KEY_INFORMATION_CLASS = ULONG;
const KeyBasicInformation          = KEY_INFORMATION_CLASS(0);
      ...
      KeyVirtualizationInformation = KEY_INFORMATION_CLASS(5);

PS: const KeyBasicInformation: KEY_INFORMATION_CLASS = 0; geht nicht, weil Delphi macht dann eine "konstante" Variable draus -.-''


[add]
hast du nochmal die Parameter deiner APIs geprüft?

VAR, CONST und sowas kennt die WinAPI (C) ja sozusagen nicht

NtQueryKey:
var ResultLength: PULONG würde ich da eher als var ResultLength: ULONG vermuten (kenn jetzt aber die API-Definitionen nicht, aber es wird doch wohl PULONG ResultLength; sein).

[richard_boderich]

@Himitsu

hast du es mal mit deinem Record getestet?

KeyInformationClass ist doch als Aufzählung definiert, oder was meinst du?

Richard

[richard_boderich]

@Himitsu

Habe es jetz mit deinen Änderungen getestet. Es kracht...

Die Konstanten der Klasse Key_Information_Class habe ich als Const definiert wie von dir vorgeschlagen. Leider hat das
überhaupt keinen Einfluss. Sobald ich Time als Tfiletime definiere. -> Exeption

Gruß Richard

[himitsu]

Zitat:

Zitat von richard_boderich

hast du es mal mit deinem Record getestet?

KeyInformationClass ist doch als Aufzählung definiert, oder was meinst du?

nein hab ich nicht, aber es war bisher bei allen anderen Aufzählungen so, welche ich übersetzt hab.

Heißt Delphi würde bei deinem Code nur das niederwertige Byte setzen und Windows den ganzen integer auswerten, wenn du es einfach nur als SET definierst.

Und wenn dein SET strimmt, dann stimmen auch die Werte der Konstanten ... es wird einfach nur durchgezählt.

so, ich lad mir gleich nochmal deine Demo runter ... entweder hab ich grad was zertestet, oder die Variable Test wird nirgend's zugewiesen, weßhalb da nur schrott drinsteht :gruebel:
[add]nee stimmt, TEST wird nirgends was zugewiesen, also Inhalt ist undefiniert[/add]



kannst du mal die ganzen Definitionen posten?
also das woraus du die Funktionsdefinitionen erstellt hast.

[himitsu]

ein bisl PLONG>varLONG geändert

und wenn du von NtQueryKey in KeyInformation 1024 Byte speichern lassen willst,
dann weise KeyInformation erstmal Speicher zu :!: