IntPtr.Subtract(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

Subtraherar en förskjutning från ett signerat heltal.

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

Parametrar

pointer
IntPtr

nativeint

Det signerade heltal som förskjutningen ska subtraheras från.

offset
Int32

Förskjutningen för att subtrahera.

Returer

IntPtr

nativeint

Ett nytt signerat heltal som återspeglar subtraktionen av offset från pointer.

Exempel

I följande exempel instansierar ett IntPtr objekt som pekar mot slutet av en tioelementsmatris och anropar Subtract sedan metoden för att iterera elementen i matrisen i omvänd ordning.

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};
      // Get the size of a single array element.
      int size = sizeof(int);
      unsafe {
         fixed(int* pend = &arr[arr.GetUpperBound(0)]) {
            IntPtr ptr = new IntPtr(pend);
            for (int ctr = 0; ctr < arr.Length; ctr++)
            {
               IntPtr newPtr = IntPtr.Subtract(ptr, ctr * size);
               Console.Write("{0}   ", Marshal.ReadInt32(newPtr));
            }
         }
      }
   }
}
// The example displays the following output:
//       20   18   16   14   12   10   8   6   4   2

#nowarn "9"
open System
open System.Runtime.InteropServices
open FSharp.NativeInterop

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

    // Get the size of a single array element.
    let size = sizeof<int>

    use pend = fixed &arr[arr.GetUpperBound 0]
    let ptr = NativePtr.toNativeInt pend 
    for i = 0 to arr.Length - 1 do
        let newPtr = IntPtr.Subtract(ptr, i * size)
        printf $"{Marshal.ReadInt32 newPtr}   "
    0

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

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, arr.Length - 1)
      Dim size As Integer = Len(arr(0))

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

Kommentarer

Metoden Subtract utlöser inget undantag om resultatet är för litet för att representeras som ett signerat heltal i körningsprocessen. I stället utförs subtraktionen 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 subtrahera en förskjutning från värdet för en pekare.

Gäller för

Se även