Types pointeur (Guide de programmation C#)Pointer types (C# Programming Guide)

Dans un contexte unsafe, un type peut être un type pointeur, un type valeur ou un type référence.In an unsafe context, a type may be a pointer type, a value type, or a reference type. La déclaration d'un type pointeur peut prendre l'une des formes suivantes :A pointer type declaration takes one of the following forms:

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

Le type spécifié avant * dans un type de pointeur est appelé type référent.The type specified before the * in a pointer type is called the referent type. Chacun des types suivants peut être un type référent :Any of the following types may be a referent type:

Les types pointeur n’héritent pas de object, et aucune conversion n’est possible entre les types pointeur et object.Pointer types do not inherit from object and no conversions exist between pointer types and object. Par ailleurs, le boxing et l'unboxing ne prennent pas en charge les pointeurs.Also, boxing and unboxing do not support pointers. Cependant, vous pouvez effectuer des conversions entre différents types pointeur ainsi qu'entre des types pointeur et des types intégraux.However, you can convert between different pointer types and between pointer types and integral types.

Lorsque vous déclarez plusieurs pointeurs dans la même déclaration, l'astérisque (*) est écrit conjointement au type sous-jacent uniquement, il n'est pas utilisé en tant que préfixe de chaque nom de pointeur.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. Par exemple :For example:

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

Un pointeur ne peut pas pointer vers une référence ou vers un struct qui contient des références, car une référence d’objet peut être collectée par le récupérateur de mémoire, même si un pointeur pointe vers elle.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. Le récupérateur de mémoire ne se préoccupe pas de savoir si un objet est pointé par des types pointeur.The garbage collector does not keep track of whether an object is being pointed to by any pointer types.

La valeur de la variable pointeur de type myType* est l'adresse d'une variable de type myType.The value of the pointer variable of type myType* is the address of a variable of type myType. Les éléments suivants sont des exemples de déclarations de type pointeur :The following are examples of pointer type declarations:

ExemplesExample DescriptionDescription
int* p p est un pointeur vers un entier.p is a pointer to an integer.
int** p p est un pointeur vers un pointeur vers un entier.p is a pointer to a pointer to an integer.
int*[] p p est un tableau unidimensionnel de pointeurs vers des entiers.p is a single-dimensional array of pointers to integers.
char* p p est un pointeur vers un caractère.p is a pointer to a char.
void* p p est un pointeur vers un type inconnu.p is a pointer to an unknown type.

L'opérateur d'indirection de pointeur * peut être utilisé pour accéder au contenu à l'emplacement vers lequel pointe la variable pointeur.The pointer indirection operator * can be used to access the contents at the location pointed to by the pointer variable. Observez par exemple la déclaration suivante :For example, consider the following declaration:

int* myVariable;

L'expression *myVariable désigne la variable int trouvée à l'adresse contenue dans myVariable.The expression *myVariable denotes the int variable found at the address contained in myVariable.

Plusieurs exemples de pointeurs sont présentés dans les rubriques fixed, instruction et Conversions de pointeur.There are several examples of pointers in the topics fixed Statement and Pointer Conversions. L’exemple suivant utilise le mot clé unsafe et les instructions fixed, et montre comment incrémenter un pointeur intérieur.The following example uses the unsafe keyword and the fixed statement, and shows how to increment an interior pointer. Vous pouvez coller ce code dans la fonction Main d'une application console pour l'exécuter.You can paste this code into the Main function of a console application to run it. Ces exemples doivent être compilés avec l’ensemble d’options de compilateur -unsafe.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
*/

L'opérateur d'indirection ne peut pas être appliqué à un pointeur de type void*.You cannot apply the indirection operator to a pointer of type void*. Toutefois, vous pouvez utiliser un cast pour convertir un pointeur void en n'importe quel autre type pointeur, et inversement.However, you can use a cast to convert a void pointer to any other pointer type, and vice versa.

Un pointeur peut être null.A pointer can be null. Le fait d'appliquer un opérateur d'indirection à un pointeur Null donne lieu à un comportement défini par l'implémentation.Applying the indirection operator to a null pointer causes an implementation-defined behavior.

Le passage de pointeurs entre méthodes peut engendrer un comportement non défini.Passing pointers between methods can cause undefined behavior. Supposons une méthode qui retourne un pointeur à une variable locale par le biais d’un paramètre in, out ou ref, ou comme résultat de fonction.Consider a method that returns a pointer to a local variable through an in, out, or ref parameter or as the function result. Si le pointeur a été défini dans un bloc fixed, la variable vers laquelle il pointe peut ne plus être fixed.If the pointer was set in a fixed block, the variable to which it points may no longer be fixed.

Le tableau suivant répertorie les opérateurs et les instructions qui peuvent fonctionner sur des pointeurs dans un contexte unsafe :The following table lists the operators and statements that can operate on pointers in an unsafe context:

Opérateur/InstructionOperator/Statement UtilisezUse
* Exécute l'indirection de pointeur.Performs pointer indirection.
-> Accède à un membre d'un struct via un pointeur.Accesses a member of a struct through a pointer.
[] Indexe un pointeur.Indexes a pointer.
& Obtient l'adresse d'une variable.Obtains the address of a variable.
++ et --++ and -- Incrémente et décrémente les pointeurs.Increments and decrements pointers.
+ et -+ and - Exécute des opérations arithmétiques sur les pointeurs.Performs pointer arithmetic.
==, !=, <, >, <= et >===, !=, <, >, <=, and >= Compare des pointeurs.Compares pointers.
stackalloc, opérateurstackalloc operator Alloue de la mémoire sur la pile.Allocates memory on the stack.
instruction fixedfixed statement Résout temporairement une variable afin de pouvoir rechercher son adresse.Temporarily fixes a variable so that its address may be found.

Pour plus d’informations sur les opérateurs associés au pointeur, consultez Opérateurs associés au pointeur.For more information about pointer related operators, see Pointer related operators.

spécification du langage C#C# language specification

Pour plus d’informations, consultez la section Types de pointeur de la Spécification du langage C#.For more information, see the Pointer types section of the C# language specification.

Voir aussiSee also