Opérateurs associés au pointeur (référence C#)Pointer related operators (C# reference)

Vous pouvez utiliser les opérateurs suivants avec les pointeurs :You can use the following operators to work with pointers:

Pour plus d’informations sur les types de pointeurs, consultez Types pointeur.For information about pointer types, see Pointer types.

Notes

Toutes les opérations impliquant des pointeurs nécessitent un contexte unsafe.Any operation with pointers requires an unsafe context. Le code qui contient des blocs -unsafe dangereux doit être compilé avec l’option compilateur.The code that contains unsafe blocks must be compiled with the -unsafe compiler option.

Adresse de l’opérateur&Address-of operator &

L’opérateur unaire & retourne l’adresse de son opérande :The unary & operator returns the address of its operand:

unsafe
{
    int number = 27;
    int* pointerToNumber = &number;

    Console.WriteLine($"Value of the variable: {number}");
    Console.WriteLine($"Address of the variable: {(long)pointerToNumber:X}");
}
// Output is similar to:
// Value of the variable: 27
// Address of the variable: 6C1457DBD4

L’opérande de l’opérateur & doit être une variable fixe.The operand of the & operator must be a fixed variable. Les variables fixes se trouvent dans des emplacements de stockage qui ne sont pas affectés par le récupérateur de mémoire.Fixed variables are variables that reside in storage locations that are unaffected by operation of the garbage collector. Dans l’exemple précédent, la variable locale number est une variable fixe, car elle se trouve dans la pile.In the preceding example, the local variable number is a fixed variable, because it resides on the stack. Les variables qui se trouvent dans des emplacements de stockage pouvant être affectés par le récupérateur de mémoire (par exemple, en étant déplacés) sont appelées variables déplaçables.Variables that reside in storage locations that can be affected by the garbage collector (for example, relocated) are called movable variables. Les champs d’objet et les éléments de tableau sont des exemples de variables déplaçables.Object fields and array elements are examples of movable variables. Vous pouvez obtenir l’adresse d’une variable mobile si vous "fixez", ou "pin", il avec une fixed déclaration.You can get the address of a movable variable if you "fix", or "pin", it with a fixed statement. L’adresse obtenue n’est valable fixed qu’à l’intérieur du bloc d’une déclaration.The obtained address is valid only inside the block of a fixed statement. L’exemple suivant montre fixed comment utiliser & une déclaration et l’opérateur :The following example shows how to use a fixed statement and the & operator:

unsafe
{
    byte[] bytes = { 1, 2, 3 };
    fixed (byte* pointerToFirst = &bytes[0])
    {
        // The address stored in pointerToFirst 
        // is valid only inside this fixed statement block.
    }
}

Vous ne pouvez pas obtenir l’adresse d’une constante ou d’une valeur.You can't get the address of a constant or a value.

Pour plus d’informations sur les variables fixes et déplaçables, consultez la section Variables fixes et déplaçables de la spécification du langage C#.For more information about fixed and movable variables, see the Fixed and moveable variables section of the C# language specification.

L’opérateur binaire & calcule la logique AND de ses opérandes booléens, ou la logique AND au niveau du bit de ses opérandes de type intégral.The binary & operator computes the logical AND of its Boolean operands or the bitwise logical AND of its integral operands.

Opérateur d’indirection de pointeur *Pointer indirection operator *

L’opérateur unaire d’indirection de pointeur * permet d’obtenir la variable vers laquelle pointe son opérande.The unary pointer indirection operator * obtains the variable to which its operand points. Il est également appelé « opérateur de déréférence ».It's also known as the dereference operator. L’opérande de l’opérateur * doit être un type de pointeur.The operand of the * operator must be of a pointer type.

unsafe
{
    char letter = 'A';
    char* pointerToLetter = &letter;
    Console.WriteLine($"Value of the `letter` variable: {letter}");
    Console.WriteLine($"Address of the `letter` variable: {(long)pointerToLetter:X}");

    *pointerToLetter = 'Z';
    Console.WriteLine($"Value of the `letter` variable after update: {letter}");
}
// Output is similar to:
// Value of the `letter` variable: A
// Address of the `letter` variable: DCB977DDF4
// Value of the `letter` variable after update: Z

Vous ne pouvez pas appliquer l’opérateur * à une expression de type void*.You cannot apply the * operator to an expression of type void*.

L’opérateur binaire * calcule le produit de ses opérandes numériques.The binary * operator computes the product of its numeric operands.

Opérateur d’accès aux membres de pointeur ->Pointer member access operator ->

L’opérateur -> associe l’indirection de pointeur à l’accès aux membres.The -> operator combines pointer indirection and member access. Autrement dit, x si est T* un y pointeur de Ttype et est un membre accessible de type , une expression de la formeThat is, if x is a pointer of type T* and y is an accessible member of type T, an expression of the form

x->y

équivaut à :is equivalent to

(*x).y

L’exemple suivant illustre l’utilisation de l’opérateur -> :The following example demonstrates the usage of the -> operator:

public struct Coords
{
    public int X;
    public int Y;
    public override string ToString() => $"({X}, {Y})";
}

public class PointerMemberAccessExample
{
    public static unsafe void Main()
    {
        Coords coords;
        Coords* p = &coords;
        p->X = 3;
        p->Y = 4;
        Console.WriteLine(p->ToString());  // output: (3, 4)
    }
}

Vous ne pouvez pas appliquer l’opérateur -> à une expression de type void*.You cannot apply the -> operator to an expression of type void*.

Opérateur d’accès aux éléments de pointeur []Pointer element access operator []

Pour une expression p d’un type pointeur, l’accès à un élément de pointeur au format p[n] est évalué comme *(p + n), où n doit être d’un type implicitement convertible en int, uint, long ou ulong.For an expression p of a pointer type, a pointer element access of the form p[n] is evaluated as *(p + n), where n must be of a type implicitly convertible to int, uint, long, or ulong. Pour plus d’informations sur le comportement de l’opérateur + avec les pointeurs, consultez la section Addition ou soustraction d’une valeur intégrale dans un pointeur.For information about the behavior of the + operator with pointers, see the Addition or subtraction of an integral value to or from a pointer section.

L’exemple suivant montre comment accéder à des éléments tableau avec un pointeur et l’opérateur [] :The following example demonstrates how to access array elements with a pointer and the [] operator:

unsafe
{
    char* pointerToChars = stackalloc char[123];

    for (int i = 65; i < 123; i++)
    {
        pointerToChars[i] = (char)i;
    }

    Console.Write("Uppercase letters: ");
    for (int i = 65; i < 91; i++)
    {
        Console.Write(pointerToChars[i]);
    }
}
// Output:
// Uppercase letters: ABCDEFGHIJKLMNOPQRSTUVWXYZ

Dans l’exemple stackalloc précédent, une expression alloue un bloc de mémoire sur la pile.In the preceding example, a stackalloc expression allocates a block of memory on the stack.

Notes

L’opérateur d’accès aux éléments de pointeur ne recherche pas les erreurs de dépassement des limites.The pointer element access operator doesn't check for out-of-bounds errors.

Vous ne pouvez pas utiliser [] pour l’accès aux éléments de pointeur avec une expression de type void*.You cannot use [] for pointer element access with an expression of type void*.

Vous pouvez également utiliser l’opérateur [] pour l’accès aux éléments de tableau ou à l’indexeur.You also can use the [] operator for array element or indexer access.

Opérateurs arithmétiques de pointeurPointer arithmetic operators

Vous pouvez effectuer les opérations arithmétiques suivantes avec des pointeurs :You can perform the following arithmetic operations with pointers:

  • Ajouter ou soustraire une valeur intégrale dans un pointeurAdd or subtract an integral value to or from a pointer
  • Soustraire deux pointeursSubtract two pointers
  • Incrémenter ou décrémenter un pointeurIncrement or decrement a pointer

Vous ne pouvez pas effectuer ces opérations avec des pointeurs de type void*.You cannot perform those operations with pointers of type void*.

Pour plus d’informations sur les opérations arithmétiques prises en charge avec les types numériques, consultez Opérateurs arithmétiques.For information about supported arithmetic operations with numeric types, see Arithmetic operators.

Ajout ou soustraction d’une valeur intégrale dans un pointeurAddition or subtraction of an integral value to or from a pointer

Pour un pointeur p de type T* et une expression n d’un type implicitement convertible en int, uint, long ou ulong, l’addition et la soustraction sont définies de la façon suivante :For a pointer p of type T* and an expression n of a type implicitly convertible to int, uint, long, or ulong, addition and subtraction are defined as follows:

  • Les expressions p + n et n + p produisent un pointeur de type T* qui est obtenu en ajoutant n * sizeof(T) à l’adresse fournie par p.Both p + n and n + p expressions produce a pointer of type T* that results from adding n * sizeof(T) to the address given by p.
  • L’expression p - n produit un pointeur de type T* qui est obtenu en soustrayant n * sizeof(T) de l’adresse fournie par p.The p - n expression produces a pointer of type T* that results from subtracting n * sizeof(T) from the address given by p.

sizeof L’opérateur obtient la taille d’un type d’octets.The sizeof operator obtains the size of a type in bytes.

L’exemple suivant illustre l’utilisation de l’opérateur + avec un pointeur :The following example demonstrates the usage of the + operator with a pointer:

unsafe
{
    const int Count = 3;
    int[] numbers = new int[Count] { 10, 20, 30 };
    fixed (int* pointerToFirst = &numbers[0])
    {
        int* pointerToLast = pointerToFirst + (Count - 1);

        Console.WriteLine($"Value {*pointerToFirst} at address {(long)pointerToFirst}");
        Console.WriteLine($"Value {*pointerToLast} at address {(long)pointerToLast}");
    }
}
// Output is similar to:
// Value 10 at address 1818345918136
// Value 30 at address 1818345918144

Soustraction de pointeurPointer subtraction

Pour deux pointeurs p1 et p2 de type T*, l’expression p1 - p2 produit la différence entre les adresses fournies par p1 et p2, divisée par sizeof(T).For two pointers p1 and p2 of type T*, the expression p1 - p2 produces the difference between the addresses given by p1 and p2 divided by sizeof(T). Le type du résultat est long.The type of the result is long. C’est -à-dire que p1 - p2est calculé en tant que ((long)(p1) - (long)(p2)) / sizeof(T).That is, p1 - p2 is computed as ((long)(p1) - (long)(p2)) / sizeof(T).

L’exemple suivant montre la soustraction d’un pointeur :The following example demonstrates the pointer subtraction:

unsafe
{
    int* numbers = stackalloc int[] { 0, 1, 2, 3, 4, 5 };
    int* p1 = &numbers[1];
    int* p2 = &numbers[5];
    Console.WriteLine(p2 - p1);  // output: 4
}

Incrémenter et décrémenter des pointeursPointer increment and decrement

L’opérateur d’incrémentation ++ajoute 1 à son opérande de pointeur.The ++ increment operator adds 1 to its pointer operand. L’opérateur de décrémentation --soustrait 1 de son opérande de pointeur.The -- decrement operator subtracts 1 from its pointer operand.

Les deux opérateurs sont pris en charge sous deux formes : suffixée (p++ et p--) et préfixée (++p et --p).Both operators are supported in two forms: postfix (p++ and p--) and prefix (++p and --p). Le résultat de p++ et p-- correspond à la valeur de p avant l’opération.The result of p++ and p-- is the value of p before the operation. Le résultat de ++p et --p correspond à la valeur de p après l’opération.The result of ++p and --p is the value of p after the operation.

L’exemple suivant montre le comportement des opérateurs d’incrémentation suffixés et préfixés :The following example demonstrates the behavior of both postfix and prefix increment operators:

unsafe
{
    int* numbers = stackalloc int[] { 0, 1, 2 };
    int* p1 = &numbers[0];
    int* p2 = p1;
    Console.WriteLine($"Before operation: p1 - {(long)p1}, p2 - {(long)p2}");
    Console.WriteLine($"Postfix increment of p1: {(long)(p1++)}");
    Console.WriteLine($"Prefix increment of p2: {(long)(++p2)}");
    Console.WriteLine($"After operation: p1 - {(long)p1}, p2 - {(long)p2}");
}
// Output is similar to
// Before operation: p1 - 816489946512, p2 - 816489946512
// Postfix increment of p1: 816489946512
// Prefix increment of p2: 816489946516
// After operation: p1 - 816489946516, p2 - 816489946516

Opérateurs de comparaison de pointeurPointer comparison operators

Vous pouvez utiliser les opérateurs ==, !=, <, >, <= et >= pour comparer des opérandes de tout type de pointeur, y compris void*.You can use the ==, !=, <, >, <=, and >= operators to compare operands of any pointer type, including void*. Ces opérateurs comparent les adresses fournies par les deux opérandes comme s’il s’agissait d’entiers non signés.Those operators compare the addresses given by the two operands as if they were unsigned integers.

Pour plus d’informations sur le comportement de ces opérateurs pour les opérandes d’autres types, consultez les articles Opérateurs d’égalité et Opérateurs de comparaison.For information about the behavior of those operators for operands of other types, see the Equality operators and Comparison operators articles.

Précédence des opérateursOperator precedence

La liste suivante présente les opérateurs relatifs aux pointeurs par ordre de précédence, de la plus élevée à la plus basse :The following list orders pointer related operators starting from the highest precedence to the lowest:

  • Opérateurs suffixés d’incrémentationx++ et de décrémentation x--, ainsi que les opérateurs -> et []Postfix increment x++ and decrement x-- operators and the -> and [] operators
  • Opérateurs préfixés d’incrémentation++x et de décrémentation --x, ainsi que les opérateurs & et *Prefix increment ++x and decrement --x operators and the & and * operators
  • Opérateurs additifs + et -Additive + and - operators
  • Opérateurs de comparaison <, >, <= et >=Comparison <, >, <=, and >= operators
  • Opérateurs d’égalité == et !=Equality == and != operators

Utilisez des parenthèses (()) pour modifier l’ordre d’évaluation imposé par la précédence des opérateurs.Use parentheses, (), to change the order of evaluation imposed by operator precedence.

Pour la liste complète des opérateurs C’commandés par niveau de préséance, voir la section De préséance de l’opérateur de l’article des opérateurs C.For the complete list of C# operators ordered by precedence level, see the Operator precedence section of the C# operators article.

Capacité de surcharge de l’opérateurOperator overloadability

Un type défini par l’utilisateur ne peut pas surcharger les opérateurs de pointeur &, *, -> et [].A user-defined type cannot overload the pointer related operators &, *, ->, and [].

spécification du langage C#C# language specification

Pour plus d’informations, consultez les sections suivantes de la spécification du langage C# :For more information, see the following sections of the C# language specification:

Voir aussiSee also