Compartir a través de


IntPtr.Addition(IntPtr, Int32) Operador

Definición

Agrega un desplazamiento a 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 al que se va a agregar el desplazamiento.

offset
Int32

Desplazamiento que se va a sumar.

Devoluciones

IntPtr

nativeint

Nuevo entero con signo que refleja la adición de offset a pointer.

Comentarios

El Addition método define la operación de suma 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)
   {
       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

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

La operación de adición no produce una excepción si el resultado es demasiado grande para representar 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 suma y seguirá el comportamiento normal del lenguaje para las operaciones de adición, incluido el desbordamiento en un checked contexto si el resultado es demasiado grande para representar.

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

Se aplica a

Consulte también