Pointer/ Zeiger ?!

Jabster

Hi!

Ich bin recht neu auf dem Gebiet C++.

Nun soll ich in Erfahrung bringen, was Pointer/ Zeiger sind. Google habe ich schon durchsucht, nur leider werde ich daraus nicht sonderlich schlau. Kann mir jemand erklären, was Pointer sind?

Und noch ne Frage

Ich möchte grad ein Tool zum Berechnen mittels P-Q, oder für die Bayern A-B-C-Formel, schreiben, doch leider funktioniert es nicht mit Kommazahlen sowie negativen Zahlen. Wie muss ich die Variablen deklarieren?

Beschimpft mich ruhig als Noob oder Anfänger, aber ich bin für jede Hilfe dankbar!

DU NOOB! Guck in die FAQ, da ist bestimmt was über Pointer.

Jabster

Wow, auf so tolle Antworten habe ich gehofft. Wenn du nix zum THema beitragen kannst, lass es doch bitte einfach!

dEUs

Der Hinweis auf die FAQ war gar nicht so dumm, da könnte wirklich was drinne stehen.
Ansonsten guck mal auf www.c-plusplus.net -> Tutorials

Walli

Original erstellt von Jabster:
**
Ich möchte grad ein Tool zum Berechnen mittels P-Q, oder für die Bayern A-B-C-Formel, schreiben, doch leider funktioniert es nicht mit Kommazahlen sowie negativen Zahlen. Wie muss ich die Variablen deklarieren?**

Ich würd mal sagen als float oder double... Was hast du jetzt? UINT? Wenn nicht müssten die neg Zahlen funktionieren...

volkard

der verweis auf tutorials ist an sich ok.
aber jetzt willste bestimmt ne schnelle lösung haben. zeig dafür mal deinen code und einer von uns wird den fehler schon finden (hoffentlich).

endlich mal einer, der nicht ständig auf die FAQs verweist! wenn jemand eine einfache frage hat, gibt es normalerweise zwei Möglichkeiten:

Hat Zeit, sieht in FAQs, Tuts, etc und macht sich selbst schlau
Hat keine Zeit, fragt schnell, will eine einfache, kurze, schnelle Antwort

aber leider durchschauen das die meisten von uns nicht!

bis auf volkard

*bIOs

also ich weiß nicht ob du es in zwischen auch mal erfahren hast, aber pointer
speichern eine adresse im heap-bereich des arbeitsspeichers oder auch im stack (nur da braucht man sie nicht).

zeiger braucht man überall! aber heutzutage sind sie (in C++) von Referenzen abzulösen

japro

Original erstellt von <doch>:
zeiger braucht man überall! aber heutzutage sind sie (in C++) von Referenzen abzulösen

stimmt wer braucht schon dynamischen speicher

also ein zeiger (ich red deutsch):
in einer "normalen" variable (int, double, char, ...) speicherst du einen Wert.
in einem Zeiger kannst du genauso einen Wert speichern, nur sollte dieser Wert eine Adresse im Speicher sein. Über den Zeiger kannst du dann den Inhalt des Speichers, auf den diese Speicheradresse verweist, ändern

Beispiele (kompilierbar)
[cpp]
#include <iostream>
using namespace std;

