IntPtr.Subtraction(IntPtr, Int32) Operador

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Source:

IntPtr.cs

Resta un desplazamiento de un entero con signo.

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

Parámetros

pointer

IntPtr

nativeint

Entero con signo del que se va a restar el desplazamiento.

offset

Int32

Desplazamiento que se va a restar.

Devoluciones

IntPtr

nativeint

Nuevo entero con signo que refleja la resta de offset de pointer.

Comentarios

El Subtraction método define la operación de resta para IntPtr los objetos . Habilita código como el siguiente.

int[] arr = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20};
unsafe {
   fixed(int* parr = &arr[arr.GetUpperBound(0)])
   {
      IntPtr ptr = new IntPtr(parr);
      for (int ctr = 0; ctr <= arr.GetUpperBound(0); ctr++)
      {
         IntPtr newPtr = ptr - ctr * sizeof(Int32);
         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.Runtime.InteropServices
open FSharp.NativeInterop

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

    use parr = fixed &arr[arr.GetUpperBound 0]
    
    let ptr = NativePtr.toNativeInt parr

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

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

Dim arr() As Integer = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20 }
Dim ptr As IntPtr = Marshal.UnsafeAddrOfPinnedArrayElement(arr, arr.GetUpperBound(0))
For ctr As Integer= 0 To arr.GetUpperBound(0)
   Dim newPtr As IntPtr = ptr - ctr * Len(arr(0))
   Console.Write("{0}   ", Marshal.ReadInt32(newPtr))
Next

Los lenguajes que no admiten operadores personalizados pueden llamar al Subtract método en su lugar.

La operación de resta no produce una excepción si el resultado es demasiado pequeño para representarlo como un entero con signo en el proceso de ejecución. En su lugar, se realiza en un contexto no comprobado.

En C# a partir de la versión 11 y al tener como destino el entorno de ejecución de .NET 7 o posterior, esta API solo es accesible a través de reflexión. El lenguaje reconoce directamente el operador de resta y seguirá el comportamiento normal del lenguaje para las operaciones de resta, incluido el desbordamiento en un checked contexto si el resultado es demasiado pequeño para representar.

El método equivalente para este operador es IntPtr.Subtract(IntPtr, Int32)

Consulte también

• Subtract(IntPtr, Int32)