Hallo Leute,
ich möchte einen 64 Bit Datentyp in einer Struktur aus zwei 32Bit
Datentypen deklarieren.
typedef struct _u64
{
unsigned long high;
unsigned long low;
} u64;
nun sollte es möglich sein, zu diesem zu casten:
also
u64 x;
x = (u64)0x5555aaaaaaaa5555;
Sprich der Benutzer soll ohne die Struktur zu kennen, einen 64Bit
Datentyp definieren können.
Welche Möglichkeiten kennt Ihr dafür in C? Oder hat von Euch jemand
eine bessere Lösung parat (ein Array??).
Wär Euch über Vorschläge und Anregungen sehr dankbar.
Gregor
Ohne daß Du den verwendeten C-Compiler benennst, wird man Dir nicht weiterhelfen können. Ältere C-Compiler kennen keine 64-Bit-Konstanten, so daß ein Konstrukt wie das von Dir zitierte einfach nicht möglich ist. (BC++ 3.1, ältere VC++-Versionen etc.) Neuere C-Compiler kennen von sich aus 64-Bit-Datentypen, so daß der ganze Aufwand entbehrlich wird. (Beispiel: VC++ 6.0 hat __int64 und kennt mit L-Suffix auch entsprechende Konstanten)
Die Lösung soll sich auf moderne Compiler wie auch VC++ 6.0 beziehen. Ich kenne bereits den von Dir erwähnten Int64 Datentyp, möchte aber dennoch eine eigene Variante schreiben, um einfach das Prinzip zu testen, um später auch 128Bit, 256Bit Datentypen etc. deklarieren zu können. Ich möchte quasi wissen, wie man einen größeren Datentyp erstellt, wenn ein Compiler z.B. nur max. 32Bit (long) unterstützt. Wäre also dennoch über Denkansätze und Hilfen froh. Thx
Später möchte ich z.B. auf meine 89C420 auch 64Bit Datentypen verwenden, Compiler SDCC
Hi Das geht (in C) AFAIK so nicht. Woher soll den der Compiler wissen wie der die 64Bit-Konstante in der Struktur ablegen soll. Du mußt schon per .-Operator auf die einzelnen Elemente der Struktur zugreifen. Eine weiter Möglichkeit wäre C++ und dann den = Operator zu überladen. Allerdings wird das bei noch längeren Konstanten auch nicht mehr funktionieren. Matthias
Naja ich möchte schon bei Ansi-C bleiben. Weiß jemand dann wie der __Int64 aufgebaut wird? Sind ja im Prinzip auch 2 Long Variablen. Sowas möchte ich ja quasi auch machen. Das Ziel soll sein, dass ein Benutzer 2 64Bit Werte addieren/multiplizieren kann, ohne vorher die Werte in High/Low Teil aufsplitten zu müssen. Immer unter der Annahme, dass es auf einem System keine 64Bit Register/Datentypen gibt und der COmpiler nur mit 32Bit klarkommt. Nun dachte ich eben an diese Struktur, die ich dann an eine noch zu entwickelnde Addier/Multiplizier Funktion übergebe ala: add(structa, structb, structergebnis) Ideen? Weil wenn da wirklich nichts zu machen ist, werde ich wohl auf die erwähnte Version, die Werte vorher in 2x32Bit aufzuteilen, zurückgreifen müssen.
Wenn der Compiler keine 64 Bit kennt, dann mußt Du alles selber machen,
auch die Zuweisungen:
struct u64 zuweis( long hw, long lw )
{
struct u64 tmp;
tmp.high = hw;
tmp.low = lw;
return tmp;
}
Peter
Das Problem besteht weniger in der Deklaration der verwendeten Struktur (da kann man ja machen, was man will), als in der Unmöglichkeit, Konstanten in dem Compiler unbekannten Datentypen anzugeben. Kennt der Compiler keinen __in64, kann man auch im Quelltext keine konstante Werte dafür definieren, ebensowenig kann der Compiler wissen, wie die Wertzuweisung zu erfolgen hat. Du musst mit Zuweisungen der einzelnen Strukturelemente arbeiten, anders geht es nicht und kann es eben auch nicht gehen, es sei denn, Du hättest den Quelltext des Compilers und würdest den entsprechend anpassen können; ich bezweifle beides. Natürlich kannst Du mit einer Struktur arbeiten und diese auch Funktionen überheben; nur kannst Du vom Compiler nicht erwarten, daß der von selbst eine Typkonvertierung anbietet. Bevor VC++ den Datentyp __int64 kannte, behalf man sich mit einem Datentyp namens LARGE_INTEGER und diversen Funktionen, die damit arbeiten konnten - auf der Ebene kannst Du arbeiten. (Die zugehörige Headerdatei, auch bei VC++ 6.0 dabei, heisst largeint.h, die zugehörige Library heisst largeint.lib, der Sourcecode davon scheint nicht mehr verfügbar zu sein).
Die entscheidende Frage ist: Ist die Reihenfolge der Variablen in einem Struct fest definiert? Ich glaube nicht. Und wenn du dort einen 64Bit Wert reinschreibst, wie soll der Compuiler ihn dort ablegen? In Intel schreibweise? Oder andersrum? Ich wuerde mal sagen deine Idee wunderbar um ein Programm zu erzeugen das nicht auf jedem Compiler gleich uebersezt wird und dir in Zukunft viele ueble Stunden mit dem Debugger bescheren wird. Olaf
Die Reihenfolge ist doch egal, da immer nur auf einzelne Elemente zugegriffen wird. Nur bei einer Union spielt die Reihenfolge eine Rolle, aber man kann ja keine Union mit einem nicht existierenden Datentyp machen. Peter
Vielen Dank für Eure Antworten, ich werde mir mal diese LARGE INT Datei anschauen, vielleicht kann ich da ein paar Ideen herausholen. Ansonsten werde ich wie erwähnt vorgehen, und die High/Low Werte einzeln eintragen (lassen).
Thread beobachten
Seitenaufteilung abschaltenBitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.