Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Werbeanzeige

dev_null

Frischling

  • »dev_null« ist der Autor dieses Themas

Beiträge: 38

Wohnort: Augsburg

Beruf: Application Developer

  • Private Nachricht senden

1

29.06.2007, 16:13

Zeiger verständniss

Hallo, ich komme in Kapitel 8 einfach nicht weiter, was daran liegt, dass ich das mit den Zeigern einfach nicht raffe, finde das total unlogisch, vieleicht kann mich ja jemand erleuchten :)

ein Zeiger Speichert die Adresse einer Variable.... Soweit klar ABER

*pPunkte <-- Das ist ein Zeiger
pPunkte = &Punkte <--- Warum wird die Adresse in pPunkte und nicht in *pPunkte gespeichert? Es wird klar beschrieben, das in einem Zeiger die Adresse gespeichert wird und ein Zeiger beginnt mit einem * Aber in dem folgedem Beispiel wird die Adresse nicht in dem "Teil mit * gespeichert"

C-/C++-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <iostream>

using namespace std;

// Hauptprogramm

//

int main ()
{
    // Variablen

    //

    int Punkte = 500;
    float fGeschwindigkeit = 20.5f;

    int *pPunkte = NULL;                // Zeiger auf Punkte

    float *pfGeschwindigkeit = NULL;        // Zeiger auf Geschwindigkeit


    // Zeiger initialisieren

    pPunkte = &Punkte;
    pfGeschwindigkeit = &fGeschwindigkeit;

    // Adresse von Punkte ausgeben

    cout << "Die Adresse der Variable \"Punkte\" ";
    cout << " lautet: " << pPunkte << endl;

    // Adresse fGeschwindigkeit ausgeben

    cout << "Die Adresse der Variable \"fGeschwindigkeit\" ";
    cout << " lautet: " << pfGeschwindigkeit << endl;

    return 0;
}


Komme da einfach nicht mit.

Was ist *pPunkte und was ist pPunkte? (* = Zeiger) Warum heißt es dann nicht
*pPunkte = &Punkte; ?

