UIntPtr.Add(UIntPtr, Int32) Méthode

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Source:

UIntPtr.cs

Ajoute un décalage à un entier non signé.

public:
 static UIntPtr Add(UIntPtr pointer, int offset);

public static UIntPtr Add (UIntPtr pointer, int offset);

static member Add : unativeint * int -> unativeint

Public Shared Function Add (pointer As UIntPtr, offset As Integer) As UIntPtr

Paramètres

pointer

UIntPtr

unativeint

Entier non signé auquel ajouter le décalage.

offset

Int32

Offset à ajouter.

Retours

UIntPtr

unativeint

Nouvel entier non signé qui reflète l’ajout de offset à pointer.

Exemples

L’exemple suivant instancie un UIntPtr objet qui pointe vers le début d’un tableau à dix éléments, puis appelle la Add méthode pour itérer les éléments du tableau.

using System;

public class Example
{
   public static void Main()
   {
      int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
      UIntPtr ptr = (UIntPtr) arr[0];
      for (int ctr = 0; ctr < arr.Length; ctr++)
      {
         UIntPtr newPtr = UIntPtr.Add(ptr, ctr);
         Console.Write("{0}   ", newPtr);
      }      
   }
}
// The example displays the following output:
//       1   2   3   4   5   6   7   8   9   10

open System

let arr = [| 1; 2; 3; 4; 5; 6; 7; 8; 9; 10 |]
let ptr = UIntPtr(uint arr[0])
for i = 0 to arr.Length - 1 do
    let newPtr = UIntPtr.Add(ptr, i)
    printf $"{newPtr}   "
// The example displays the following output:
//       1   2   3   4   5   6   7   8   9   10

Module Example
   Public Sub Main()
      Dim arr() As Integer = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }
      Dim ptr As UIntPtr = CType(arr(0), UIntPtr)
      For ctr As Integer= 0 To arr.Length - 1
         Dim newPtr As UIntPtr = UIntPtr.Add(ptr, ctr)
         Console.Write("{0}   ", newPtr)
      Next
   End Sub
End Module
' The example displays the following output:
'       1   2   3   4   5   6   7   8   9   10

Remarques

La Add méthode ne lève pas d’exception si le résultat est trop grand pour être représenté sous la forme d’un entier non signé dans le processus en cours d’exécution. Au lieu de cela, l’opération d’ajout est effectuée dans un contexte non vérifié.

Les langages qui ne prennent pas en charge la surcharge d’opérateur ou les opérateurs personnalisés peuvent utiliser cette méthode pour ajouter un décalage à la valeur d’un pointeur.

Voir aussi

• Addition(UIntPtr, Int32)