Bin hier her gekommen nachdem ich jegliche Hoffnung auf Verständnis der Pointer bereits aufgeben hatte. Sehr gutes Video und 10000 mal besser erklärt als mein Professor.
Ich habe übrigens gelernt, dass man das Sternchen immer direkt vor dem Zeigernamen setzt. Dem Compiler ist es egal ob Leerzeichen vorhanden sind oder nicht, es dient aber der besseren Lesbarkeit. int* i, j; //Heißt NICHT, dass i UND j Zeiger sind, NUR i in dem Fall ist ein Zeiger. Besser zu lesen ist: int *i, j;
Viel Spaß beim Video! Das ist ein Re-upload, da ich am Ende einen kleinen Fehler hatte. Ich hoffe das hilft euch weiter! Ansonsten checkt die Videobeschreibung aus.
die Erklärung mit der Zeichnung war super. Bin mit diesem Video viel schneller vorangekommen als mit den Erklärungen von meinem prof.... Vielen Dank ^^
du hast die variable temperature im stack. Danach legst du den Pointer tempBytes an, der auf die Adresse der Variable temperatur zeigt. Dieser zeigt also auch auf den Stack (im Unterschied zum Video, wo diese immer auf den Heap gezeigt haben) d.h. temperature und *tempBytes hätten die gleiche ausgabe
Zu deiner Grafik am Ende: Malloc liefert doch einen Zeiger, der in diesem Fall auf einen Integer zeigt (bzw. der Wert, der in der Heap gespeichert werden soll). Wir haben: int *j = (int*)malloc(sizeof(int)) (Zeiger j zeigt auf Zeiger malloc) Der Zeiger j (von Stack ausgehend) zeigt auf den Zeiger malloc (in deiner Darstellung hätte man also den Zeiger von j auf den Titel „Heap setzen müssen). Der Zeiger malloc, zeigt wiederum auf eine freie Speichersysteme im Heap. Also passiert beim Abruf folgendes: int &j = Adresse von j auf dem Stack int j = Adresse von malloc bzw. dem Heap int *j = Inhalt von Malloc bzw. Dem Heap. ---------------- Ist so wie ich das sehe, denn richtig?
Okey die Frage hat sich nun geklärt. Falls jemand sich das gleiche gedacht hat: Malloc liefert einen Zeiger, ja. Allerdings einen Zeiger, der auf den 1. reservierten Platz im Heap zeigt. Es sieht also folgendermaßen aus: *int j= (*int)malloc(2*sizeof(int)) (Die 2 steht für: 2 Plätze für Integer im Heap reserviert). (Zeiger *j zeigt auf den Malloc-Zeiger, der auf den !!1. reservierten Platz im Heap zeigt!!). Die Adresse von j ist eine Adresse vom Stack Die Adresse von malloc ist die Adresse vom 1. reservierten Platz im Heap. Somit: Variable j bekommt die Adresse des 1. reservierten Platzes im Heap zugewiesen Also zur Übersichtlichkeit: &j -> liefert Adresse von j auf dem Stack j -> liefert die Adresse des 1. reservierten Platzes im Heap j* = 2 -> ändert den Wert des 1. reservierten Platzes im Heap. Nochmal der Grund, weshalb dies möglich ist: Der Zeiger j ist der Malloc Zeiger, welchen auf den 1. reservierten Platz im Heap zeigt. j beinhaltet die Adresse von diesem Platz. Mit *j lässt sich also der Wert ändern, der auf diese Adresse gespeichert ist. Jetzt wird‘s spannend: der 2. reservierte Platz im Heap soll einen Wert zugewiesen bekommen. Ganz wichtig: Jeder Platz auf dem Heap hat hat seine eigene Adresse. Jede Adresse hat einen Wert. Es gibt 2 Möglichkeiten, um einen Wert auf den 2. reservierten Platz im Heap zu speichern. 1) *(j+1)= 3 Zeiger j zeigt auf die nächste Adresse im Heap und ändert den Wert in dieser Adresse zu einer 3. Zur Verständlichkeit: j = Zeiger auf den malloc Zeiger, der auf den 1. reservierten Platz zeigt. In Kurz: *j = Zeiger auf den 1. reservierten Platz im Heap.*j -> Zugriff auf diesen Platz. *(j+1)= Zeiger auf den 2: reservierten Platz im Heap *(j+1) -> Zugriff auf diesen Platz. 2) j[1] = 3 Zur Veranschaulichung: Für j[0] = 2 gilt: j ist die Adresse des 1. reservierten Platzes im Heap. Index 0 -> 1. Platz. Ändert den Wert des Platzes zu einer 2. Man kann in diesem Fall der Darstellung also sagen: j ist der Name des Heaps. Bzw. Eine Variable für den ganzen Speicherbereich im Heap, welche durch freigegeben wurde.
Ich hing seit ein paar Tagen an einer Hausaufgabe fest. Ein UA-cam Video und schon bin ich fertig mit der Aufgabe... Und da sagen mir Leute, UA-cam wäre Zeitverschwendung!!!!
Bin hier her gekommen nachdem ich jegliche Hoffnung auf Verständnis der Pointer bereits aufgeben hatte. Sehr gutes Video und 10000 mal besser erklärt als mein Professor.
Ich habe übrigens gelernt, dass man das Sternchen immer direkt vor dem Zeigernamen setzt. Dem Compiler ist es egal ob Leerzeichen vorhanden sind oder nicht, es dient aber der besseren Lesbarkeit.
int* i, j; //Heißt NICHT, dass i UND j Zeiger sind, NUR i in dem Fall ist ein Zeiger.
Besser zu lesen ist:
int *i, j;
Super Video, vor allem dann noch mal die Erklärung mit der Zeichnung. Vielen Dank!
Viel Spaß beim Video!
Das ist ein Re-upload, da ich am Ende einen kleinen Fehler hatte.
Ich hoffe das hilft euch weiter!
Ansonsten checkt die Videobeschreibung aus.
die Erklärung mit der Zeichnung war super. Bin mit diesem Video viel schneller vorangekommen als mit den Erklärungen von meinem prof.... Vielen Dank ^^
Danke für diese into-tiefe Erklärung
Das war ein echt hilfreiches Video. Vielen Dank! =)
Super Video, genau das was ich gebraucht hab
Das war sehr hilfreich!
Aber wofür braucht man das genau? Hast du vlt. Anwendungsbeispiele?
Klasse Video, danke!
Gut erklärt aber fand es schade, dass du viele unbekannte Sachen rausgehauen hast ohne die zu erklären musste halt googeln xD
Im Prinzip gut erklärt. Trotzdem verstehe ich nicht, was der Vorteil von Pointern gegenüber Variablen ist.
Sehr geiles Video :) vielen Dank
sehr gut erklärt
Schön erklärt
Sehr gut erklärt.
Danke sehr
Ich habe das gerade im Dunkeln geguckt. Bruder der Cut auf das weiße Blatt hat mich so geflashbangt. Nächstes mal kleine Warnung
wooow perfekt sehr gute Erklärung vielen dank
was ist der unterschied zwischen Stack und Heap? xD
Gute Frage was ist Stack und was ist Heap-....
Hey, nochmal eine frage:
Wofür steht das (int*) in "j = (int*) malloc(sizeof(int));"
Casting (danach kannst du googeln)
Danke
Geiles VIdeo! Grüße an die FMIs aus Wob
Wie genau habe ich so ein Code zu verstehen:
float temperature = 15.09f;
byte *tempBytes = (byte *)&temperature;
du hast die variable temperature im stack. Danach legst du den Pointer tempBytes an, der auf die Adresse der Variable temperatur zeigt. Dieser zeigt also auch auf den Stack (im Unterschied zum Video, wo diese immer auf den Heap gezeigt haben)
d.h. temperature und *tempBytes hätten die gleiche ausgabe
Zu deiner Grafik am Ende: Malloc liefert doch einen Zeiger, der in diesem Fall auf einen Integer zeigt (bzw. der Wert, der in der Heap gespeichert werden soll). Wir haben:
int *j = (int*)malloc(sizeof(int))
(Zeiger j zeigt auf Zeiger malloc)
Der Zeiger j (von Stack ausgehend) zeigt auf den Zeiger malloc (in deiner Darstellung hätte man also den Zeiger von j auf den Titel „Heap setzen müssen).
Der Zeiger malloc, zeigt wiederum auf eine freie Speichersysteme im Heap.
Also passiert beim Abruf folgendes:
int &j = Adresse von j auf dem Stack
int j = Adresse von malloc bzw. dem Heap
int *j = Inhalt von Malloc bzw. Dem Heap.
----------------
Ist so wie ich das sehe, denn richtig?
Okey die Frage hat sich nun geklärt. Falls jemand sich das gleiche gedacht hat:
Malloc liefert einen Zeiger, ja. Allerdings einen Zeiger, der auf den 1. reservierten Platz im Heap zeigt.
Es sieht also folgendermaßen aus:
*int j= (*int)malloc(2*sizeof(int))
(Die 2 steht für: 2 Plätze für Integer im Heap reserviert).
(Zeiger *j zeigt auf den Malloc-Zeiger, der auf den !!1. reservierten Platz im Heap zeigt!!).
Die Adresse von j ist eine Adresse vom Stack
Die Adresse von malloc ist die Adresse vom 1. reservierten Platz im Heap.
Somit: Variable j bekommt die Adresse des 1. reservierten Platzes im Heap zugewiesen
Also zur Übersichtlichkeit:
&j -> liefert Adresse von j auf dem Stack
j -> liefert die Adresse des 1. reservierten Platzes im Heap
j* = 2 -> ändert den Wert des 1. reservierten Platzes im Heap.
Nochmal der Grund, weshalb dies möglich ist: Der Zeiger j ist der Malloc Zeiger, welchen auf den 1. reservierten Platz im Heap zeigt. j beinhaltet die Adresse von diesem Platz. Mit *j lässt sich also der Wert ändern, der auf diese Adresse gespeichert ist.
Jetzt wird‘s spannend: der 2. reservierte Platz im Heap soll einen Wert zugewiesen bekommen. Ganz wichtig: Jeder Platz auf dem Heap hat hat seine eigene Adresse.
Jede Adresse hat einen Wert.
Es gibt 2 Möglichkeiten, um einen Wert auf den 2. reservierten Platz im Heap zu speichern.
1) *(j+1)= 3
Zeiger j zeigt auf die nächste Adresse im Heap und ändert den Wert in dieser Adresse zu einer 3. Zur Verständlichkeit:
j = Zeiger auf den malloc Zeiger, der auf den 1. reservierten Platz zeigt. In Kurz: *j = Zeiger auf den 1. reservierten Platz im Heap.*j -> Zugriff auf diesen Platz. *(j+1)= Zeiger auf den 2: reservierten Platz im Heap *(j+1) -> Zugriff auf diesen Platz.
2) j[1] = 3
Zur Veranschaulichung:
Für j[0] = 2 gilt:
j ist die Adresse des 1. reservierten Platzes im Heap. Index 0 -> 1. Platz. Ändert den Wert des Platzes zu einer 2.
Man kann in diesem Fall der Darstellung also sagen: j ist der Name des Heaps. Bzw. Eine Variable für den ganzen Speicherbereich im Heap, welche durch freigegeben wurde.
Ich liebe dich ❤
danke sehr gutes Video like und abo hast du von mir
Wow
Ich hing seit ein paar Tagen an einer Hausaufgabe fest. Ein UA-cam Video und schon bin ich fertig mit der Aufgabe...
Und da sagen mir Leute, UA-cam wäre Zeitverschwendung!!!!