Partager via


IntPtr.Addition(IntPtr, Int32) Opérateur

Définition

Ajoute un décalage à un entier signé.

public:
 static IntPtr operator +(IntPtr pointer, int offset);
public static IntPtr operator + (IntPtr pointer, int offset);
static member ( + ) : nativeint * int -> nativeint
Public Shared Operator + (pointer As IntPtr, offset As Integer) As IntPtr

Paramètres

pointer
IntPtr

nativeint

Entier signé à laquelle ajouter le décalage.

offset
Int32

Offset à ajouter.

Retours

IntPtr

nativeint

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

Remarques

La Addition méthode définit l’opération d’ajout pour IntPtr les objets. Il active le code tel que le suivant.

int[] arr = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20 };
unsafe {
   fixed(int* parr = arr)
   {
       IntPtr ptr = new IntPtr(parr);
       for (int ctr = 0; ctr < arr.Length; ctr++)
       {
          IntPtr newPtr = ptr + ctr * sizeof(Int32);
          Console.Write("{0}   ", Marshal.ReadInt32(newPtr));
       }
   }
}
// The example displays the following output:
//       2   4   6   8   10   12   14   16   18   20
#nowarn "9"
open System.Runtime.InteropServices
open FSharp.NativeInterop

[<EntryPoint>]
let main _ =
    let arr =
        [| 2; 4; 6; 8; 10; 12; 14; 16; 18; 20 |]
        
    use parr = fixed arr

    let ptr = NativePtr.toNativeInt parr

    for i = 0 to arr.Length - 1 do
        let newPtr = ptr + nativeint i * nativeint sizeof<int>
        printf $"{Marshal.ReadInt32 newPtr}   "
    0

    // The example displays the following output:
    //       2   4   6   8   10   12   14   16   18   20
Dim arr() As Integer = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20 }
Dim ptr As IntPtr = Marshal.UnsafeAddrOfPinnedArrayElement(arr, 0)
For ctr As Integer = 0 To arr.Length - 1
   Dim newPtr As IntPtr = ptr + ctr * Len(arr(0))
   Console.WriteLine("{0}   ", Marshal.ReadInt32(newPtr))
Next
' The example displays the following output:
'       2   4   6   8   10   12   14   16   18   20

Les langages qui ne prennent pas en charge les opérateurs personnalisés peuvent appeler la méthode à la Add place.

L’opération d’ajout ne lève pas d’exception si le résultat est trop grand pour représenter en tant qu’entier signé dans le processus en cours d’exécution. Au lieu de cela, elle est effectuée dans un contexte non vérifié.

En C# à partir de la version 11 et lors du ciblage du runtime .NET 7 ou ultérieur, cette API est accessible uniquement via la réflexion. L’opérateur d’ajout est directement reconnu par la langue et suit le comportement de langage normal pour les opérations d’ajout, y compris le dépassement dans un checked contexte si le résultat est trop grand pour représenter.

La méthode équivalente pour cet opérateur est IntPtr.Add(IntPtr, Int32)

S’applique à

Voir aussi