Was sind Zeiger und wofür sind sie da?

#include <iostream>
using namespace std;

main()
{
  int* pa1 = new int array1[10,10,10,10,10,10,10,10,10,10];
  int* pa2 = new int array2[10,10,10,10,10,10,10,10,10,10];
  cout << pa1 << endl;
  cout << pa2 << endl;
}

Hi,
erst war mir der Sinn einfach nicht klar, und deshalb habe ich es nicht verstanden, obwohl es eigentlich ziemlich leicht ist.
Also, Zeiger sind Variablen, die die Addresse einer anderen Variablen enthalten. Allerdings muss man erstmal einen Zeiger definieren und dan auch Zuweisen. Also definieren geht so:

int *name;

also int ist der Variablentyp und name en kannst du dir beliebig aussuchen.
Das * musst du einfach zwischen den Typ (hier int) und den namen (name) setzen.
Das bringt dir jetzt aber nicht allzu viel, deshalb musst du dem Zeiger noch einen Wert zuweisen.
Das geht so:

int variable1;   //eine normale int variable wird definiert
int *Zeiger1;    //Zeiger definieren

Zeiger1 = &variable1  //jetzt enthält Zeiger1 die Addresse von Variable1

Das & kannst du benutzen, um die addresse einer variablen zu ermitteln.
Also, man kann sagen, dass & soviel wie "Addresse von" heisst.

Das macht ja immernoch wenig sinn. Warum sollte man zum Beispiel wenn wir variable1 verändern sollen das über den Zeiger machen?
Können wir ja genauso ohne den Zeiger.
Nun ist es so, wenn man Variablen als Parameter in einer Funktion angibt ist das Programm etwas langsam, da von der variablen extra eine Kopie für die Parameterliste angefertigt wird (glaube ich). Jetzt könnten wir, um rechenzeit zu sparen, den Zeiger angeben, der die Addresse von variable1 speichert das ist aus irgendeinem Grund schneller.

Also zusammengefasst:

-Ein Zeiger speichert die Addresse einer Variablen.
-Zeiger werden oft als Parameter angegeben um Rechenzeit zu sparen.

Nochmal ein beispiel:

int variable1 = 5;
int *zeiger1;
zeiger1 = &variable1;  //speichert die addresse von variable1 im Zeiger

Wenn wir jetzt aber auf den wert von Variable1 über den Zeiger zugreifen wollen, müssen wir das so machen: *zeiger1 // * heisst hier, gib den Inhalt von der Addresse auf die der Zeiger zeigt an.

Hoffe ich konnte es etwas erklären.
Ich bin auch noch newbie wir könnten per ICQ auch was reden: Nr: 281565653

MFG Muffin Man

SmartyShark

Also ganz einfach.... Aber das Verständnis für Zeiger opfert normalerweise
etwas Zeit.

Zeiger zeigen, wie der Name schon sagt, auf "etwas".
Dieses "etwas" sind Speicheradressen (z.B. 0x033210442).

Man deklariert z.B. eine Variable (einfachste Fall).

int x; (Diese Integervariable erhält eine Speicheradresse im
Arbeitsspeicher, meist vom Betriebssystem zugeordnet. Der Kernel
eines Betriebssystem kümmert sich um die Speicherverwaltung).

Bsp. : int x = 5;
x hat jetzt den Wert 5 und bekommt die
(Speicheradresse :0x0032321311). Die Speicheradresse hat also den
Inhalt 5.

int* y = &x;
Bedeutung : Der Zeiger y zeigt nun auf die Speicheradresse (0x0032321311).
Wenn man jetzt sagt :

y = 10;

Dann hat der Wert x den Wert 10.

SmartyShark

Maxi

SmartyShark schrieb:

int* y = &x;
Bedeutung : Der Zeiger y zeigt nun auf die Speicheradresse (0x0032321311).
Wenn man jetzt sagt :

y = 10;

Dann hat der Wert x den Wert 10.

SmartyShark

Hä wäre y = 10 nicht, dass y dann auf die Adresse 0x0000000A zeigt? Wenn du x über y ändern willst, dann musst du den Zeiger dereferenzieren, das heißt, du greifst über den Zeiger auf den Wert zu, der an der Adresse gespeichert ist:

*y = 10
ein * vor der Variablen besagt, dass nciht die Adresse sondern der Wert der dort gespeichert ist verwendet wird.

was passiert zB wenn ich sowas hier schreibe:

int x;
int *y;
int z;

x = 5;
y = &x;
*y = x+5;
z = *y;

wie hoch ist z?
z

Ich würde sagen Z = 10
Bin mir aber nicht 100% sicher (wäre aber logisch)

hey leute, wir haben hier eine faq.

ihr müsst nicht alles für jeden neu erklären. das bringt nix.

gz

hmm ich hab noch ne weitere frage gleihc hierzu, und da ich in der faq nix gefunden habe...

ihr sagtet bisher, man muss einen zeiger so initialisieren:
int *x;
x = &y; // so ist x ein pointer der auf die adresse auf y zeigt

nun sehe ich allerdings häufig, keine zuweisung von pointern, in diversen beispielcodes, was manchmal echt verwirrend ist...
da steht z.b.

struct tm *timeinfo;
also hier haben wir einen pointer als tm struct.. aber worauf zeigt der...?

weiter gehts dann irgendwie so:
time(&timestamp);
timeinfo = localtime(&timestamp);
mktime(timeinfo);

im ganzen code wird dem pointer timeinfo nirgends ne adresse zugewiesen.. warum/wie geht das denn?

Bashar

gz schrieb:

time(&timestamp);
timeinfo = localtime(&timestamp);
mktime(timeinfo);

im ganzen code wird dem pointer timeinfo nirgends ne adresse zugewiesen.. warum/wie geht das denn?

Als was würdest du dann "timeinfo = localtime(&timestamp);" bezeichnen, wenn nicht als Zuweisung? localtime liefert einen Zeiger auf eine tm-Struktur zurück.

(Bevor du das in die falsche Kehle bekommst: Man kann keinen Zeiger auf eine lokale Variable zurückgeben, d.h. dieser Code ist fehlerhaft:

int * meine_funktion()
{
  int a;
  return &a; // FALSCH!
}

Bei localtime funktioniert das, weil der zurückgegebene Zeiger auf eine statisch allozierte Struktur verweist.)

Etyx

Also danke erstmal für den Aufwand so ganz hab ich das jetzt auch nicht verstanden aber das werde ich alles per ICQ regeln!
THX @all!

Shade Of Mine

A Tutorial on Pointers and Arrays in C