Post- und Prefix Notation?
-
Ahja Danke!
Ich darf nicht die Schritte zählen sondern muss die Adressen aufaddieren. So einfach war das!
-
So, noch eine Frage:
Jetzt versetze ich mit
*(p++) = *q;
*(p+1) = 's';den Pointer p an den Index 2 respektive Stelle 3 im Array. Aussehen tuts so:
| <- *p ------------------------- | a | s | s | f | g | 0 | ------------------------- 0 1 2 3 4 5 ------------------------- | q | w | e | r | 0 | | ------------------------- 6 7 8 9 10 11Dann möchte ich mit *(p+7) = 'h'; ein h an den Index 8 bzw. Stelle 9 schreiben, oder nochmal anders das 'e' durch ein 'h' ersetzen. p ist ja nun 2.
Wie geht das da jetzt? So wie vorher? Jetzt muss ich 7 mal eine 1 addieren. Jetzt komm ich beim r raus... Man ich werd echt noch bekloppt hier...
-
Mich wundert es nicht.
p++ verändert p!
Wenn du p veränderst dann solltest du dich über das Ergebnis nicht zu wundern. Poste man den gesamten Code, der dein Verhalten reproduziert.
-
bandchef schrieb:
Ahja Danke!
Ich darf nicht die Schritte zählen sondern muss die Adressen aufaddieren. So einfach war das!
Das ist doch das Gleiche. Eine Adresse weiter ist ein Schritt weiter.
Du musst die Schritte zählen und nicht die Positionen.
Dein Bild ist da korrekt.
-
Wenn ich 7 Schritte zähle, dann komm ich beim e raus. Warum aber darf ich dann beim ersten Mal, also da wo p 0,0 steht, nicht die Schritte zählen? Denn da muss ich ja anscheinend das hier machen:
Was gibt: p = p + 0? Natürlich p! welches 'a' ist.
Was gibt: p = p + 1? 's'
Was gibt: p = p + 2? 'd'
Was gibt: p = p + 3? 'f'
Was gibt: p = p + 4? 'g'
Was gibt: p = p + 5? '0'
Was gibt: p = p + 6? 'q'Ich erkenn da halt einfach kein Schema... Am Anfang muss addieren und jetzt soll ich auf einmal wieder die Schritte zählen... Was mir ja einleuchtet weil ich ja sonst nicht an die Position komm. Aber es kann doch nicht sein, dass ich es einmal so und einmal so machen muss...
-
Wenn der Zeiger aber schon auf das 2te Element zeigt und du 7 elemente weiter zeigst bist du bei Element 9! Setz dich jetzt hin und schreibe endlich Code, und stocher nicht in der Gegend rum. Schau es dir an!
-
Es ist ja auch nicht so und mal so.
Bei der Position fängst du bei 1 an zu zählen. Es heißt ja erste Position (oder 1. mit Punkt)
Der Index fängt bei 0 an.Zwischen der 1. und 7. Stelle sind 6 Positionen (7-1) und ob du jetzt 1+6 oder 0+6
rechnest ist egal. Du musst aufpassen das du dann im jeweiligen Kontext bleibst. Position oder Index. Nicht vermischen.| <- p ------------------------------------------------- | a | s | s | f | g | \0| q | w | e | r | 0 | | ------------------------------------------------- 0 1 2 3 4 5 6 7 8 9 10 11 Index 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. Position
-
Gut.
Wenn es nun heißt *(p+7) sind dann da jetzt Position oder Indize gemeint? Wahrscheinlich aber Indize, oder?
Wenn es nun Indize sind, dann muss ich 2 + 7 rechnen und ich komm bei 9 raus, was falsch ist.
-
bandchef schrieb:
Wenn es nun heißt *(p+7) sind dann da jetzt Position oder Indize gemeint? Wahrscheinlich aber Indize, oder?
Richtig, der Index.
bandchef schrieb:
Wenn es nun Indize sind, dann muss ich 2 + 7 rechnen und ich komm bei 9 raus, was falsch ist.
Nichts.
Es sei denn du wolltest zum 'e', das beim Index 8 ist.
8 - 2 ist aber 6 und nicht 7.Oder anders p+2 zeigt auf das 3. Element, du willst zum 9. dann ist 9-3 auch 6.
OK, die 7 ist falsch.
-
#include<stdio.h> int main() { char zk[2][6] = {"asdfg", "qwer"}; char *p, *q; int j = 3; p = &zk[0][0]; q = p + 6; *(p++) = *q; *(p+1) = 's'; zk[0][j] = '\0'; *q = 'g'; *(p+7) = 'h'; printf("%s %s", zk[0], zk[1]); return 0; }Und warum passiert dann hier genau das was ich die ganze Zeit nicht verstehe. Das Programm schreibt mir an den 8. index ein 'h'.
-
#include<stdio.h> int main() { char zk[2][6] = {"asdfg", "qwer"}; char *p, *q; int j = 3; p = &zk[0][0]; // p zeigt auf 'a' q = p + 6; //q zeigt auf 'q' *(p++) = *q; // p zeigt auf 's' string ist {"qsdfg", "qwer"} *(p+1) = 's'; // string ist {"qssfg", "qwer"} zk[0][j] = '\0'; // string ist {"qss0g", "qwer"} *q = 'g'; // string ist {"qss0g", "gwer"} *(p+7) = 'h'; // string ist {"qss0g", "gwhr"} printf("%s %s", zk[0], zk[1]); return 0; }Weil du den Zeiger mit p++ veränderst. Wenn der Pointer auf das zweite Element zeigt und du 7 elemente weiter gehst, dann zeigt er auf das 9te Element und somit wird e durch h ersetzt.
-
p++ verändert den Zeiger, p zeigt danach auf eine andere Stelle
p+1 verändert den Zeiger nicht.
-
Danke HighLigerBiMBam!
Jetzt weiß ich wo ich gestern die ganze Zeit hängen geblieben bin.
Ich habe die ganze Zeit die Codezeile
*(p+1) = 's';falsch interpretiert. Ich hab das so interpretiert, als ob der Pointer p um einen Schritt erhöht wird und an diese neue Stelle das 's' geschrieben wird. Wie diese Stelle aber nun wirklich funktionieren soll, kann ich mir aber leider nicht erklären. Es muss doch, damit ich an das Element mit dem Index 2 rankomme und aus dem 'd' ein 's' werden kann, trotzdem der Pointer p um eins erhöht werden. Und zwar bevor ich das neue char schreiben kann. Laut Vorrangregel kommt ja auch das p+1 zuerst, da Klammern vor diesem Pointer-Sternchen kommen...
Natürlich hat DirkB recht wenn er schreibt, dass
p+1 verändert den Zeiger nicht.
Ich hab auch die Adressen ausgeben lassen und p+1 verändert den Zeiger in der Tat nicht. Wie aber kommt dann trotzdem das weitere 's' an den Index 2, wenn doch der Zeiger eigntlich noch immer auf den Index 1 des Arrays zeigt?
Die zentrale Frage ist also dann: "Was macht *(p+1) bzw. *(p+7)?"
-
Du erhöhst ja den Pointer p mit p + 1 nicht, sondern du sagst nur, dass du auf das Element/Wert der Adresse *(p + 1) zugreifen willst. p bleibt unverändert. Anders ist dies bei dem post/prefix, dieser verändert p in jedem Fall. Natürlich kannst du p mit einer Adition verändert, aber nur mit einer Zuweisung:
p = p + 7
-
Hm, Danke.
Jetzt hab ich's endlich gerafft.
Ich hab jetzt noch ein paar Fragen.
Es gibt ja auch noch das Konstrukt:
*p+1 entspricht (*p)+1
Dieses Konstrukt erhöht mir aber nun die Adresse des Pointers, oder?
-
*p = *p + 1Damit erhöhst du bestenfalls den Wert auf den der Pointer zeigt.
*p = (*p)+1Ist äquivalent zu oben.
char zk[2][6] = {"asdfg", "qwer"}; char *p, *q; int j = 3; p = &zk[0][0]; // p zeigt auf 'a' q = p + 6; //q zeigt auf 'q' *(p++) = *q; // p zeigt auf 's' string ist {"qsdfg", "qwer"} *(p+1) = 's'; // string ist {"qssfg", "qwer"} zk[0][j] = '\0'; // string ist {"qss0g", "qwer"} *q = 'g'; // string ist {"qss0g", "gwer"} *(p+7) = 'h'; // string ist {"qss0g", "gwhr"} //Zusatz *p = *p+1; // string ist {"qts0g", "gwhr"} p = p + 8; // p zeigt auf 'r' *p = (*p)+1; //string ist {"qts0g", "gwhs"}
-
Ich hoffe ich nerv nicht, aber was macht dann das hier:
*&j entspricht doch auch: *(&j)=j
Was kann man nun damit machen? Mit &j hole ich mir doch die Adresse von einer Variable j, oder? Was aber macht dann der * Stern hier? Ist das an dieser Stelle das Dereferenzierungszeichen oder ist das immer noch ein Pointer?
-
Ich würde sagen du dereferenzierst die Adresse von j (welche ja normalerweise ein pointer ist) und greifst mit dem * auf den Wert der Adresse zu.
int a = 5, b; // a = 5 int *p = &a; // p zeigt auf a *(&a) = 7; // die Adresse von a wird dereferenziert ist also a = 7 (*&a)++; // die Adresse von a wird dereferenziert ist also a++ und somit ist a = 8 *&b = 4; printf("%i %i", *p, b); // p zeigt auf a und der Wert davon ist nun 8
-
*(&a) = 7; // die Adresse von a wird dereferenziert ist also a = 7
Ich ersetze hier also die Adresse von a mit dem Wert 7 bzw. einer jeden anderen Variablen? Stimmt das so?
-
Nein, du setzt a = 7 den Wert. *&a ergibt wenig Sinn, da die Operationen sich gegenseitig aufheben, also kannst du diese auch weglassen und nu a schreiben.
&variable //Adresse von variable (Wert->Adresse) *pointer //Dereferenzierung einer Adresse/Pointers (Adresse->Wert) *&variable // Wert -> Adresse -> Wert sinnvoll?