Ich habe eine Funktion...

int getDLLVersion(void);

..die mir eine Vesionsnummer zurück gibt. Laut Dokumentation stehen in den "höherwertigen 16 Bit die Hauptversion" und und in den anderen 16 Bit die Unterversion.
Bsp.: 0x00010003 bedeutet Version 1.03

Jetzt wollte ich die Version direkt in ein Struct speichern:

struct DLLVersion {
  short minor;
  short maior;
}
DLLVersion version;
version = getDLLVersion();

Leider geht das so nicht (was ich schon vor dem Kompilieren ahnte).
Ich weiß jetzt nur leider nicht weiter. Ein Tipp wäre hilfreich. Wenn der Aufwand dafür zu groß ist, speichere ich die Version halt nur als int.

Danke für die Hilfe.
Gerrit

greetz, Swordfish

dll_version_t( int dll_version ) : m_major( ( dll_version >> 16 ) & 0x00ff ), m_minor( dll_version & 0x00ff ) { }

Binäre operationen sind also die Lösung meines Problems. Ich habe mich also mal im Netz schlau gemacht und frage mich nun, ob nicht hier:

...m_major( ( dll_version >> 16 ) & 0x00ff )...

die UND-Operation überflüssig (redundant) ist, da ">>" doch automatisch mit 0 auffüllt. Mache ich einen Denkfehler oder ist das zur Sicherheit, weil die Compiler das unterschiedlich machen?

Noch viel wichtiger:
Die gespeicherten werte sind ja dezimal. Die Versionsnummern sind aber Hexadezimal ausgedrückt.
Was ich meine: Die Versionsnummer lautet z.B.: 3.92
Mein major-Hex-Wert ist also 3
mein minor-Hex-Wert ist 92
In meinem Struct stehen aber ja Integerwerte also 3 und 146. Wie mache ich also eine Hex-92 zu einer Dec-92?
Beim googlen bekomme ich immer nur Dec-Hex-Konverter, was mir ja nun nix bringt.

Danke nochmal.
Gerrit

Aber nach wie vor finde ich nicht heraus, wie ich aus der hex-92 eine int-92 machen kann. Es muss doch einfacher gehen als so (funktionieren tuts):

int ver = getDLLVersion();

		// dieser Umweg muss noch ersetzt werden
		int tmp;
		float bruch;

		MEDllVersion.major = ver >> 16;
		bruch = float(MEDllVersion.major)/16;
		tmp = int(floor(bruch));
		MEDllVersion.major = tmp*10 + (MEDllVersion.major - tmp*16);

		MEDllVersion.minor = ver & 0x00FF;
		bruch = float(MEDllVersion.minor)/16;
		tmp = int(floor(bruch));
		MEDllVersion.minor = tmp*10 + (MEDllVersion.minor - tmp*16);

gerritgoetzen schrieb:

Noch viel wichtiger:
Die gespeicherten werte sind ja dezimal. Die Versionsnummern sind aber Hexadezimal ausgedrückt.
Was ich meine: Die Versionsnummer lautet z.B.: 3.92
Mein major-Hex-Wert ist also 3
mein minor-Hex-Wert ist 92
In meinem Struct stehen aber ja Integerwerte also 3 und 146. Wie mache ich also eine Hex-92 zu einer Dec-92?

Bist du dir sicher dass dich das ueberhaupt interessiert?
Falls ja, ein hex-to-dec ist relativ trivial:

int hex2dec(int hex)
{
  int dec = 0;
  while(hex > 16)
  {
    dec = (dec * 16) + (hex % 16);
    hex /= 16;
  }
  return dec + hex;
}

(ohne Gewaehr)

müsste es nicht 0xFFFF sein?

Richtig!

// 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

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 :))

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

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

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

greetz, Swordfish

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

contradictio in adiecto

greetz, Swordfish

contradictio in adiecto

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

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

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

am einfachsten wäre es mit einem short pointer.

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

greetz, Swordfish

gerritgoetzen schrieb:

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

greetz, Swordfish

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

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

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

Ist es aber nicht :p

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.