Zeiger[Suche] Tut,Beispiel mit erklörung o.ä.

Low_Skiller · 24. Januar 2006

Hallo,
Ich suche schon seit längerem nen Tut oder sowas in der Art für Zeiger.

da das prinzip eh immer das gleiche ist ists fast egal ob in Delphi oder C++.
In C++ hab ich mal n Buch gelesen und Zeiger war das einzige Thema was so umständlich/unverständlich, dass man auch mit dem Beispiel nicht wirklich verstehen konnte was und wozu Zeiger sind

Was ich von meinem Lehrer weiß, ist das mann sich einen Zeiger ja als art endloses Array vorstellen sollte, erweiterbar, veränderbar (und auch löschbar )
Weil man irgendwie auf Speicher verweisen kann. Wie und warum man das macht weiß ich allerdings nicht

Und da dieses Thema scheinbar wichtig ist um "weiter" zu kommen(mich kotzen diese F* programme an wo 50int und 80 Char variablen sind oder auch 1 Array aus dem ich selber nicht mehr rauskomme)

gute Bewertung gibts vlt. auch wenn einer Helfen kann THX schonmal

Anzeige

weixi2 · 24. Januar 2006

Ein Zeiger ist eine Variable, die die Adresse einer anderen Variable speichert.

Bsp:

Code:

#incluse <iostream>
using std::cout;

int main()
{
 int Alter; //Irgendeine Variable
 int * pAlter; // Ein Zeiger

 pAlter = &Alter; //Mittels Adressoperator (&) Adresse von Alter an pAlter weisen

 cout << "Alter: " << Alter << "\n";
 cout << "pAlter: " << *pAlter << "\n"; //Wert, der an der Adresse von pAlter gespeichert ist ausgeben

return 0;

}

nochn kleinen syntax fehler ausgebessert

Low_Skiller · 24. Januar 2006

was hat das für Vorteile/Nachteile?
Im prinzip kann ich doch auch einfach mit Alter arbeiten(hier im Bsp.)

Hat der Zeiger einen Typen oder wird einfach ein Zahlen/alphanumerischer Wert ausgegeben?

weixi2 · 24. Januar 2006

Mit Zeigern kannst du halt tiefer eindringen und manipulieren.. Oder du übergibst nen Zeiger an eine Funktion.. dann wird die Variable auf die der Zeiger deutet verändert und nicht eine Instanz der Variable..

Die Zeigervariable kann verschieden dargestellt werden.. kommt aufs system drauf an. kannst sie dir ja mal ausgeben lassen:

Code:

cout << pAlter;

Belacqua · 25. Januar 2006

Mit Zeigern kann man viel machen, aber auch viel kaputt. Eine sinnvolle Anwendung ist zum Beispiel das Übergeben größerer Strukturen an eine Funktion.

z.B.

struct Struktur
{
BYTE n1;
WORD n2;
BYTE uArray[50];
}

Struktur sTeststruktur;

Würde man nun diese Struktur an eine Funktion über einen Parameter übergeben wollen ergibt sich das Problem, dass alle Werte der Struktur über den Stack an die aufgerufene Funktion übergeben werden (50+2+1 = 53 Bytes!). Bei Microcontrollern kann das schon zum Stacküberlauf führen und unter Windows kann man das auch nicht gerade als saubere Programmiertechnik bezeichnen. Übergibt man aber nur den Zeiger auf die Struktur, so beschränkt sich die Übergabe auf die in dem Zeiger enthaltene Adressebreite, die je nach System ein paar Bytes nicht überschreiten dürfte.

Beispiel
Funktion(&sTeststruktur); // so wird in C der Zeiger auf die Struktur übergeben.

Unplugged · 25. Januar 2006

vor allem was die Nutzung von Dll betrifft, spielen Pointer eine wichtige Rolle.
An Funktionen die in dll's ausgelagert sind, sollten grundsätzlich immer Pointer übergeben wird.

Instanzvariablen von Klassen ( abgeleitet von TObject ) sind in Delphi beispielsweise auch Pointer.

blaah · 25. Januar 2006

als mit zeigern /pointer kannst du eine verkette liste machen:

http://de.wikibooks.org/wiki/Algorithmen_und_Datenstrukturen_in_C:_Verkettete_Listen

jetzt weiß ich die genauen daten nicht mehr, aber du kannst nur eine gewisse größe an variablen anlegen. int = 2bit, (glaub ich).

