IntPtr.Add(IntPtr, Int32) Metod

Definition

Namnområde:
System
Sammansättningar:
mscorlib.dll, System.Runtime.dll
Sammansättningar:
netstandard.dll, System.Runtime.dll
Sammansättning:
System.Runtime.dll
Sammansättning:
mscorlib.dll
Sammansättning:
netstandard.dll
Källa:
IntPtr.cs
Källa:
IntPtr.cs
Källa:
IntPtr.cs
Källa:
IntPtr.cs
Källa:
IntPtr.cs

Lägger till en förskjutning i ett signerat heltal.

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

Parametrar

pointer
IntPtr

nativeint

Det signerade heltal som förskjutningen ska läggas till i.

offset
Int32

Förskjutningen som ska läggas till.

Returer

IntPtr

nativeint

Ett nytt signerat heltal som återspeglar tillägget av offset till pointer.

Exempel

I följande exempel instansierar ett IntPtr objekt som pekar på början av en tioelementsmatris och anropar Add sedan metoden för att iterera elementen i matrisen.

using System;
using System.Runtime.InteropServices;

public class Example
{
   public static void Main()
   {
      int[] arr = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 };
      unsafe {
         fixed(int* parr = arr) {
            IntPtr ptr = new IntPtr(parr);
            // Get the size of an array element.
            int size = sizeof(int);
            for (int ctr = 0; ctr < arr.Length; ctr++)
            {
               IntPtr newPtr = IntPtr.Add(ptr, ctr * size);
               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
open System.Runtime.InteropServices
open FSharp.NativeInterop

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

    // Get the size of an array element.
    let size = sizeof<int>
    for i = 0 to arr.Length - 1 do
        let newPtr = IntPtr.Add(ptr, i * size)
        printf $"{Marshal.ReadInt32 newPtr}   "
    0

// The example displays the following output:
//       2   4   6   8   10   12   14   16   18   20

Imports System.Runtime.InteropServices

Module Example
   Public Sub Main()
      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 = IntPtr.Add(ptr, ctr * Len(arr(0)))
         Console.Write("{0}   ", Marshal.ReadInt32(newPtr))
      Next
   End Sub
End Module
' The example displays the following output:
'       2   4   6   8   10   12   14   16   18   20

Kommentarer

Metoden Add utlöser inget undantag om resultatet är för stort för att representeras som ett signerat heltal i körningsprocessen. I stället utförs additionsåtgärden i en omarkerad kontext.

Språk som inte stöder överlagring av operatorer eller anpassade operatorer kan använda den här metoden för att lägga till en förskjutning till värdet för en pekare.

Gäller för

Se även