wenn ich mir ein Byte-Array deklariere und dieses mit Werte fülle, und mit einem Struct draufzeige, dann kommen mir unverständliche Werte.

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

void main()
{
	struct strAktion
	{
		BYTE bAktion;
		WORD len;

	};
	BYTE p[5] = { 49,01,00,01,99 };

	strAktion * a = (strAktion *) p;
	cout << a->bAktion << endl;
	cout << a->len << endl;
}

Mal angenommen "p" hat die Adresse 0, so müssten die Variablen im Struct nach der Zuweisung ja die Adressen 0 für strAktion->bAktion und 1 für strAktion->len haben (Low-Byte kommt zuerst).
D.h. es müssten folgende Werte ausgegeben werden: 1 (ascii für 49) und 1 für strAktion->len.

Aber stattdessen bekomme ich folgende Ausgabe: 1 für strAktion->bAktion was auch richtig ist, aber für strAktion->len bekomme ich 256.
D.h er weist dem Short wert die Adresse 2 zu statt 1 (was meiner Ansicht richtig sein müsste), womit ein Byte übersprungen wird.

Wo ist da der Wurm drin? Ist es Tatsälich ein Compiler Fehler, oder denke ich einfach nur Falsch.

Gruß Stu

PS.: Ich benutze Visual Studio 6.0

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

void main()
{
	WORD *len;

	BYTE p[5] = { 49,01,00,01,99 };

	len = (WORD *) p + 1;
	cout << *len << endl;
}

Bei einer Manuellen zuweisung der Adress von "len" bekommt die Variable nicht den Wert p +1, sonder p + 2!
D.h. wenn p die Adresse 0 hat, dann ist len nach der zuweising p+1 nicht 1, sonder 2.

Wenn ich vorher aber nen Byte zeiger auf p+1 setze, ihn danach zum nem WORD zeiger convertiere, so funktioniert es.

/*WORD *len;
	BYTE *b;

	BYTE p[5] = { 49,01,00,01,99 };

	b = p + 1;
	len = (WORD*) b;

	cout << *b + 0x30<< endl;
	cout << *len << endl;*/

Das kann doch net sein...
Konnte das wirklich am paddingbyte liegen? denn ich deklariere den buffer doch selbst und gebe die Werte ein.

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

void main()
{
	WORD *len;

	BYTE p[5] = { 49,01,00,01,99 };
	
	len = (WORD *) p + 1;
	cout << *len << endl;
}

Allein das ist ja völlig falsch. So sollte es aussehen:

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

int main()
{
	WORD *len;

	BYTE p[5] = { 49,01,00,01,99 };

	len = (WORD *) p + 1;
	std::cout << *len << std::endl;
}

Und jetzt mal Windowsunabhängig:

#include <iostream>

int main()
{
	int * len;

	unsigned char p[5] = { 49,01,00,01,99 };

	len = (int *) p + 1;
	std::cout << len << " " << (void*) p << std::endl;
}

Und wenn ich das starte, bekomme ich genau das erwartete. len zeigt 4 bytes weiter als p.

Bespiespeicher:

unsigned char p[5] = { 49,01,00,01,99 };
Angenommen p ist auf adresse 0, dann würde der Speicher so aussehen:

0 : 49
1 : 01
2 : 00
3 : 01
4 : 99

len = (unsigned short p + 1;

wenn p = 0 ist, dann ist p + 1 = 1, d.h len sollte die Adresse 1 haben, damit die nächten 2 bytes ausgelesen werden können.

Wenn ich den code aber Debugge, dann hat len nach der Zuweisung nicht p+1, sondern p+2.

len = (unsigned short p + 1;

wenn p = 0 ist, dann ist p + 1 = 1, d.h len sollte die Adresse 1 haben, damit die nächten 2 bytes ausgelesen werden können.

Falsch sizeof(unsigned short) ist 2
daher gibt

(unsigned short *) p + 1;

eine adresse p + 2 bytes.

wenn du unbedingt die adresse des 2. bytes willst dann entweder

unsigned short * len = (unsigned short *)& p[1];

oder

unsigned short * len = (unsigned short *)((char *)p + 1);

Du solltest dich etwas mit Pointerarithmetik befassen.
Kurt

EDIT geht natürlich auch so

unsigned short * len = (unsigned short *)( p + 1);