Types pointeur (Guide de programmation C#)
Dans un contexte unsafe, un type peut être un type pointeur, un type valeur ou un type référence. La déclaration d'un type pointeur peut prendre l'une des formes suivantes :
type* identifier;
void* identifier; //allowed but not recommended
Chacun des types suivants peut être un type pointeur :
sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, decimal ou bool.
Tout type enum.
Tout type pointeur
Tout type struct défini par l'utilisateur qui contient des champs de types unmanaged uniquement.
Les types pointeur n'héritent pas de object et aucune conversion n'existe entre types pointeur et object. Par ailleurs, le boxing et l'unboxing ne prennent pas en charge les pointeurs. Cependant, vous pouvez effectuer des conversions entre différents types pointeur ainsi qu'entre des types pointeur et des types intégraux.
Lorsque vous déclarez plusieurs pointeurs dans la même déclaration, le symbole * est écrit conjointement au type sous-jacent uniquement, pas en tant que préfixe de chaque nom de pointeur. Par exemple :
int* p1, p2, p3; // Ok
int *p1, *p2, *p3; // Invalid in C#
Un pointeur ne peut pas pointer vers une référence ou un struct qui contient des références, car une référence d'objet peut être récupérée par le garbage collector, même si un pointeur pointe vers elle. Le garbage collector ne se préoccupe pas de savoir si un objet est pointé par des types pointeur.
La valeur de la variable pointeur de type myType* est l'adresse d'une variable de type myType. Les éléments suivants sont des exemples de déclarations de type pointeur :
Exemple |
Description |
|---|---|
int* p |
p est un pointeur vers un entier |
int** p |
p est un pointeur vers un pointeur vers un entier |
int*[] p |
p est un tableau unidimensionnel de pointeurs vers des entiers |
char* p |
p est un pointeur vers un caractère |
void* p |
p est un pointeur vers un type inconnu |
L'opérateur d'indirection de pointeur * peut être utilisé pour accéder au contenu à l'emplacement vers lequel pointe la variable pointeur. Observez, par exemple, la déclaration suivante :
int* myVariable;
L'expression *myVariable désigne la variable int trouvée à l'adresse contenue dans myVariable.
Vous ne pouvez pas appliquer l'opérateur d'indirection à un pointeur de type void*. Toutefois, vous pouvez utiliser un cast pour convertir un pointeur void en n'importe quel autre type pointeur, et inversement.
Un pointeur peut être null. L'application d'un opérateur d'indirection à un pointeur Null donne lieu à un comportement défini par l'implémentation.
Sachez que le passage de pointeurs entre méthodes peut engendrer un comportement imprévisible. Par exemple, retourner un pointeur à une variable locale via un paramètre Out ou Ref ou en tant que résultat de la fonction. Si le pointeur a été défini dans un bloc fixed, la variable vers laquelle il pointe peut ne plus être fixed.
Le tableau suivant répertorie les opérateurs et les instructions qui peuvent fonctionner sur des pointeurs dans un contexte unsafe :
Opérateur/Instruction |
Utilisation |
|---|---|
* |
Exécute l'indirection de pointeur. |
-> |
Accède à un membre d'un struct via un pointeur. |
[] |
Indexe un pointeur. |
& |
Obtient l'adresse d'une variable. |
++ et -- |
Incrémente et décrémente les pointeurs. |
+ et - |
Exécute des opérations arithmétiques sur les pointeurs. |
==, !=, <, >, <= et >= |
Compare des pointeurs. |
stackalloc |
Alloue de la mémoire sur la pile. |
instruction fixed |
Résout temporairement une variable afin de pouvoir rechercher son adresse. |
Spécification du langage C#
Pour plus d'informations, consultez la Spécification du langage C#. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.
Voir aussi
Référence
Pointeurs et code unsafe (Guide de programmation C#)
Conversions de pointeur (Guide de programmation C#)
Expressions de pointeur (Guide de programmation C#)
fixed, instruction (référence C#)
Boxing et unboxing (Guide de programmation C#)