C++ Hack (Frage)

[Mental Wreck]

Hey,
ich hätte da mal eine Frage.
Da mir geholfen wurde bei meinem ersten Hack habe ich immernoch nicht herrausgefunden wie man diesen Teil herrausfindet:

*(BYTE*)ADR_XXXXXX = ***;

Also,
bei manchen Sachen steht BYTE bei manchen FLOAT usw... könnte mir mal jemand den Teil erklären^^? Kommt zwar nooblike rüber, aber fragen darf man ja wohl.

[.BritainAndy]

google nach datentypen in c++

[Mental Wreck]

BrtainAndy,
ich glaube du meinst was anderes als ich (:

[.BritainAndy]

WIllst du erklärt haben was DWORD, BYTE usw bedeuten doer wieso sie an dem Teil des Codes stehen?

[Mental Wreck]

Wieso sie dort stehen und wie ich herrausfinde warum dort BYTE hinkommt und nicht FLOAT.

[yihaaa]

Weil ADR_XXXXXX scheinbar ein BYTE* ist.

MfG

Edit: Wenn du mal etwas mehr von dem Code zeigen würdest...

[xNopex]

Wieso sie dort stehen und wie ich herrausfinde warum dort BYTE hinkommt und nicht FLOAT.

Kommt darauf an, wieviele Speicherzellen du "ansprechen" möchtest. Das wiederum hängt mit dem Speicherbedarf von int, char,... ab. Siehe:

char = 1 Byte
int = 4 Byte
float = 4 Byte
double = 8 Byte

Quelle:

Obwohl der Speicherbedarf je nach Compiler etwas schwanken kann. Dabei wird aber immer eine Minimale-Größe eingehalten, die im Standard festgelegt wurde.
Der Zeiger selber hat keine Ahnung, wie groß der Speicher ist, auf den er zeigt. Er weiß nur, wie groß ein Element ist, was durch den Datentyp des Zeigers festgelegt wird. D.h. ein Element eines Zeigers vom Typ BYTE ist ein Byte groß. Ein Element eines Zeigers vom Typ int ist 4Bytes groß:

int* pInt = new int[5]; //pInt zeigt auf eine Speicherfolge von Integer-Werten, Gesamtspeicherbedarf: 5*4 = 20
int element1 = pInt[0]; //Erstes Element = 4Bytes groß; Speicherzellen 0-3

Über einen Integer-Zeiger hast du also immer nur Zugriff auf 4Speicherzellen. Das heißt folgendes:

int* pInt = new int[5];
int i1 = pInt[0]; //Speicherzellen 0-3
int i2 = pInt[1]; //Speicherzellen 4-7
...

Wie du siehst hast du nie direkten Zugrif auf eine einzelne Speicherzelle zum Beispiel Speicherzelle 2. Wenn du eine einzelne Zelle ansprechen möchtest, hilft nur ein unsigned char*-Zeiger (Entspricht BYTE):

int* pInt = new int[5];
BYTE* pByte = pInt+1;
BYTE speicherzelle2 = pByte[0];

Woher du weißt, welchen Zeiger-Typ du verwenden musst? Das erschließt sich aus dem, was du tun willst. WIllst du zum Beispiel einzelne Op-Codes ändern, nimmst du natürlich einen BYTE-Zeiger, weil die op-Codes genau 1Byte groß sind (0x0-0xFF) und damit genau in einer Speicherzelle Platz finden. Willst du Adressen ändern, auf die Pointer zeigen, dann verwendest du natürlich unsigned int (DWORD), weil eine Adresse (bei 32bit) genau 4Bytes groß ist. Usw.

Wer Fehler findet, darf verbessern.

Weil ADR_XXXXXX scheinbar ein BYTE* ist.

Q:Warum ist der Ball rot?
A:Weil der Ball scheinbar rot ist.

[Medix]

Gibt an auf welchen Datentyp der Zeiger zeigt.

falsch

bool x = 1;
*(DWORD*)&x;

richtig:

bool x = 1;
*(bool*)&x;

[Xenox3]

@Medix du kannst nicht sagen das das falsch ist du bekommst es halt nur in einem andren format zurück geliefert (kann auch gewollt sein)

[Medix]

Inwiefern sollte das gewollt werden?

Bitte um ein Beispiel

[xNopex]

Originally Posted by Medix

Gibt an auf welchen Datentyp der Zeiger zeigt.
[S]richtig:[/S]

bool x = 1;
*(bool*)&x;

Leider immer noch komplett falsch.
richtig:

bool x = true;
...

Desweiteren brauchst du ja keinen Cast (dazu noch im C-Style), wenn du einer Variable gleichen Typs den Wert des Pointers zuordnen willst:

bool y = *(bool*)&x;
//entspricht
bool y = x;

Inwiefern sollte das gewollt werden?
Bitte um ein Beispiel

-->

DWORD WINAPI ExampleThread(LPVOID lpParam)
{
    MY_PARAM_STRUCT* pmyStruct = reinterpret_cast<MY_PARAM_STRUCT*>(lpParam);
...

[Medix]

Leider immer noch komplett falsch.

was heißt hier komplett falsch?

Was macht es für einen unterschied ob ich mit 1 oder true die variable ansetze?
Da hät ich jetzt gerne eine gute erklärung von dir.

[xNopex]

Weil bool in C++ entweder 'true' oder 'false' ist und keine integer Zahl. Warum meinst du hat man in C++ so einen Datentyp als Standard eingeführt? Dass du dann weiter mit deinen Zahlen rumhantieren kannst? :-/ Das ist einfach nur schlechter Stil, falsch, und schlecht!

Furthermore:

In Visual C++ 5.0 and later, bool is implemented as a built-in type with a size of 1 byte.

Quelle:

Jetzt rate mal, was passiert, wenn du einem 1Byte Datentyp einen 4Byte großen Wert zuordnest. Wahrscheinlich hat der Microsoft Compiler (bzw. jeder andere) aber auch für solche Fälle vorgesorgt und optimiert euren schlechten Code...
Es ist und bleibt aber dumm.

[Medix]

wer sagt denn das 1 = 4bytes sind?
char ist genau so ein byte und kann ebenso den wert 1 annehmen.

1 wird erst zu 4 bytes wenn du einem datentyp der 4bytes hast den wert 1 zuweist.

Zudem wird true,false auch nicht mehr als irgend ein define auf 0 oder 1 sein weil spätestens wenns zu Maschinencode umgewandelt wird steht 0,1 dort.

Das hat imo nichts mit schlechtem code zu tun. Maximal vom Stil her... aber who cares?
your argument is invalid.

[xNopex]

Der Compiler entscheidet wie viel Speicher er jeweils reserviert. Das meinte ich mit optimieren.

Zudem wird true,false auch nicht mehr als irgend ein define auf 0 oder 1 sein weil spätestens wenns zu Maschinencode umgewandelt wird steht 0,1 dort.

false ist meistens als 0 definiert und true als ungleich 0. Und du arbeitest nicht mit Assembler, sondern mit C++! Nochmal die Frage an dich: Warum führt der !Standard! einen Datentyp mit eindeutig definierten Zuständen ein, wenn du diese dann misachtest? Das ist schlicht falsch und schlecht programmiert. Eine bool Variable ist entweder true oder false. Es ist doch egal, wie sie intern behandelt wird. Das ist btw. von Compiler zu Compiler unterschiedlich, weil der Standard das nicht eindeutig festlegt. Aber ich weise doch als vernünftiger Programmierer keiner bool-Variable einen Wert zu, dessen Zustand so nicht eindeutig definiert ist. Das ist doch Wahnsinn. I-wann kommst du auf die Idee Strings als Kette von Zahlen zu schreiben, weil der Computer später eh mit Zahlen arbeitet. Nur erwartet man als fremder Leser deines Codes nicht eine Aneinanderreihung von Zahlen, sondern einen lesbaren Text. Sonst kannst du gleich alles mit deinem Hex-Editor schreiben. Wozu dann noch ne Hochsprache mit Regeln? Frei nach deinem Motto: Der Computer arbeitet eh nur mit Zahlen... Warum nicht gleich alles binär eintippen?
Diese Regeln (Syntax) sollen dem Programmierer die Arbeit erleichtern, dass er sich nicht merken muss, ob 0 oder 1 jetzt true oder false ist. Sondern er merkt sich einfach entsprechende Schlüsselwörter. Deswegen hat C++ ja diesen Datentyp eingeführt, wohingegen C keinen solchen Datentyp kennt, was sicherlich oft genug zu Problemen geführt hat. Ich verstehe jetzt die Diskussion auch gar nicht. Akzeptiere doch einfach, dass es falsch, sprich schlecht, ist, wenn man einem Wahrheitswert direkt einen numerischen Wert zuweist, wenn es entsprechende Schlüsselwörter dafür gibt. Warum in Gottes Namen sollte man soetwas tun?

EDIT: Nur mal so als hypothetisches Beispiel:
Da true als ungleich 0 definiert ist, dkann ein Compiler, der den Standard beachtet, das Schlüsselwort 'true' als 0xFF definieren. Das macht wahrscheinlich kein Compiler, aber es ist möglich. Was passiert dann, wenn du deinem Wahrheitswert '1' zuweist? Undefiniertes Verhalten. Es kann alles passieren. Aber du hast schon Recht: Who cares. Ich mache btw. auch keine Zeilenumbrüche, ich meine, ist ja nicht mein problem, wenn niemand meinen Code versteht und lesen kann.