Was hat denn *pPunkte für einen Sinn für mich steht da nur NULL drine mehr nicht :( Ein definierter typ der keine verwendung hat... :(

so long

dev_null
Think free!

David Scherfgen

Administrator

Beiträge: 10 382

Wohnort: Hildesheim

Beruf: Wissenschaftlicher Mitarbeiter

  • Private Nachricht senden

2

29.06.2007, 16:24

Da hast du was falsch verstanden.

pPointer ist der Zeiger selbst.
*pPointer ist das, worauf der Zeiger zeigt.

Also:

pPointer = &Variable;

pPointer zeigt jetzt auf die Variable, speichert also ihre Adresse.
Wenn ich jetzt die Variable über den Zeiger ändern will:

*pPointer = 42;

drakon

Supermoderator

Beiträge: 6 513

Wohnort: Schweiz

Beruf: Entrepreneur

  • Private Nachricht senden

3

29.06.2007, 16:30

*pPunkte ist ein Zeiger auf eine Variabel (z.B einen Integer - Wert).

pPunkte enthält dann die Adresse, auf die der Zeiger verweisst.

Beispiel:

C-/C++-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int Zahl;  //irgendeine Zahl


int* pZahl; // ein Zeiger auf einen Integer Wert

   
    //Nun haben wir eine Zahl und einen Zeiger auf eine Zahl.

    //Der Zeiger pZahl verweist aber noch nicht auf die Variabel Zahl!!! Sondern irgendwohin!!

   //Mit dem & - Operator kannst du die Adresse einer Variabel ausgeben.

   //Somit können wir einen Zeiger auf Zahl durch pZahl erzeugen.


pZahl = &Zahl; // Der Zeiger auf eine Variabel wird mit der Adresse von Zahl gefüllt.


//*pZahl (also der Zeiger) verweisst auf Zahl, kann also direkt angesprochen werden.


*pZahl = 10; //Wir könne hier mit *pZahl direkt auf Zahl zugreifen und den Wert, wie wir es kennen verändern.


Wichtig ist also zu verstehen, dass:
*pZahl der Zeiger auf die Variabel ist und:
pZahl lediglich einen Hexadezimalen Wert enhält, welcher der Adresse entspricht, auf welches der Zeiger zeigt.

EDIT:
Zu spät.
Bei mir nochmal dasselbe, wie bei David

David Scherfgen

Administrator

Beiträge: 10 382

Wohnort: Hildesheim

Beruf: Wissenschaftlicher Mitarbeiter

  • Private Nachricht senden

4

29.06.2007, 16:50

Zitat von »"drakon"«

*pPunkte ist ein Zeiger auf eine Variabel (z.B einen Integer - Wert).

Nein, *pPunkte ist das, worauf der Zeiger zeigt.

Zitat von »"drakon"«

Wichtig ist also zu verstehen, dass:
*pZahl der Zeiger auf die Variabel ist und:

s.o.

Zitat von »"drakon"«

pZahl lediglich einen Hexadezimalen Wert enhält, welcher der Adresse entspricht, auf welches der Zeiger zeigt.

Hexadezimal?! Wie kommst du darauf? Der Zeiger ist einfach nur ein (32-Bit-)Wert und wird wie alle Zahlen im Computer binär gespeichert, also mit Einsen und Nullen.

dev_null

Frischling

  • »dev_null« ist der Autor dieses Themas

Beiträge: 38

Wohnort: Augsburg

Beruf: Application Developer

  • Private Nachricht senden

5

29.06.2007, 16:54

Ok nun bin ich erstmal einen Schritt weiter, nur noch einen Hakren,

pZeiger // Zeiger der die Adresse enthält
*pZeiger // Zeiger auf eine Variable

Was ist nun der Zeiger? Ich weiß nicht so richtig wie ich es erklären soll was ich nicht kapiere.

Beispiel ich zeige euch einen Aschenbecher und sage das ist ein Aschenbecher, dann zeige ich euch einen Teller und sage das ist ein Aschenbecher, was ist dann der Aschenbecher?

C-/C++-Quelltext

1
2
3
4
5
int Zahl = 5; // eine Variable vom Typ int (logisch)


int *pZahl = NULL; // Hier definiere ich einen Zeiger (ist das DER Zeiger?)


pZahl = &Zahl; // Hier speichere ich die Adresse in den Zeiger ab (??? ich denke *pZahl ist der Zeiger)


So steht es im Buch:
==============
An dem Sternchen (*) erkennt man, dass es sich nicht um „normale“ Variablen handelt, sondern eben um Zeiger, in denen man eine Adresse speichern kann.

Da sage ich mir ABER ich speichere die Adresse nicht in *pZahl sonder in pZahl, wenn ich das mit cout ausgebe liefert mir pZahl die Adresse und *pZahl den Wert. Aber ich verstehe es nicht. Irgendwo hackt es bei mir.

Wir haben 3 Sachen: eine Adresse, eine Variable, eine Wert

C-/C++-Quelltext

1
int Zahl = 5; 


Somit hat die Variable Zahl den Wert 5. So nun hat die Variable auch eine Adresse, soweit auch klar, ODER hat der Wert die Adresse?

Ein Zeiger Speichert die Adresse, soweit klar

Eine Adresse zeigt auf den Wert einer Variable oder auf die Variable?

Ich glaube das Problem was ich habe ist, ich kann keinen bezug von *pZeiger zu pZeiger herstellen.

Schließlich ist in meinen anderen Post *pZeiger = NULL;

Habe es auch schon probiert mal 1 Nacht über Problem zu schlafen, ging nicht konnte nicht einschlafen das blockiert komplett mein Hirn :)

Zitat von »"David Scherfgen"«


Nein, *pPunkte ist das, worauf der Zeiger zeigt.


Das habe ich etwas verstanden, jedoch wo Steht worauf der Zeiger (*pPunkte) zeigt?

*pPunkte = NULL; // Zeigt für mich auf nix
Think free!

David Scherfgen

Administrator

Beiträge: 10 382

Wohnort: Hildesheim

Beruf: Wissenschaftlicher Mitarbeiter

  • Private Nachricht senden

6

29.06.2007, 17:00

Zitat von »"dev_null"«

*pZeiger // Zeiger auf eine Variable

Falsch, s.o.

Ein Zeiger ist im Prinzip nichts weiter als eine Speicheradresse. Was jetzt an dieser Adresse im Speicher liegt, ist egal.

int* pZeiger; // Deklaration eines Zeigers

pZeiger ist nun ein Zeiger, den wir irgendwohin zeigen lassen können, z.B. dahin, wo eine Variable im Speicher liegt

int Wert = 1337;
pZeiger = &Wert;

Will ich jetzt den Speicherinhalt ändern, auf den der Zeiger zeigt, dann mache ich das so:

*pZeiger = 42;

Was macht folgende Zeile?

pZeiger++;

Der Zeiger zeigt jetzt nicht mehr auf "Wert", sondern auf den Speicherbereich dahinter (4 Bytes dahinter, wenn sizeof(int) == 4).

Und was macht:

(*pZeiger)++;

Damit wird der Wert, auf den der Zeiger zeigt, erhöht.

Zitat von »"dev_null"«

*pZeiger = NULL;

Ist Unfug, NULL wird für Zeiger genutzt, nicht für "normale Werte". Mit dieser Zeile änderst du nicht den Zeiger, sondern den Wert, auf den er zeigt. Wenn du den Zeiger "nirgendwo" hin zeigen lassen willst, dann machst du das so:

pZeiger = NULL;

oder

pZeiger = 0;

Das ist dann ein Nullzeiger. Wenn du versuchst, den Wert zu lesen oder zu schreiben, auf den er zeigt, dann wirst du einen Fehler bekommen.

Faule Socke

Community-Fossil

Beiträge: 1 915

Wohnort: Schreibtischstuhl

  • Private Nachricht senden

7

29.06.2007, 17:02

Ich stimme David zu. Besser kann man es eigentlich auch nicht erklären.

Ein Zeiger ist so was ähnliches wie eine Variable. Nur mit dem unterschied, dass er die Adresse einer anderen Variable, oder eines anderen Zeigers speichert.

C-/C++-Quelltext

1
2
3
4
5
6
7
8
9
10
11
12
int *pInt = 0; // das * signalisiert HIER lediglich, das man einen Zeiger erstellen will(ungeschikt ausgedrückt)


int Int = 42; // das ist eine ganz normale variable...


pInt = &Int; // Das & signalisiert hier, dass dem Zeiger nicht der Wert der variablen int zugewiesen werden soll, sondern ihre Adresse.


// Wenn man jetzt die adresse ausgeben will, macht man das wie folgt:

cout << &Int; // Gibt die Adresse des von Int aus

cout << Int; // Gibt den Wert von Int aus

cout << pInt; // Gibt die zieladresse(also die adresse auf die der Zeiger zeigt/die er gespeichert hat) aus

cout << *pInt; // Gibt den Wert der Variablen aus, auf die der Zeiger zeigt.

cout << &pInt; // Gibt die Adresse des Zeigers aus. Das ist nicht die Zieladresse des Zeigers!!!


EDIT
Drakon: Es heisst Variable und nicht Variabel!


Socke

8

29.06.2007, 17:18

Mit dem *(Dereferenzierungs-oderIndirektionsoperator) greifts du auf den Wert der an der Adresse die im zeiger gespeichert ist zu.
Ohne das * ist es dennoch ein zeiger. Nur das du damit die Adresse die im Zeiger gespeichert ist ausgibst.
Also:

C-/C++-Quelltext

1
2
3
4
5
6
7
8
9
int Variable = 100; // X-beliebige Variable

int *Zeiger = NULL; // Der Zeiger wird deklariert und initiailisiert, eshandelt  sich um einen NULL-Zeiger da er mit NULL  initialisiert wurde                                         



Zeiger = &Variable;   // Die Adresse der Variablen wird im Zeiger gespeichert


*Zeiger++;   // Damit veränderst du den Wert der Variablen


cout << "Adresse der Variablen:" << Zeiger << endl; // Hier gibts du die Adresse der Variablen aus, weil kein * verwendet wurde


Alles klar soweit?!
"Wenn es keine Milch gäbe, würde ich auf Kaffee verzichten."

dev_null

Frischling

  • »dev_null« ist der Autor dieses Themas

Beiträge: 38

Wohnort: Augsburg

Beruf: Application Developer

  • Private Nachricht senden

9

29.06.2007, 17:30

Ja, jetzt habe ich es gerafft, ist manchmal so, das es ansich einfach ist, aber wenns nicht "klick" macht, dann gehts halt nicht :), aber nun hats klick und sogar klack gemacht :)

Danke für die Hilfe.
Think free!

drakon

Supermoderator

Beiträge: 6 513

Wohnort: Schweiz

Beruf: Entrepreneur

  • Private Nachricht senden

10

29.06.2007, 17:32

Zitat von »"David Scherfgen"«

Zitat von »"drakon"«

*pPunkte ist ein Zeiger auf eine Variabel (z.B einen Integer - Wert).

Nein, *pPunkte ist das, worauf der Zeiger zeigt.

Zitat von »"drakon"«

Wichtig ist also zu verstehen, dass:
*pZahl der Zeiger auf die Variabel ist und:

s.o.

Zitat von »"drakon"«

pZahl lediglich einen Hexadezimalen Wert enhält, welcher der Adresse entspricht, auf welches der Zeiger zeigt.

Hexadezimal?! Wie kommst du darauf? Der Zeiger ist einfach nur ein (32-Bit-)Wert und wird wie alle Zahlen im Computer binär gespeichert, also mit Einsen und Nullen.


:? Ups...da war ich nicht ganz da.

Werbeanzeige