pointer zwischenspeicher

Slade100 · 11/09/2014, 21:16

also ich habe einen pointer der auf eine value zeigt(coordinate), jetzt will ein zwischenspeicher haben, welcher die value von dem moment wo ich sie abspeicher bei behält.
z.b coordinate ist 2000, dann zwischenspeicher ich es auf x, laufe ein stück dann ist x 2000 und coordinate hat sich geändert auf was auch immer, egal was ich probiert habe entweder ist mein game gecrasht oder x(als ich x auch als dword deklariert habe) hatte ständig den geänderten wert auch

Tasiro · 11/09/2014, 21:59

Das ist zu schade. Ich hoffe, du findest eine Lösung für dein Problem.

Oh, und bevor ich es vergesse: Du solltest eine Frage stellen, deinen Weg und dein Ziel beschreiben und dich nicht auf die Kristallkugeln anderer verlassen ("War und bleibt das X?").

Slade100 · 11/09/2014, 22:54

Quote:

Originally Posted by Tasiro

Das ist zu schade. Ich hoffe, du findest eine Lösung für dein Problem.

Oh, und bevor ich es vergesse: Du solltest eine Frage stellen, deinen Weg und dein Ziel beschreiben und dich nicht auf die Kristallkugeln anderer verlassen ("War und bleibt das X?").

danke für den hinweis, aber die frage könnte man sich doch denken^^

also wie kriege ich einen zwischenspeicher für den value( auf welches ein pointer zeigt )hin?

warfley · 11/09/2014, 23:55

wenn ich das richtig verstanden habe versuchs mal mit
dein Pointer:

Code:

int * Zeiger;

deine absicherung

Code:

int * Zeiger2;
Zeiger2 = Zeiger;

deine veränderung von zeiger

Code:

for (int i=0; i<2103; i++) {
  Zeiger* = i;
  Zeiger++;
}

Und Zeiger wieder auf den startwert setzten:

Code:

Zeiger = Zeiger2;

und tada du hast einen pointer mit 2103 werten und er zeigt am ende wirder auf den start punkt

Option 2:

Code:

Zeiger = Zeiger - (Steps * SizeofInt);

müsste auch funktionieren, musst halt die steps zählen

ƬheGame · 11/10/2014, 06:55

Quote:
Originally Posted by warfley
wenn ich das richtig verstanden habe versuchs mal mit
dein Pointer:
Code:
int * Zeiger;
deine absicherung
Code:
int * Zeiger2;
Zeiger2 = Zeiger;
deine veränderung von zeiger
Code:
for (int i=0; i<2103; i++) {
  Zeiger* = i;
  Zeiger++;
}
Und Zeiger wieder auf den startwert setzten:
Code:
Zeiger = Zeiger2;
und tada du hast einen pointer mit 2103 werten und er zeigt am ende wirder auf den start punkt

Option 2:
Code:
Zeiger = Zeiger - (Steps * SizeofInt);
müsste auch funktionieren, musst halt die steps zählen

Ihr habt das mit den Pointern noch nicht so ganz begriffen ne ^^
Wenn du einen Zeiger hast der auf einen Int zeigt der als wert 32 hat und du nun einen Zeiger erstellst der auf den genannten Zeiger zeigt. Dann zeigen am Ende beide Zeiger auf den int mit dem Wert 32. Ein Zeiger zeigt immer auf eine Adresse im RAM sobald sich der Wert darin ändert, ändert sich auch der Wert des Zeigers. In deinem Beispiel hat Zeiger2 IMMER den gleichen wert wie Zeiger

Nebst dem müsste dein Pointer Zahl2 so aussehen "int **Zeiger2;" weil es ein Pointer auf einen Pointer ist.

Code:

int x = 1;
int xCache = x;
int *ptrToX = &x;

for(x = 0; x <= 100; x++){
    foo(xCache); // x hat den alten wert
    bar(ptrToX); // x mit dem neuen wert
    xCache = *ptrToX; // den wert von x cachen
}

Hab euch etwas gezeichnet:

MrSm!th · 11/10/2014, 10:37

