ein integer in zwei short teilen

hmmmmmmmm schrieb:

müsste es nicht 0xFFFF sein?

Richtig!

Don06

Man muss da nichts umwandeln, alle Zahlen werden doch binär dargestellt. Ob dezimal oder hexadezimal ist doch nur eine Interpretationssache:

// zuerst dezimal:
std::cout << version.get_major() << '.' << version.get_minor() << std::endl;
// dann hexadezimal:
std::cout << std::hex << version.get_major() << '.' << std::hex versíon.get_minor() << std::endl;

Ich würde aber den <<-Operator für die Klasse von Swordfisch überladen, wenn du die Version öfter mal ausgeben willst (zB in eine Datei). Machst du das nicht, sondern benutzt sie nur zum Vergleich mit anderen Versionen, ist das ganz ja vollkommen irrelevant, da 0x92 == 146 == 0222 == 10010010 (binär).

Gruß
Don06

gerritgoetzen

Mit dem &0x00FF leuchtet mir jetzt ein. Danke.

Nun zum anderen Problem. Ich hab ja die Versionsnummern in meinem Struct drin. "major" und "minor" sind als "short" (also 16bit) dort drin.

typedef struct _DLL_VERSION
{
	unsigned short major;
	unsigned short minor;
} DLL_VERSION, *PDLL_VERSION;

Wenn ich nun so

DLL_VERSION version;
int ver = getDLLVersion();
version.major = (ver >> 16) & 0x00FF;
version.minor = ver & 0x00FF;

mein struct fülle, stehen dort folgende werte:
major = 3 // Hex: 3
minor = 146 // Hex: 92

Die Versionsnummer lautet aber nicht 3.146 sondern 3.92. Es geht nämlich um die Hex-Werte und nicht um die dezimalen (so ist es in der Dokumentation der Funktion erklärt). Ich möchte also folgendes speichern:
major = 3
minor = 92

Deshalb auch meine Umrechnung. Ich denke aber das das einfacher gehen muss. Funktionieren tuts ja. Ich hoffe ich habe mich nun verständlicher ausgedrückt.

Danke
Gerrit

(jetzt wart Ihr schneller mit tippen :))

DrakoXP

prinzipiell ist das ja machbar,
aber hast du dir mal überlegt, was passiert, wenn da mal statt 92 ein 9F steht oder so?
wie willst du das dann einfach mal als Dezimalzahl werten?

Swordfish

Was du von getDLLVersion( ) bekommst, sind einen Haufen bits. Nicht mehr und nicht weniger. Nachdem du den int in zwei unsigned short s aufgeteilt hast, hast du wieder einen Haufen bits. Wie Du die interpretierst, ist eine andere Geschichte.

Ist die DLL von Dir, oder bist du "nur" Benutzer? Wenn der Entwickler der DLL vorgibt, dass die Versionsnummern Hexadezimal zu verstehen sind, dann gib sie Hexadezimal aus und alles ist gut.

greetz, Swordfish

.filmor

Eine Möglichkeit wäre auch noch ein Bitset:

struct dll_version_t
{
    unsigned major : 16;
    unsigned minor : 16;
};

dll_version_t version = *reinterpret_cast<dll_version_t*> (getDLLVersion ());

Swordfish

Verdammt, ich bin immer noch viel zu C-lastig. *kopfgegentischplatteknallt*

greetz, Swordfish

wenn es sowieso/nur für windows ist, gibts zu diesem zweck die wunderschönen makros LOWORD und HIWORD.

Swordfish

winner schrieb:

[...] wunderschönen makros LOWORD und HIWORD.

contradictio in adiecto

greetz, Swordfish

Swordfish schrieb:

contradictio in adiecto

genau, ich wollte ja noch "oxymoron" als user hinschreiben

am einfachsten wäre es mit einem short pointer.

short getUpper( long value )
{
    short * ptr = (short*) &value;
    ++ptr;
    return *ptr;
}

short getLower( long value )
{
    short * ptr = (short*) &value;
    return *ptr;
}

Swordfish

plongor schrieb:

am einfachsten wäre es mit einem short pointer.

Wohl eher am unsichersten. Was, wenn ein short 4 Bytes breit ist?

greetz, Swordfish

Gegenfrage, was ist wenn der Integer 33 Byte groß ist und gar nicht durch 2 teilbar ist?

Swordfish

Sch***egal, denn:

gerritgoetzen schrieb:

Laut Dokumentation stehen in den "höherwertigen 16 Bit die Hauptversion" und und in den anderen 16 Bit die Unterversion.

greetz, Swordfish

Ich meine eine Union wäre eine gute Lösung

union
{
unsigned int alles;
unsigned short hälfte[2];
};

Ich meine eine Union wäre eine gute Lösung

union
{
unsigned int alles;
unsigned short hälfte[2];
};

c++-er schrieb:

Ich meine eine Union wäre eine gute Lösung

Ist es aber nicht :p

camper

plongor schrieb:

am einfachsten wäre es mit einem short pointer.

short getUpper( long value )
{
    short * ptr = (short*) &value;
    ++ptr;
    return *ptr;
}

short getLower( long value )
{
    short * ptr = (short*) &value;
    return *ptr;
}

undefiniert

c++-er schrieb:

Ich meine eine Union wäre eine gute Lösung
union
{
unsigned int alles;
unsigned short hälfte[2];
};

ebenfalls undefiniert

Natürlich muss die Repräsentation beider Typen entsprechend zueinander passen (also short: 16bit ohne padding, int: 32bit ohne Padding) - aber beide Verfahren (die auf das Gleiche hinauslaufen) haben dennoch aus dem gleichen Grunde (3.10/15) undefiniertes Verhalten.

Könnte mal jemand einen FAQ Beitrag dazu schreiben warum das undefiniert ist? Ich sehe das nämlich ziemlich oft das eine Union für sowas missbraucht wird.