Partager via


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 :

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#)

unsafe (référence C#)

fixed, instruction (référence C#)

stackalloc (référence C#)

Boxing et unboxing (Guide de programmation C#)

Concepts

Guide de programmation C#

Autres ressources

Types (référence C#)