Quote:
Originally Posted by ƬheGame
Ihr habt das mit den Pointern noch nicht so ganz begriffen ne ^^
Wenn du einen Zeiger hast der auf einen Int zeigt der als wert 32 hat und du nun einen Zeiger erstellst der auf den genannten Zeiger zeigt. Dann zeigen am Ende beide Zeiger auf den int mit dem Wert 32. Ein Zeiger zeigt immer auf eine Adresse im RAM sobald sich der Wert darin ändert, ändert sich auch der Wert des Zeigers. In deinem Beispiel hat Zeiger2 IMMER den gleichen wert wie Zeiger Nebst dem müsste dein Pointer Zahl2 so aussehen "int **Zeiger2;" weil es ein Pointer auf einen Pointer ist.
Code:
int x = 1;
int xCache = x;
int *ptrToX = &x;

for(x = 0; x <= 100; x++){
    foo(xCache); // x hat den alten wert
    bar(ptrToX); // x mit dem neuen wert
    xCache = *ptrToX; // den wert von x cachen
}
Hab euch etwas gezeichnet:

Um mal Korinthen zu kacken:
Nein, der erste Zeiger zeigt auf den int, der zweite zeigt auf den ersten Zeiger.
Ebenfalls ändert sich nicht der Wert des Zeigers (der bleibt nämlich immer die Adresse), wenn sich der int ändert.

warfley · 11/10/2014, 12:16

Quote:

Ihr habt das mit den Pointern noch nicht so ganz begriffen ne ^^
Wenn du einen Zeiger hast der auf einen Int zeigt der als wert 32 hat und du nun einen Zeiger erstellst der auf den genannten Zeiger zeigt. Dann zeigen am Ende beide Zeiger auf den int mit dem Wert 32. Ein Zeiger zeigt immer auf eine Adresse im RAM sobald sich der Wert darin ändert, ändert sich auch der Wert des Zeigers. In deinem Beispiel hat Zeiger2 IMMER den gleichen wert wie Zeiger Nebst dem müsste dein Pointer Zahl2 so aussehen "int **Zeiger2;" weil es ein Pointer auf einen Pointer ist.

Ich glaube du hast da nicht was ganz richtig verstanden, oder ich habe mich mit der Syntax geirrt, aber

Code:

int * Zeiger2;
Zeiger2=Zeiger

ist nicht

Code:

int * Zeiger2;
Zeiger2*=Zeiger

Ich sage nicht Zeiger 2 ist ein pointer der auf einen pointer zeigt, ich sage Zeiger 2 ist ein pointer der auf das selbe Element wie Zeiger zeigr
erhöhe ich nun den stack Wert von Zeiger interessiert das den Zeiger 2 ja nicht im geringsten, da der ja schön weiter auf das erste Element zeigt, und noch den alten stack Wert von Zeiger enthält. Ich hätte auch einen integer nehmen können um das zwischenzuspeichern, aber ich wweiss nich mehr welcher integer Typ in C die Größe eines pointers hat sich

Slade100 · 11/10/2014, 14:48

Quote:
Originally Posted by ƬheGame
Ihr habt das mit den Pointern noch nicht so ganz begriffen ne ^^
Wenn du einen Zeiger hast der auf einen Int zeigt der als wert 32 hat und du nun einen Zeiger erstellst der auf den genannten Zeiger zeigt. Dann zeigen am Ende beide Zeiger auf den int mit dem Wert 32. Ein Zeiger zeigt immer auf eine Adresse im RAM sobald sich der Wert darin ändert, ändert sich auch der Wert des Zeigers. In deinem Beispiel hat Zeiger2 IMMER den gleichen wert wie Zeiger Nebst dem müsste dein Pointer Zahl2 so aussehen "int **Zeiger2;" weil es ein Pointer auf einen Pointer ist.
Code:
int x = 1;
int xCache = x;
int *ptrToX = &x;

for(x = 0; x <= 100; x++){
    foo(xCache); // x hat den alten wert
    bar(ptrToX); // x mit dem neuen wert
    xCache = *ptrToX; // den wert von x cachen
}
Hab euch etwas gezeichnet:

danke für die erklärung, das mit den pointern bringe ich immer wenig durcheinander, aber deine erklärung hats ziemlich verständlich gemacht, dafür danke ich dir schonmal sehr

, nur noch was
1. was macht foo und bar?
2. ich hab mich wahrscheinlich schlecht ausgedrückt, das problem von mir ist ja das bei mir die variabel wo der pointer drauf zeigt nicht existiert, also sie existiert schon aber nicht in meiner source, wie gesagt diese ist ingame meine coordinate