int main () {
{
int x = 10; //Erzeuge eine Variable im Stapelspeicher (Stack) des Programms
//vom Typ int, und weise ihr den Wert 10 zu
int *zeiger;//Erzeuge einen Zeiger, der nur Adressen von ints beinhalten kann
zeiger = &x;//&x - nimm die Speicheradresse von x und weise sie dem Zeiger zu
//Man sagt: "zeiger" zeigt auf x

cout << x << endl;
cout << *zeiger << endl; //Mit dem Dereferenzierungsoperator * greifst du
//auf den Inhalt der Speicheradresse, die im Zeiger
//gespeichert ist zu

(*zeiger)++; //Inkrementiere den Wert, auf den der Zeiger zeigt um 1
cout << x << endl; //x ist inkrementiert worden
}
//2. Beispiel:
{
int x = 10, y = 20; //Zwei neue ints auf dem Stack erzeugen
int * zeiger; //Erklärung: siehe oben
int * * doppel_zeiger;//Erzeuge einen Zeiger, der nur auf Zeiger zeigen kann,
//die auf ints zeigen

zeiger = &x; //zeiger zeigt auf x
doppel_zeiger = &zeiger; //doppel_zeiger zeigt auf zeiger

(*doppel_zeiger) = &y; //lässt den zeiger, auf den doppelzeiger zeigt, auf y zeigen

cout << *zeiger << endl; //beweis: zeiger zeigt auf y

cout << **doppel_zeiger << endl; //Doppelte Zeiger müssen auch doppelt
//dereferenziert werden, um den richtigen
//wert zu erhalten

}
//3. Beispiel - Zusatz - 3/4/5 fach Zeiger (hoffentlich vertippe ich mich nicht)
{
char x = 'x', y = 'y', z = 'z'; //Natürlich gibt es nicht nur int-Variablen
char *zeiger1 = &x, *zeiger2 = &y; //Merke die Syntax:
/*
int *i, y; - i ist vom Typ Zeiger auf int, y vom typ int!
int i, *y; - i ist vom Typ int, y vom Typ Zeiger auf int!
int *i, *y; - i und y sind vom Typ Zeiger auf int
*/
char * * zeiger_auf_zeiger = &zeiger1;
**zeiger_auf_zeiger = 'a';
cout << x << endl; //Sollte 'a' ausgeben

zeiger_auf_zeiger = &zeiger2; //Merken für unten
**zeiger_auf_zeiger = 'b';
cout << y << endl; //Sollte 'b' ausgeben

*zeiger_auf_zeiger = &z;
cout << *zeiger2 << endl; //Sollte 'z' ausgeben
**zeiger_auf_zeiger = 'c';
cout << z << endl; //Sollte 'c' ausgeben

char *** dreifach_zeiger = &zeiger_auf_zeiger;
***dreifach_zeiger = 'z';
cout << z << endl; //Sollte 'z' ausgeben
**dreifach_zeiger = zeiger1;
***dreifach_zeiger = 'n';
cout << x << endl; //Sollte 'n' ausgeben

So, 4 und 5fach Zeiger darf wer anders machen!
}
//4. Beispiel - Die häufigere Verwendung von Zeigern - dynamischer Speicher
{
int *x = new int; //operator new nimmt sich Speicher vom Heap (Freestore, Freispeicher, etc)
*x = 10;
//und nicht vergessen:
delete x; //Um den Speicher wieder freizugeben
}
//5. Beispiel - Array auf dem Heap
{
int *x = new int[10]; //Hole Speicher für 10 ints
//x (und im allgemeinen Zeiger überhaupt) kann wie ein Array verwendet werden
x[0] = 1;
x[1] = 2;
...
x[9] = 10; //10. Element ist unter x[9]

//Freigeben mit delete []
delete [] x; //wenn du mit new [] speicher besorgst, mit delete [] freigeben!
}
//6. Beispiel - Zeigerarithmetik - Einführung
{
/*Man kann auch noch anders auf array-elemente zugreifen: du inkrementierst den zeiger:*/
int *x = new int[10];
*x = 1; //hat denselben effekt wie x[0] = 1;
++x; //x zeigt jetzt einfach auf den nächsten int im Speicher, also auf &x[1]
*x = 2; //etc.
--x; //wieder zurück, den zum freigeben muss x auf das erste element zeigen
delete x;
}
//7. Beispiel - Arrays und Zeigerarithmetik - Vertiefung
{
int x[10]; //Ein Array von 10 ints herstellen
int *y = &x[0]; //y zeigt auf das 1. Element von x
*y = 10;
cout << x[0] << endl; //Ausgabe: '10'
++y; //y zeigt auf das 2. Element von x
*y = 20;
cout << x[1] << endl; //Ausgabe: '20'

int *z = x; //Wie oben schon besprochen: eine Array-Variable (x) verhält sich
//wie ein zeiger (z)
z += 5; //Um 5 ints weiterspringen -> Zum 5.Element
*z = 50;
cout << x[4] << endl; //5.Element ausgeben: sollte sein '50'
z -= 4; //Auf das 2. Element zurückspringen
(*z)++;
cout << x[1] << endl; //Ausgabe: 21

/*
Wie man sieht, kann man zu Zeigern also auch Werte addieren, und so quer
durch den Speicher navigieren. Wenn ein Zeiger aber auf eine "falsche"
Adresse zeigt (z.b. hinter die Array-Grenze) oder auf 0 Zeigt (int *x = 0)
und man in dereferenziert, erzeugt dies "undefiniertes Verhalten".
Der Computer könnte abstürzen, oder auch ein Vogonenraumschiff anrufen,
und den Kommandanten an seine Mission, die Erde zu vernichten, erinnern,
was er vergessen haben könnte, weil er gerade ein Gedicht vorträgt.
Also: Zeiger zu dereferenzieren, die auf ungültige Adressen verweisen, ist
*schlecht
/
//8. Beispiel - Zeigerarithmetik (3, oder shon 4?) - ptrdiff_t
{
//Man kann auch Zeiger (gleichen typs versteht sich)
//voneinander abziehen. Das Ergebnis hat den Typ ptrdiff_t:

int x[10];
ptrdiff_t groesse = &x[9] - &x[0]; //groesse enthält nun den Wert, wieviele
//ints zwischen x[0] und x[9] liegen.
}
//9. Beispiel - Dereferenzierung und der operator ->
{
//C++ ist eine schöne objektorientierte Sprache, in der man natürlich
//auch Zeiger auf Objekte anlegen kann
struct bar {
int x, y;
bar () : x(0), y(0) {}
};
bar b;
b.x = 10; b.y = 20; //Alles klar, bis jetzt.

//Und nun erzeugen wir ein bar im Heap:
bar *b = new bar;
//Wie greift man jetzt auf die elemente zu? richtig, zuerst dereferenzieren:
(*b).x = 10; (*b).y = 20;
//und wieder löschen
delete bar;

//Und das ganz nochmal als Beispiel mit nem Array
bar *barr = new bar[20];
barr[0].x = 10; barr[0].y = 20;
/* etc. */
delete [] barr;

//Aber - weil sich jemand gedacht hat, er müsse zuviel tippen - ist die schreibweise
//(*zeiger).member zwar erlaubt, aber durch die kürzere Form
//zeiger->member ersetzbar:
bar *foo = new bar;
foo->x = 10; foo->y = 20;
delete foo;
}

} //ende von main[/cpp]

