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  

Die folgenden Typen können Zeigertypen sein:Any of the following types may be a pointer 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. 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 BeschreibungDescription
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 Notwendigkeit für das unsafe-Schlüsselwort und die fixed-Anweisung sowie die Vorgehensweise zum Erhöhen eines inneren Zeigers veranschaulicht.The following example shows the need for the unsafe keyword and the fixed statement, and 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. (Denken Sie daran, unsicheren Code im Projekt-Designer zu aktivieren. Wählen Sie in der Menüleiste Projekt, Eigenschaften aus, und wählen Sie anschließend Unsicheren Code zulassen auf der Registerkarte Erstellen aus.)(Remember to enable unsafe code in the Project Designer; choose Project, Properties on the menu bar, and then select Allow unsafe code in the Build tab.)

// 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);  
        // Deferencing 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]);  
Console.ReadLine();  

// 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.

Beachten Sie, dass die Übergabe von Zeigern zwischen Methoden zu nicht definiertem Verhalten führen kann.Be aware that passing pointers between methods can cause undefined behavior. Dies betrifft zum Beispiel die Rückgabe eines Zeigers an eine lokale Variable als Out-Parameter, Ref-Parameter oder als Funktionsergebnis.Examples are returning a pointer to a local variable through an 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 VerwendungUse
* 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. Die Sprachspezifikation ist die verbindliche Quelle für die Syntax und Verwendung von C#.

Siehe auchSee Also

C#-ProgrammierhandbuchC# Programming Guide
Unsicherer Code und ZeigerUnsafe Code and Pointers
ZeigerkonvertierungenPointer Conversions
ZeigerausdrückePointer Expressions
TypenTypes
unsafeunsafe
fixed-Anweisungfixed Statement
stackallocstackalloc
Boxing und UnboxingBoxing and Unboxing