ich glaub ich kanns am besten durch meine source als beispiel zeigen, damit ihr wisst was gemeint ist
also ich habe mit pattern gearbeitet

DWORD xJmpBack = 0; //jmp damit, nach meinem bearbeiteten punkt normal weiter gemacht wird
DWORD xRegister = 0x0; // hier wird die adresse von EAX gespeichert(siehe unten)
DWORD xPtr; // hier wird im nächsten teil hpregister+ offset drauf gespeichert

in meinem header ist der teil:
_declspec(naked) void xChange()
{
__asm
{
CMP [EAX+0x46AC],0h
MOV xRegister, EAX
jmp [xJmpBack]
}

}
in meiner source.cpp ist das hier:
xPtr = xRegister + 0x46AC;

klappt auch wunderbar alles, hab somit die x coordinate ingame, nun aber zum problem
unzwar will ich, sobald ich mein programm starte, die x coordinate zum start punkt gespeichert werden. damit ich das eine bedingung habe wie: if(*(int*)xPtr != xstart) ....;
oder gibts vllt eine bedinung wie , if (wenn *(int*)xPtr sich ändert), das würde das ganze auch extrem leicht machen aber so eine bedingung ist mir nicht bekannt

warfley · 11/10/2014, 15:29

foo und bar stehen als Platzhalter für irgendwelche Methoden/Zuweisungen, und sollen andeuten, an dieser stelle machst du irgendetwas, ziemlich egal was.

Dr. Coxxy · 11/10/2014, 15:36

Quote:

Originally Posted by ƬheGame

... jede menge unverständlicher mist ...

wenn du es nicht richtig weißt, oder nicht in der lage bist korrekt zu erklären solltest du es bitte auch nicht versuchen, das stiftet nur verwirrung.

Fehler:
1.

Quote:

Wenn du einen Zeiger hast der auf einen Int zeigt der als wert 32 hat und du nun einen Zeiger erstellst der auf den genannten Zeiger zeigt. Dann zeigen am Ende beide Zeiger auf den int mit dem Wert 32.

falsch.

Code:

int x = 32;
int* ptr1 = &x;
int** ptr2 = &ptr1;

ptr1 zeigt auf x, ptr2 zeigt auf ptr1 und nicht auf einen int mit dem wert 32.

2.

Quote:

Ein Zeiger zeigt immer auf eine Adresse im RAM sobald sich der Wert darin ändert, ändert sich auch der Wert des Zeigers.

falsch.
der Wert eines zeigers ist die adresse die er beinhaltet, nicht der inhalt der speicheradresse auf die er zeigt.
also ändert sich der wert von ptr1 nicht wenn x geändert wird, der von ptr2 sowieso nicht.

3.

Quote:

In deinem Beispiel hat Zeiger2 IMMER den gleichen wert wie Zeiger

falsch.
ptr2 hat den wert &ptr1, ptr1 hat den wert &x.

du scheinst da etwas mit den begrifflichkeiten durcheinander zu kommen, der wert eines zeigers ist die adresse, nicht der inhalt der adresse.

Slade100 · 11/10/2014, 16:17

Quote:
Originally Posted by Dr. Coxxy
wenn du es nicht richtig weißt, oder nicht in der lage bist korrekt zu erklären solltest du es bitte auch nicht versuchen, das stiftet nur verwirrung.

Fehler:
1.

falsch.
Code:
int x = 32;
int* ptr1 = &x;
int** ptr2 = &ptr1;
ptr1 zeigt auf x, ptr2 zeigt auf ptr1 und nicht auf einen int mit dem wert 32.

2.

falsch.
der Wert eines zeigers ist die adresse die er beinhaltet, nicht der inhalt der speicheradresse auf die er zeigt.
also ändert sich der wert von ptr1 nicht wenn x geändert wird, der von ptr2 sowieso nicht.

3.

falsch.
ptr2 hat den wert &ptr1, ptr1 hat den wert &x.

du scheinst da etwas mit den begrifflichkeiten durcheinander zu kommen, der wert eines zeigers ist die adresse, nicht der inhalt der adresse.

