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;
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 ^^
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.
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 TH-cam Video und schon bin ich fertig mit der Aufgabe... Und da sagen mir Leute, TH-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;
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 ^^
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.
Super Video, vor allem dann noch mal die Erklärung mit der Zeichnung. Vielen Dank!
Das war ein echt hilfreiches Video. Vielen Dank! =)
Ich habe das gerade im Dunkeln geguckt. Bruder der Cut auf das weiße Blatt hat mich so geflashbangt. Nächstes mal kleine Warnung
Danke für diese into-tiefe Erklärung
Super Video, genau das was ich gebraucht hab
Sehr geiles Video :) vielen Dank
Im Prinzip gut erklärt. Trotzdem verstehe ich nicht, was der Vorteil von Pointern gegenüber Variablen ist.
Klasse Video, danke!
Das war sehr hilfreich!
Aber wofür braucht man das genau? Hast du vlt. Anwendungsbeispiele?
Hey, nochmal eine frage:
Wofür steht das (int*) in "j = (int*) malloc(sizeof(int));"
Casting (danach kannst du googeln)
Gut erklärt aber fand es schade, dass du viele unbekannte Sachen rausgehauen hast ohne die zu erklären musste halt googeln xD
was ist der unterschied zwischen Stack und Heap? xD
Gute Frage was ist Stack und was ist Heap-....
Geiles VIdeo! Grüße an die FMIs aus Wob
Sehr gut erklärt.
Danke sehr
Schön erklärt
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
sehr gut erklärt
wooow perfekt sehr gute Erklärung vielen dank
Ich liebe dich ❤
Danke
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.
danke sehr gutes Video like und abo hast du von mir
Ich hing seit ein paar Tagen an einer Hausaufgabe fest. Ein TH-cam Video und schon bin ich fertig mit der Aufgabe...
Und da sagen mir Leute, TH-cam wäre Zeitverschwendung!!!!
Wow