So. Ich nenne das eine kleine Einführung in die Welt der Zeiger. Das klingt jetzt ganz schön verwirrend, für einen Neuling, aber so ist's. Ich hoffe ich habe keine Fehler eingebaut (und wenn doch, bitte korrigiert mich).
Was ich noch sagen will: Das ist mir jetzt mal so auf die schnelle eingefallen. Ich wette, es gibt noch mindestens 1000 Probleme, die noch auf dich zukommen, Neuling Aber dazu gibt es ja die Community
Ich will auch nicht demotivierend klingen, aber das ist noch nicht mal ein kleiner Teil der Komplexität von C++. Viel Spaß noch beim lernen
Ich hoffe, ich habe ein kleines bisschen weitergeholfen.
Könnte ja jemand in die FAQs stellen

Original erstellt von japro:
[quote]Original erstellt von <doch>:
[qb]zeiger braucht man überall! aber heutzutage sind sie (in C++) von Referenzen abzulösen

stimmt wer braucht schon dynamischen speicher :)[/QB][/QUOTE]
int &x = *new int; :p
aber ich meinte damit Zeiger die in den Stack zeigen.

Jabster

Danke! Habt mir sehr weitergeholfen

Dimah tu das bitte zu den FAQs dazu

Daniel E.

Original erstellt von <Zusatz>:
**
> stimmt wer braucht schon dynamischen speicher
int &x = *new int; :p
**

Eigentlich interessant.

struct B {}; struct D1 : B {}; struct D2 : B {}; struct D3 : B {};

void foo (int a, int b)
{
    B& r = *(a == 12 ? new D1 : b == 42 ? new D2 : a == b ? new D3 : new B);
    /* ... */
    delete &r;
}

Ich bin mir nicht sicher, ob so etwas definiert ist, weil nach dem delete »zeigt« r auf kein gültiges Objekt mehr ...

ich würd sagen, nach dem delete ist r keine gültige Referenz mehr, und genauso dumm wie int &i = (int&) 01234;

das hatten wir aber doch schonmal, oder?

kannst du wenigstens mal antworten Dimah bitte ?

Dimah oder Hume: ihr könntet doch wenigstens den langen beispielcode zu Arrays und Pointer dazutun

Gerard

sorry <oder > & <erklärer> war mit php bescheftig und habe mir die threads nicht duchgelesen

ich warte bist keiner mehr was zu sagen hat (wenn der thread auf seite 2 kommt) dann verschibe ich ihn