deswegen kannst du auch keine array anlegen: int test[100][100];
da der heat bereich nur eine gewisse größe speichern kann. deswegen musst du in den bereich ohne adressname gehen. d.h.

die variablen können nur über die adresse angesprochen werden. dieser bereich ist der eigentliche ram und somit kannst du soviel variablen anlegen wie du arbeitsspeicher hast.

wenn du jetzt eine verkettete liste machst, also so wie auf dem link. kannst du x beliebige variablen machen, bzw ketten speichern.

hoffe das ost alles teilweise richtig. wenn nicht sorry!

the_player · 25. Januar 2006

Hat das ganze nicht auch was mit callByValue und CallByReferenz zu tun, wenn man mal von den verketteten Listen absieht. Wenn ich eine var setzte (mit einem Wer füllen will) habe ich doch normalerweise callByValue wenn ich die aber mittels eines Pointers auf den Speichort zeigen lasse dann habe ich doch callByReferenz. so kann man var immer auf dem selben wert halten.

Stimmt das bei C++ habe sonst nur andere Hochsprachen gemacht!

Low_Skiller · 25. Januar 2006

Also wenn ich dsa richtig verstanden habe sind Zeiger/Pointer die Methode um Daten(typen) resourcen sparend zu übergeben.

Dann danke für die vielen Antworten, ich lass das Thema mal offen so
ich geh mal n bisschen probieren.

THX 4 Help @ All ich geb mal n paar gute bewertungen an euch.

EDIT:bewerten ging nicht mal in die Forenregeln guggn) wenns klappt hohl ichs nach!

tiger888 · 27. Januar 2006

Hab hier mal noch ne PowerPoint Presentation zum Thema Zeiger, Records und Stapel geuppt.
is aus unserem Unterricht.
Basiert zwar auf der Grundlage von Java aber vielleicht hilts ein bissl beim Verständnis

Klick mich

humpidum · 27. Januar 2006

das hier ist ne relativ gute seite zu delphi
da findet man bestimmt auch was zu zeigern.

http://www.dsdt.info/

ich fand zeiger auch immer das schwerste beim programmieren...

...viel glück!

Low_Skiller · 27. Januar 2006

THX Tiger_888/humpidum würd dir gern n 10er geben aber entwederich hab dich schon bewertet oder ich darfs ned

bloodrage · 31. Januar 2006

also im Prinzip ist ein Zeiger nichts anderes als eine Variable die eine ADRESSE vom Speicher beinhaltet.

natürlich ist das bei mehreren bytes großen Variablentypen immer der Anfangsbyte auf den gedeutet/gepoint/gezeigt wird!

Zeiger werden wie Variablen einer bestimmten Klasse zugeordnet, d.h. es gibt Zeiger für int, long, short etc. das gleiche gilt übrigens für selbstdefinierte Strukturen!

Um diesem Problem bei der Übergabe aus dem Weg zu gehen arbeitet man bei unbekannten Datenelementen mit void* Zeigern. Denn diese können in alle anderen Zeigertypen umgewandelt werden.
Durch Zeiger kann man eben sehr leicht undefinierte Datenmengen bearbeiten, so könnte z.b. ein Array von void* Zeigern auf einzelne Datenbereiche deuten in denen sich wiederrum void* zeiger verbergen und diese zeigen wiederrum auf andere Arrays oder Datenelement etc.

Neben diesen Zeigern auf Variablen gibts es noch die so genannten Funktionszeiger.
Diese werden verwendet um einerseits Tipparbeit andererseits eine veränderbare Programmstruktur zu erstellen.
Funktionszeiger sind wie folgt aufgebaut:
void (* Zeigername) (Funktionsparameter von der Funktion des Zeigers);
eine Zuweisung der Adressierung erfoglt so:
Zeigername = Funktionsname;

Diese Zuweisung funktionier übrigens nur, wenn die Anzahl und die Typen der Parameter überein stimmen!

Im Übrigen:
int Array[500] != int * Array[500]
ABER:
int Array[500] == *Array = new int[500];
d.h. der Array-Name ist ein konstanter Zeiger auf das erste Element sprich Array[0]; .

Hoff' damit etwas Klarheit geschaffen zu haben. Bei Fragen einfach ne PN.
PS: Es gibt noch Streber die 15 Punkte in Info haben

mfg
bloodrage

Nützliche Suchen

Zeiger[Suche] Tut,Beispiel mit erklörung o.ä.

Videos zum Themenbereich