IntPtr.Subtract(IntPtr, Int32) Methode

Referenz

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Subtrahiert einen Offset von einer signierten ganzzahligen Zahl.

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

Parameter

pointer: IntPtr
nativeint

Die signierte ganze Zahl, um den Offset zu subtrahieren.

offset: Int32

Der Offset, der subtrahiert werden soll.

Gibt zurück

IntPtr nativeint

Eine neue signierte ganze Zahl, die die Subtraktion von offset .pointer

Beispiele

Im folgenden Beispiel wird ein IntPtr Objekt instanziiert, das auf das Ende eines Zehn-Element-Arrays verweist, und ruft dann die Methode auf, um die Subtract Elemente im Array in umgekehrter Reihenfolge zu durchlaufen.

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

Hinweise

Die Subtract Methode löst keine Ausnahme aus, wenn das Ergebnis zu klein ist, um als signierte ganze Zahl im Ausführungsprozess darzustellen. Stattdessen wird der Subtraktionsvorgang in einem deaktivierten Kontext ausgeführt.

Sprachen, die keine Operatorüberladung oder benutzerdefinierte Operatoren unterstützen, können diese Methode verwenden, um einen Offset vom Wert eines Zeigers zu subtrahieren.

Gilt für

Siehe auch

Subtraction(IntPtr, Int32)

Freigeben über