Zeigertypen (C#-Programmierhandbuch)Pointer types (C# Programming Guide)

In einem unsicheren Kontext kann ein Typ sowohl ein Zeigertyp als auch ein Werttyp oder Verweistyp sein.In an unsafe context, a type may be a pointer type, a value type, or a reference type. Eine Zeigertypdeklaration erfolgt in einer der folgenden Formen:A pointer type declaration takes one of the following forms:

type* identifier;
void* identifier; //allowed but not recommended

Der Typ, der vor * in einem Zeigertyp angegeben wird, wird als Verweistyp bezeichnet.The type specified before the * in a pointer type is called the referrent type. Die folgenden Typen können Verweistypen sein:Any of the following types may be a referrent type:

Zeigertypen erben nicht von objectobject, und es ist keine Konvertierung zwischen Zeigertypen und möglich.Pointer types do not inherit from object and no conversions exist between pointer types and object. Weiterhin unterstützen Boxing und Unboxing keine Zeiger.Also, boxing and unboxing do not support pointers. Es ist jedoch möglich, Konvertierungen zwischen verschiedenen Zeigertypen sowie zwischen Zeigertypen und ganzzahligen Typen durchzuführen.However, you can convert between different pointer types and between pointer types and integral types.

Wenn Sie mehrere Zeiger innerhalb ein- und derselben Deklaration deklarieren, wird das Sternchen (*) nur einmal mit dem zugrunde liegenden Typ notiert und nicht als Präfix für jeden Zeigernamen verwendet.When you declare multiple pointers in the same declaration, the asterisk (*) is written together with the underlying type only; it is not used as a prefix to each pointer name. Zum Beispiel:For example:

int* p1, p2, p3;   // Ok
int *p1, *p2, *p3;   // Invalid in C#

Ein Zeiger kann nicht auf einen Verweis oder eine Struktur verweisen, die Verweise enthält, da ein Objektverweis auch dann in die Garbage Collection aufgenommen werden kann, wenn ein Zeiger darauf verweist.A pointer cannot point to a reference or to a struct that contains references, because an object reference can be garbage collected even if a pointer is pointing to it. In der Garbage Collection wird nicht nachgehalten, ob von einem der Zeigertypen auf ein Objekt verwiesen wird.The garbage collector does not keep track of whether an object is being pointed to by any pointer types.

Der Wert der Zeigervariablen vom Typ myType* ist die Adresse einer Variablen vom Typ myType.The value of the pointer variable of type myType* is the address of a variable of type myType. Im Folgenden finden Sie Beispiele für Zeigertypdeklarationen:The following are examples of pointer type declarations:

BeispielExample Beschreibung Description
int* p p ist ein Zeiger auf einen ganzzahligen Wert.p is a pointer to an integer.
int** p p ist ein Zeiger auf einen Zeiger auf einen ganzzahligen Wert.p is a pointer to a pointer to an integer.
int*[] p p ist ein eindimensionales Array von Zeigern auf ganzzahlige Werte.p is a single-dimensional array of pointers to integers.
char* p p ist ein Zeiger auf eine char-Variable.p is a pointer to a char.
void* p p ist ein Zeiger auf einen unbekannten Typ.p is a pointer to an unknown type.

Sie können den Zeigerdereferenzierungsoperator * verwenden, um auf den Inhalt an der Speicherstelle zuzugreifen, auf die die Zeigervariable zeigt.The pointer indirection operator * can be used to access the contents at the location pointed to by the pointer variable. Betrachten Sie beispielsweise die folgende Deklaration:For example, consider the following declaration:

int* myVariable;

Der Ausdruck *myVariable kennzeichnet die int-Variable, die sich an der in myVariable enthaltenen Adresse befindet.The expression *myVariable denotes the int variable found at the address contained in myVariable.

Es gibt mehrere Beispiele von Zeigern in den Themen fixed-Anweisung und Zeigerkonvertierungen.There are several examples of pointers in the topics fixed Statement and Pointer Conversions. Im folgenden Beispiel wird die Verwendung des unsafe-Schlüsselworts und der fixed-Anweisung sowie die Vorgehensweise zum Erhöhen eines inneren Zeigers veranschaulicht.The following example uses the unsafe keyword and the fixed statement, and shows how to increment an interior pointer. Sie können diesen Code in die Hauptmethode einer Konsolenanwendung einfügen, um ihn auszuführen.You can paste this code into the Main function of a console application to run it. Diese Beispiele müssen mithilfe der Compileroption -unsafe kompiliert werden.These examples must be compiled with the -unsafe compiler option set.

// Normal pointer to an object.
int[] a = new int[5] { 10, 20, 30, 40, 50 };
// Must be in unsafe code to use interior pointers.
unsafe
{
    // Must pin object on heap so that it doesn't move while using interior pointers.
    fixed (int* p = &a[0])
    {
        // p is pinned as well as object, so create another pointer to show incrementing it.
        int* p2 = p;
        Console.WriteLine(*p2);
        // Incrementing p2 bumps the pointer by four bytes due to its type ...
        p2 += 1;
        Console.WriteLine(*p2);
        p2 += 1;
        Console.WriteLine(*p2);
        Console.WriteLine("--------");
        Console.WriteLine(*p);
        // Dereferencing p and incrementing changes the value of a[0] ...
        *p += 1;
        Console.WriteLine(*p);
        *p += 1;
        Console.WriteLine(*p);
    }
}

Console.WriteLine("--------");
Console.WriteLine(a[0]);

/*
Output:
10
20
30
--------
10
11
12
--------
12
*/

Der Dereferenzierungsoperator kann nicht auf Zeiger vom Typ void* angewendet werden.You cannot apply the indirection operator to a pointer of type void*. Sie können jedoch eine Umwandlung verwenden, um einen void-Zeiger in einen anderen Zeigertyp und umgekehrt zu konvertieren.However, you can use a cast to convert a void pointer to any other pointer type, and vice versa.

Ein Zeiger kann den Wert null annehmen.A pointer can be null. Die Anwendung des Dereferenzierungsoperators auf einen NULL-Zeiger führt zu einem in der Implementierung definierten Verhalten.Applying the indirection operator to a null pointer causes an implementation-defined behavior.

Die Übergabe von Zeigern zwischen Methoden kann zu nicht definiertem Verhalten führen.Passing pointers between methods can cause undefined behavior. Ziehen Sie eine Methode in Betracht, die einen Zeiger auf eine lokale Variable als einen in-, out- oder ref-Parameter oder als Funktionsergebnis zurückgibt.Consider a method that returns a pointer to a local variable through an in, out, or ref parameter or as the function result. Wenn der Zeiger in einem fixed-Block festgelegt wurde, ist die Variable, auf die der Zeiger verweist, möglicherweise nicht fixiert.If the pointer was set in a fixed block, the variable to which it points may no longer be fixed.

In der folgenden Tabelle werden die Operatoren und Anweisungen aufgelistet, die in einem unsicheren Kontext auf Zeiger angewendet werden können.The following table lists the operators and statements that can operate on pointers in an unsafe context:

Operator/AnweisungOperator/Statement MitUse
* Führt eine Zeigerdereferenzierung aus.Performs pointer indirection.
-> Greift über einen Zeiger auf einen Member einer Struktur zu.Accesses a member of a struct through a pointer.
[][] Indiziert einen Zeiger.Indexes a pointer.
& Ruft die Adresse einer Variablen ab.Obtains the address of a variable.
++ und --++ and -- Inkrementiert und dekrementiert Zeiger.Increments and decrements pointers.
+ und -+ and - Führt Zeigerarithmetik aus.Performs pointer arithmetic.
==, !=, <, >, <=, und >===, !=, <, >, <=, and >= Vergleicht Zeiger.Compares pointers.
stackalloc Belegt Speicher für den Stapel.Allocates memory on the stack.
fixed-Anweisungfixed statement Fixiert eine Variable vorübergehend, damit ihre Adresse gefunden werden kann.Temporarily fixes a variable so that its address may be found.

C#-ProgrammiersprachenspezifikationC# Language Specification

Weitere Informationen erhalten Sie unter C#-Sprachspezifikation.For more information, see the C# Language Specification. Die Sprachspezifikation ist die verbindliche Quelle für die Syntax und Verwendung von C#.The language specification is the definitive source for C# syntax and usage.

Siehe auchSee Also