und deswegen ist das thema so verwirrend, einer erklärt wie das funzt, dann kommt ein zweiter verbessert den 1., dann ein 3. derr nochmal den 2. verbessert, ich bin auf den 4. gespannt^^ ne spaß danke für die erklärung habs mittlerweile gecheckt aber wie ich den zwischenspeicher hinkriege weiß ich immernoch nich

ƬheGame · 11/11/2014, 08:43

Quote:
Originally Posted by Dr. Coxxy
wenn du es nicht richtig weißt, oder nicht in der lage bist korrekt zu erklären solltest du es bitte auch nicht versuchen, das stiftet nur verwirrung.

Fehler:
1.

falsch.
Code:
int x = 32;
int* ptr1 = &x;
int** ptr2 = &ptr1;
ptr1 zeigt auf x, ptr2 zeigt auf ptr1 und nicht auf einen int mit dem wert 32.

2.

falsch.
der Wert eines zeigers ist die adresse die er beinhaltet, nicht der inhalt der speicheradresse auf die er zeigt.
also ändert sich der wert von ptr1 nicht wenn x geändert wird, der von ptr2 sowieso nicht.

3.

falsch.
ptr2 hat den wert &ptr1, ptr1 hat den wert &x.

du scheinst da etwas mit den begrifflichkeiten durcheinander zu kommen, der wert eines zeigers ist die adresse, nicht der inhalt der adresse.

Logischerweise beinhalten beide Pointer eine adresse. Aber das ist im Ende scheiss egal weil es darum geht was dabei rauskommt wenn man den Pointer dereferenziert und das ist nunmal der Int. Ich habe absichtlich nicht von Adressen gesprochen sonst blickt jemand der es nicht kann garnicht durch. Nebst dem steht da auch immer Zeigt auf x/y und nicht zeigt auf int. Schau dir mal das bild an, da steht auch ptr2 zeigt auf ptr1 der auf den int zeigt. Am Ende kann man meine Version so implementieren und es funktioniert im Gegensatz zu allem anderen was hier vor mir geschrieben wurde.

Ich sage nicht Zeiger 2 ist ein pointer der auf einen pointer zeigt, ich sage Zeiger 2 ist ein pointer der auf das selbe Element wie Zeiger zeigr
erhöhe ich nun den stack Wert von Zeiger interessiert das den Zeiger 2 ja nicht im geringsten, da der ja schön weiter auf das erste Element zeigt, und noch den alten stack Wert von Zeiger enthält. Ich hätte auch einen integer nehmen können um das zwischenzuspeichern, aber ich wweiss nich mehr welcher integer Typ in C die Größe eines pointers hat sich[/QUOTE]

[quote=warfley;30141765]Ich glaube du hast da nicht was ganz richtig verstanden, oder ich habe mich mit der Syntax geirrt, aber

Code:

int * Zeiger2;
Zeiger2=Zeiger

ist nicht

Code:

int * Zeiger2;
Zeiger2*=Zeiger

Quote:

for (int i=0; i<2103; i++) {
Zeiger* = i;
Zeiger++;
}

Also zeigst du einfach random auf irgendwelche Ram-stellen von denen du keine Ahnung hast was darin steht und schreibst da einfach etwas rein? Wenn du deinen Weg machen willst solltest du vielleicht erst den ganzen Speicherplatz allozieren den du da beschreiben willst und nicht random irgendwo ins ram schreiben. Das Programm wird wahrscheinlich dadurch höchstens abstürzen oder es geschehen andere Lustige dinge. Da kannst du auch gleich ne random funktion aufrufen und den wert dem Pointer zuweisen und danach frisch fröhlich dinge reinschreiben.

sowas wie:

Code:

ptr = (int*)malloc(sizeof(int)*2103);

wäre warscheinlich noch wichtig.
Auch da sollte man aber alles noch mit 0 inizialisieren, oder calloc verwenden
sofern man nicht zu 100% alle Stellen neu beschreibt.

Zu windows 95 zeiten hat ein Pointer an die falsche stelle noch den PC abstürzen lassen. Da konntest du das komplette Ram mit 0 befüllen da hat der Rechner nicht geschaut das du nicht außerhalb deines Speichers schreibst.

Dr. Coxxy · 11/11/2014, 10:58

Quote:

Originally Posted by ƬheGame

