imported>BlackEyedLion: - Wikisyntax (Verweis auf einen Abschnitt mit #) im lesbaren Text

2025-06-30T05:22:56Z

- Wikisyntax (Verweis auf einen Abschnitt mit #) im lesbaren Text

Neue Seite

[[Datei:Pointers-de.svg|mini|240px|Der Zeiger ''a'' zeigt auf Variable ''b''. Die Variable ''b'' enthält eine Nummer (binär 01101101) und die Variable ''a'' enthält die Speicheradresse von ''b'' (hexadezimal 1008). In diesem Fall passen die Adresse und die Daten in ein 32-Bit-[[Datenwort|Wort]].]]
[[Datei:Pointer (Zeiger) in C.ogv|mini|Video-Tutorial über Zeiger, Dereferenzierung, Felder und Zeigerarithmetik sowie deren Funktionsweise im Arbeitsspeicher am Beispiel der Programmiersprache C]]

Mit '''Zeiger''' ({{enS|pointer}}) wird in der [[Informatik]] ein Objekt einer [[Programmiersprache]] bezeichnet, das eine [[Speicheradresse]] zwischenspeichert.

Der Zeiger ''referenziert'' (verweist, zeigt auf) einen Ort im Hauptspeicher des Computers. Hier können [[Variable (Programmierung)|Variablen]], Objekte oder [[Anweisung (Programmierung)|Programmanweisungen]] gespeichert sein. Das Erlangen der dort hinterlegten Daten wird als ''dereferenzieren'' oder ''rückverweisen'' bezeichnet; siehe den Abschnitt [[#Zeigeroperationen|Zeigeroperationen]].

Ein Zeiger ist ein Sonderfall und in einigen [[Programmiersprache]]n die einzige Implementierungsmöglichkeit des Konzepts einer [[Referenz (Programmierung)|Referenz]]. Zeiger werden in diesem Sinne auch als '''''Referenzvariable''''' bezeichnet.

Zeiger werden unter anderem dazu verwendet, den [[Dynamischer Speicher|dynamischen Speicher]] zu verwalten. So werden bestimmte Datenstrukturen, zum Beispiel [[verkettete Listen]], in der Regel mit Hilfe von Zeigern [[Implementierung|implementiert]].

Der Zeiger wurde 1964/65 von [[Harold Lawson]] eingeführt und in der Programmiersprache [[PL/I]] implementiert.

== Zeiger in Programmiersprachen ==
{{Siehe auch|Zeiger (C)}}
Zeiger kommen vor allem in maschinennahen Programmiersprachen, wie [[Assemblersprache|Assembler]] oder in Sprachen, die zur [[Systemprogrammierung]] geeignet sind, wie [[C (Programmiersprache)|C]] oder [[C++]], vor. Der Gebrauch in streng typisierten Sprachen wie [[Modula-2]] oder [[Ada (Programmiersprache)|Ada]] ist stark eingeschränkt und in Sprachen wie [[Java (Programmiersprache)|Java]] oder [[Eiffel (Programmiersprache)|Eiffel]] zwar intern vorhanden, aber für den Programmierer verborgen ([[Opaker Kontext|opak]]). Mit erstgenannten Sprachen ist es möglich, Zeiger auf beliebige Stellen im Speicher zu erzeugen oder mit ihnen zu rechnen.

Manche Programmiersprachen schränken den Gebrauch von Zeigern ein, weil Programmierern bei der Arbeit mit Zeigern leicht schwerwiegende Programmierfehler unterlaufen. Bei Programmen, die in C oder C++ geschrieben sind, stellen sie häufige Ursachen für [[Pufferüberlauf|Pufferüberläufe]] oder [[Schutzverletzung|Speicherzugriffsverletzungen]] und daraus folgende [[Absturz (Computer)|Abstürze]] oder [[Sicherheitslücke]]n dar.<ref>Roland Bickel: [https://www.all-electronics.de/automatisierte-statische-code-analyse-fuer-sichere-software/ Automatisierte statische Code-Analyse für sichere Software], all-electronics.de vom 22. Oktober 2015, abgerufen am 4. Juli 2019.</ref>

In objektorientierten Sprachen tritt an die Stelle der Zeiger alternativ (C++) oder ausschließlich (Java, Python) die Referenz, die im Gegensatz zu Zeigern nicht ausdrücklich dereferenziert werden muss.

=== Zeiger in C# ===
In der Sprache [[C-Sharp|C#]] oder [[Visual Basic .NET]] kommen Zeiger im Grunde nicht vor. Alle Funktionalitäten, die Zeiger bieten, wurden durch Konzepte wie [[Methodenzeiger|Delegate]] ersetzt. Es ist jedoch in C#, nicht aber in VB.NET möglich, unsicheren Code zu deklarieren (der auch speziell kompiliert werden muss), um Zeiger wie in C++ nutzen zu können.<ref>[http://msdn.microsoft.com/de-de/library/t2yzs44b(VS.80).aspx MSDN] über unsicheren Code und Zeiger in C#</ref> Damit kann in manchen Fällen bessere [[Leistung (Informatik)|Leistung]] erreicht werden.

Der [[Datentyp]], auf den ein Zeiger verweist, wird als Verweistyp bezeichnet. Zeigertypen können nur innerhalb eines Blocks hinter dem [[Schlüsselwort (Programmierung)|Schlüsselwort]] <code>unsafe</code> verwendet werden. Nur bestimmte Datentypen, nämlich [[Datentyp#Elementare Datentypen|elementare Datentypen]], [[Aufzählungstyp]]en, Zeigertypen und Strukturtypen können ein Verweistyp sein. Es ist möglich, Konvertierungen zwischen verschiedenen Zeigertypen sowie zwischen Zeigertypen und ganzzahligen Datentypen durchzuführen.

== Typisierung ==
Die Typisierung eines Zeigers sagt aus, ob der [[Datentyp]] des Zeigers selbst Auskunft über den Datentyp des Wertes, auf den der Zeiger verweist, gibt. Es wird zwischen typisierten und untypisierten Zeigern unterschieden.<ref name=":0">{{Internetquelle |url=https://pebble.gitbooks.io/learning-c-with-pebble/content/chapter08.html |titel=Chapter 8: Pointers and Memory Allocation · Learning C with Pebble |abruf=2023-09-22}}</ref>

Typisierte Zeiger können nur auf Werte des entsprechenden Datentyps verweisen. So kann ein „Zeiger auf ein Wert vom Typ Integer“ auch nur auf ein Wert vom Typ „Integer“ verweisen. Der Datentyp des Zeigers selbst bestimmt sich also durch den Datentyp, auf den er verweist. In der Programmiersprache C ist dies eine Voraussetzung zur Realisierung der Zeigerarithmetik (s. u.), denn nur durch das Wissen um die Speichergröße des assoziierten Typs kann die Adresse des Vorgänger- oder Nachfolgeelementes berechnet werden.<ref name=":0" /> Darüber hinaus ermöglicht die Typisierung von Zeigern dem [[Compiler]], Verletzungen der [[Datentyp|Typkompatibilität]] zu erkennen.<ref>{{Internetquelle |url=https://www.geeksforgeeks.org/type-checking-in-compiler-design/ |titel=Type Checking in Compiler Design |werk=GeeksforGeeks |datum=2022-04-27 |sprache=en-us |abruf=2023-09-22}}</ref>

Untypisierte Zeiger können nicht dereferenziert, inkrementiert oder dekrementiert werden, sondern müssen vor dem Zugriff in einen typisierten Zeigertyp umgewandelt werden. Beispiele dafür sind der Typ <code>void*</code> in C, C++ und [[D (Programmiersprache)|D]], in [[Objective-C]] vom Typ <code>id</code> oder <code>POINTER</code> in Pascal. In höheren Programmiersprachen existieren zum Teil keine untypisierten Zeiger.<ref name=":0" />

== Sonderfälle ==

=== Nullzeiger ===
Der Nullzeiger ist ein spezieller Wert (ein sog. [[Nullwert]], nicht zwingend numerisch 0). Wird dieser Wert einer programmiersprachlich als Zeiger deklarierten Variablen zugewiesen, zeigt dies an, dass mit der Zeigervariablen auf „nichts“ verwiesen wird. Nullzeiger werden in fast allen Programmiersprachen sehr gerne verwendet, um eine „designierte Leerstelle“ zu kennzeichnen. Eine Ausnahme ist die Programmiersprache [[Rust (Programmiersprache)|Rust]].<ref>{{Internetquelle |url=https://doc.rust-lang.org/std/option/index.html |titel=std::option - Rust |abruf=2023-09-26}}</ref> Zum Beispiel wird eine einfach [[verkettete Liste]] meist so implementiert, dass dem Folgezeiger des letzten Elements der Wert des Nullzeigers gegeben wird, um auszudrücken, dass es kein weiteres Element gibt. Auf diese Weise lässt sich ein zusätzliches Feld, das das Ende der Liste zu bedeuten hätte, einsparen.

In [[Pascal (Programmiersprache)|Pascal]] und [[Object Pascal]] heißt der Nullzeiger beispielsweise <code>nil</code> (lateinisch: „nichts“ oder Akronym für „not in list“). In C kennzeichnet das in der [[Standard C Library|Standardbibliothek]] enthaltene [[C-Präprozessor|Präprozessor]]-Makro <code>NULL</code> den Nullzeiger und verdeckt die interne Repräsentation. In C++ heißt der Nullzeiger ebenfalls <code>NULL</code> und ist als Makro für die numerische Null (<code>0</code>) definiert.<ref>[[Bjarne Stroustrup]]: [http://www.stroustrup.com/bs_faq2.html#null C++ Style and Technique FAQ]</ref> Im neuen C++-Standard C++11 wurde die Konstante <code>nullptr</code> eingeführt, die eine typsichere Unterscheidung zwischen 0 und dem Nullzeiger ermöglicht. [[Donald Knuth]] stellt den Nullzeiger mit dem Symbol <math>\Lambda</math> dar,<ref>{{Literatur |Autor=Donald Knuth |Titel=Fundamental Algorithms |Reihe=The Art of Computer Programming |Auflage=3. |Verlag=Addison-Wesley |Datum=1997 |ISBN=0-201-89683-4 |Seiten=234}}</ref> diese Konvention wird auch von den Werkzeugen [[WEB (Programmiersprache)|WEB]] und CWEB (ebenda) verwendet.

Das Dereferenzieren eines Nullzeigers ist meist nicht erlaubt. Je nach Programmiersprache und Betriebssystem führt es zu [[Undefiniertes Verhalten|undefiniertem Verhalten]] oder einem Programmabbruch per Ausnahmebehandlung (englisch ''exception'') bzw. [[Schutzverletzung]].

=== Ungültige Zeiger ===
Falls eine Zeigervariable dereferenziert wird, die nicht auf einen gültigen Speicherbereich des entsprechenden Typs zeigt, kann es ebenfalls zu unerwartetem Verhalten kommen. So kann eine Situation auftreten, wenn eine Variable vor ihrer Benutzung nicht auf einen gültigen Wert initialisiert wurde (uninitialisierter Zeiger) oder wenn sie noch auf eine Speicheradresse verweist, die nicht mehr gültig ist ([[wilder Zeiger]]). Zeigt der Zeiger nicht auf eine gültige Speicheradresse, kann es wie beim Nullzeiger zu einer [[Schutzverletzung]] kommen.

=== Intelligente Zeiger ===
{{Hauptartikel|Intelligenter Zeiger}}
Als [[Intelligenter Zeiger|Intelligente Zeiger]] (engl. ''smart pointers'') werden Objekte bezeichnet, die einfache Zeiger einkapseln und mit zusätzlichen Funktionen und Eigenschaften ausstatten. Z. B. könnte ein ''smart pointer'' ein dynamisch alloziertes Speicherobjekt freigeben, sobald die letzte Referenz darauf gelöscht wird.

Zeiger auf eine [[Component Object Model|COM]]- oder [[Common Object Request Broker Architecture|CORBA]]-[[Schnittstelle]] sind in manchen Programmiersprachen (z. B. [[Object Pascal]]) als [[Intelligenter Zeiger]] implementiert.

=== Funktionszeiger (Methodenzeiger) ===
Funktionszeiger bilden eine besondere Klasse von Zeigern. Sie zeigen nicht auf einen Bereich im Datensegment, sondern auf den Einsprungspunkt einer Funktion im Codesegment des Speichers. Damit ist es möglich, ''benutzerdefinierte'' Funktionsaufrufe, deren Ziel erst zur Laufzeit bestimmt wird, zu realisieren.
Funktionszeiger kommen häufig in Verbindung mit [[Rückruffunktion]]en ''(callback function)'' zum Einsatz und stellen eine Form der [[Polymorphie (Programmierung)#Inklusionspolymorphie|späten Bindung]] dar.

{{Siehe auch|Methodenzeiger}}

=== Memberzeiger ===
In C++  ist es möglich, analog zu [[Methodenzeiger]]n auch Zeiger auf die ''Daten''member einer Klasse zu definieren:

<syntaxhighlight lang="c++">
#include <cstdint>
#include <vector>

using namespace std;

struct RGB_Pixel {
uint8_t red = 0, green = 0, blue = 128;
};

// definiert Typalias 'Channel' als Zeiger auf uint8_t-Datenmember der Klasse RGB_Pixel
using Channel = uint8_t RGB_Pixel::*;

// invertiert den ausgewählten RGB-Kanal aller Pixel eines Bildes
void invert(vector<RGB_Pixel>& image, Channel channel) {
for(RGB_Pixel& pixel: image)
pixel.*channel = 255 - pixel.*channel;
}

int main() {
vector<RGB_Pixel> image;
// Memberzeiger zeigt auf den grünen RGB-Kanal
Channel green = &RGB_Pixel::green;
// nur der grüne RGB-Kanal wird invertiert
invert(image, green);
}
</syntaxhighlight>

== Zeigeroperationen ==

; Dereferenzieren
: auf das Objekt, auf welches der Zeiger zeigt, zugreifen. Im Falle eines Funktionszeigers z. B. die referenzierte Funktion aufrufen
; Inkrementieren/Dekrementieren
: den Zeiger auf das Objekt versetzen, das sich im Speicher hinter/vor dem derzeitigen Objekt befindet. Intern wird dies durch Addition oder Subtraktion der Objektgröße realisiert. Diese ist dem Compiler nur bekannt, wenn der Typ des referenzierten Objekts während der [[Kompilierzeit]] klar gekennzeichnet ist.
; Zerstören
: des referenzierten Objektes (siehe [[Konstruktor|Konstruktor/Destruktor]]). Es bietet sich nach Aufruf des Destruktors an, alle Variablen, die Zeiger auf das zerstörte Objekt enthalten, auf den Nullwert zu setzen, um später erkennen zu können, dass kein gültiges Objekt mehr referenziert wird. Dies ist im Allgemeinen jedoch nicht möglich.
; Vergleichen
: mit anderen Zeigern auf Gleichheit/Ungleichheit. Manche Sprachen erlauben auch einen Größer-Kleiner-Vergleich zwischen Zeigern.

== Zeigerarithmetik ==
Das Rechnen mit Zeigern auf Basis der Speichergröße des referenzierten Typs wird als Zeigerarithmetik bezeichnet. Dabei können Zeiger erhöht, verringert und subtrahiert werden. Alle Operationen berücksichtigen dabei die Größe des referenzierten Typs. Inkrementiert man beispielsweise den Zeiger auf einen vier Byte großen Datentyp um eins, so wird dessen Wert (also die Speicheradresse) um vier Bytes erhöht. Beim Subtrahieren zweier Zeiger erhält man die Anzahl dazwischen passender Objekte des referenzierten Typs.

In Sprachen wie C wird die Zeigerarithmetik üblicherweise eingesetzt, um über terminierte Arrays zu iterieren, wie in folgendem Programm, das über das Array seiner Argumente iteriert:

<syntaxhighlight lang="c">
#include <stdio.h>

int
main(int argc, char *argv[]) /* argv ist NULL-terminiert */
{
char **cpp;

for (cpp = argv; *cpp; cpp++) { /* cpp wird jeweils um die Größe von char* erhöht */
printf("arg: %s -- adr: %p\n", *cpp, cpp); /* dereferenzierter Wert und seine Adresse */
}
printf("args: %lu\n", cpp - argv); /* Anzahl der Elemente im Array */

return 0;
}
</syntaxhighlight>

Der Aufruf mit Ausgabe sieht auf einem [[64-Bit-Architektur|64-Bit-System]] beispielsweise so aus:

<pre>
$ ./b foo bar
arg: ./b -- adr: 0x7fffffffea00
arg: foo -- adr: 0x7fffffffea08
arg: bar -- adr: 0x7fffffffea10
args: 3
</pre>

Da Zeigerarithmetik als fehleranfällig angesehen wird, wird sie in höheren Programmiersprachen meist nicht unterstützt, wobei dort andere Möglichkeiten gegeben sind, um die gleiche Funktionalität zu erlangen.

=== Zeiger auf Arrays ===
Man kann in C und C++ einer Zeigervariablen direkt ein [[Feld (Datentyp)|Array]] zuweisen. Das Ergebnis ist, dass der Zeiger auf das erste Element des Arrays zeigt.

<syntaxhighlight lang="c++">
int triangleNumbers[5];
int* numbersPointer = triangleNumbers;
</syntaxhighlight>

Über diese Zeigervariablen kann man über den Index-Operator auf die einzelnen Elemente des Arrays zugreifen:

<syntaxhighlight lang="c++">
numbersPointer[0] = 0;
numbersPointer[1] = 1;
numbersPointer[2] = 3;
numbersPointer[3] = 6;
numbersPointer[4] = 10;
cout << *numbersPointer << endl;
cout << numbersPointer[3] << endl;
</syntaxhighlight>

In diesem Beispiel werden den Elementen des Arrays die ersten fünf [[Dreieckszahl]]en zugewiesen. Mit der vorletzten Anweisung wird der Inhalt des ersten Elements des Arrays, also ''0'', ausgegeben. Mit der letzten Anweisung wird der Inhalt des Array-Elements mit dem Index 3, also ''6'', ausgegeben.

== Eigenschaften von Zeigern auf Daten ==
=== Vorteile ===
Die Verwendung von Zeigern kann in bestimmten Fällen den Programmablauf beschleunigen oder helfen, Speicherplatz zu sparen:
* Ist die von einem Programm im Speicher zu haltende Datenmenge am Programmstart unbekannt, so kann genau so viel Speicher angefordert werden, wie benötigt wird ([[Dynamischer Speicher|Dynamische Speicherverwaltung]]).
* Es ist möglich, während des Programmablaufs nicht mehr benötigten Speicher wieder an das Betriebssystem zurückzugeben.
* Bei der Verwendung von Feldern bzw. Vektoren kann man mittels Zeigern schnell innerhalb des Feldes springen und navigieren. Anstatt einen Index zu verwenden und so die Feldelemente darüber anzusprechen, setzt man zu Beginn des Ablaufs einen Zeiger auf den Anfang des Feldes und inkrementiert diesen Zeiger bei jedem Durchlauf. Die tatsächliche Schrittweite des Inkrements richtet sich nach dem betreffenden Datentyp. Diese Art des Zugriffs auf Felder wird in vielen [[Programmiersprache]]n und [[Compiler]]n an manchen Stellen intern automatisch so umgesetzt.
* Verweise auf Speicherbereiche können geändert werden, z. B. zur Sortierung von [[Liste (Datenstruktur)|Listen]], ohne die Elemente umkopieren zu müssen ([[dynamische Datenstruktur]]en).
* Bei Funktionsaufrufen kann durch die Übergabe eines Zeigers auf ein Objekt vermieden werden, das Objekt selbst zu übergeben, was eine in bestimmten Fällen sehr zeitaufwendige Anfertigung einer Kopie des Objektes erfordern würde ([[Referenzparameter]]).
* Anstatt Variablen jedes Mal zu kopieren und so jedes Mal erneut Speicherplatz zur Verfügung zu stellen, kann man in manchen Fällen einfach mehrere Zeiger auf dieselbe Variable verweisen lassen.
* Bei Zeichenketten können direkt Speicherinhalte angesprochen werden, ohne über Objekte und Funktionen gehen zu müssen.

=== Nachteile und Gefahren ===
Es gibt Sprachen, die bewusst auf den Einsatz von Zeigern verzichten (s. o.). Dies hat vor allem folgende Gründe:
* Der Umgang mit Zeigern ist schwierig zu erlernen, kompliziert und fehleranfällig. Vor allem im Sinne von Zeigern zu denken, bereitet Programmieranfängern oft Schwierigkeiten. Auch bei erfahrenen Programmierern kommen Flüchtigkeitsfehler im Umgang mit Zeigern noch relativ häufig vor.
* In manchen Programmiersprachen ist keine effektive [[Datentyp]]-Kontrolle möglich, das heißt, beim Ausführen kann nicht kontrolliert werden, welche Daten an der Zieladresse stehen, und ob diese den Erwartungen (Spezifikationen) des Programmablaufs entsprechen
* Programmierfehler bei der Arbeit mit Zeigern können schwere Folgen haben. So kommt es z. B. zu Programmabstürzen, unbemerkter Beschädigung von Daten (durch vagabundierende Zeiger), [[Pufferüberlauf|Pufferüberläufen]] oder „verlorenen“ Speicherbereichen ([[Speicherleck]]s): Das Programm fordert ständig mehr Speicher an, der anderen Programmen nicht mehr zur Verfügung steht, bis im Extremfall das Betriebssystem nicht mehr genügend liefern kann.
* Setzen sich Datenstrukturen aus Zeigern zusammen, die auf einzelne kleine Speicherblöcke verweisen, kann dies insbesondere bei Prozessen, die sehr lange laufen, zur [[Externe Fragmentierung|Fragmentierung]] des Adressraumes führen, so dass der [[Prozess (Computer)|Prozess]] keinen weiteren Speicher anfordern kann, obwohl die Summe der allozierten Speicherblöcke wesentlich geringer als der verfügbare Speicher ist.
* Die Effizienz des [[Cache|Prozessor-Caches]] leidet darunter, wenn eine Datenstruktur auf viele Speicherblöcke verweist, die im Adressraum weit auseinanderliegen. Daher kann es sinnvoll sein, stattdessen [[Feld (Datentyp)|Tabellen bzw. Felder]] (engl.: ''array'') zu verwenden, weil diese eine kompaktere Darstellung im Speicher haben.
* Letzteres kann sich auch negativ im Zusammenhang mit [[Paging]] auswirken.
* Nicht zuletzt ist ein Zeiger eine typische Ansatzstelle von [[Malware]]: Das Schadprogramm braucht nur eine Stelle zu ändern, um auf den eigenen Programmcode zu zeigen: Gibt es keine saubere Kontrolle des für das Programm reservierten Speicherbereichs, kann dieser auch beliebig anderswo liegen. Außerdem sind über fehlgeleitete Zeiger auch Pufferüberläufe einfach zu erzeugen. Insbesondere können so in Datenvariablen liegende Programmcodes zur Ausführung gelangen. Dies stellt eine typische Methode zur Erstinfektion dar.

== Weblinks ==
{{Commonscat|Pointers (computing)|Zeiger (Informatik)}}
* [http://www.willemer.de/informatik/cpp/pointer.htm Zeiger in C++]
* [https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/unsafe-code Unsafe code, pointer types, and function pointers (C# documentation)]
* [https://www.cplusplus.com/doc/tutorial/pointers/ Pointers - C++ Tutorials]
* [https://www.geeksforgeeks.org/pointers-c-examples/ Pointers in C/C++ with Examples]
* [https://www.w3schools.com/cpp/cpp_pointers.asp C++ Pointers]

== Einzelnachweise ==
<references />

{{Normdaten|TYP=s|GND=4285887-2}}

[[Kategorie:Programmierung]]
[[Kategorie:Programmiersprachelement]]
[[Kategorie:Wikipedia:Artikel mit Video]]
[[Kategorie:Informatik]]

Zeiger (Informatik) - Versionsgeschichte

imported>BlackEyedLion: - Wikisyntax (Verweis auf einen Abschnitt mit #) im lesbaren Text