Logischerweise beinhalten beide Pointer eine adresse. Aber das ist im Ende scheiss egal weil es darum geht was dabei rauskommt wenn man den Pointer dereferenziert und das ist nunmal der Int. Ich habe absichtlich nicht von Adressen gesprochen sonst blickt jemand der es nicht kann garnicht durch. Nebst dem steht da auch immer Zeigt auf x/y und nicht zeigt auf int. Schau dir mal das bild an, da steht auch ptr2 zeigt auf ptr1 der auf den int zeigt.

Es geht aber um die begrifflichkeiten, der wert eines pointers ist nunmal eine adresse und nicht der wert der variable auf die er zeigt, das ist ein fest definierter begriff den man nicht einfach anders benutzen darf.

Quote:

Ich sage nicht Zeiger 2 ist ein pointer der auf einen pointer zeigt, ich sage Zeiger 2 ist ein pointer der auf das selbe Element wie Zeiger zeigr
erhöhe ich nun den stack Wert von Zeiger interessiert das den Zeiger 2 ja nicht im geringsten, da der ja schön weiter auf das erste Element zeigt, und noch den alten stack Wert von Zeiger enthält. Ich hätte auch einen integer nehmen können um das zwischenzuspeichern, aber ich weiss nich mehr welcher integer Typ in C die Größe eines pointers hat

was?
ptr2 zeigt aber auf ptr1 und nicht auf x, das auf x zeigen geschieht nur indirekt, wenn du ptr1 änderst zeigt ptr2 auch nicht mehr indirekt auf x.

Code:

int x = 10;
int y = 42;
int* ptr1 = &x;
int** ptr2 = &ptr1;
//**ptr2 == *ptr1 == x == 10
ptr1 = &y;
// **ptr2  == *ptr1 == y == 42

uintptr_t.

warfley · 11/11/2014, 13:08

Quote:

Also zeigst du einfach random auf irgendwelche Ram-stellen von denen du keine Ahnung hast was darin steht und schreibst da einfach etwas rein? Wenn du deinen Weg machen willst solltest du vielleicht erst den ganzen Speicherplatz allozieren den du da beschreiben willst und nicht random irgendwo ins ram schreiben. Das Programm wird wahrscheinlich dadurch höchstens abstürzen oder es geschehen andere Lustige dinge. Da kannst du auch gleich ne random funktion aufrufen und den wert dem Pointer zuweisen und danach frisch fröhlich dinge reinschreiben.

Das Speicher reservieren habe ich bewusst weggelassen, da ich die Methode in c nicht kenne um das zu machen, und das ist ja auch egal, da ich davon ausgehe das der TE schon seine Methode hat um den pointer zu verändern, und nurnwissen wollte wie er den anfangspointer wieder bekommt, und da habe ich einfach gezeigt, nimm einen Zeiger 2 weiße ihm den selben Keller Wert zu wie Zeiger 1, und dann kann man Zeiger 1 einfach verändern wie man will, da man noch einen 2ten pointer hat der immer auf das erste Symbol zeigt

ƬheGame · 11/11/2014, 15:18

Quote:

Originally Posted by warfley

Das Speicher reservieren habe ich bewusst weggelassen, da ich die Methode in c nicht kenne um das zu machen, und das ist ja auch egal, da ich davon ausgehe das der TE schon seine Methode hat um den pointer zu verändern, und nurnwissen wollte wie er den anfangspointer wieder bekommt, und da habe ich einfach gezeigt, nimm einen Zeiger 2 weiße ihm den selben Keller Wert zu wie Zeiger 1, und dann kann man Zeiger 1 einfach verändern wie man will, da man noch einen 2ten pointer hat der immer auf das erste Symbol zeigt

Wenn der OP nicht weiss wie man den wert cacht, wird er wohl kaum wissen wie man genug speicher alloziert damit man den Pointer inkrementieren kann ohne irgendwo in's Nirvana zu zeigen.

Code:

int x = 10;
int y = 42;
int* ptr1 = &x;
int** ptr2 = &ptr1;
//**ptr2 == *ptr1 == x == 10
ptr1 = &y;
// **ptr2  == *ptr1 == y == 42

Das versuche ich hier ja schon die ganze Zeit zu erklären. Nebst dem Kommt der von dir Zitierte Text nicht von mir epvp hat nur das Zitat verbugt.