IntPtr Структура

Определение

Представляет целое число со знаком, где битовая ширина совпадает с указателем.

public value class IntPtr
public value class IntPtr : IComparable, IComparable<IntPtr>, IEquatable<IntPtr>, IFormattable, System::Runtime::Serialization::ISerializable
public value class IntPtr : IComparable, IComparable<IntPtr>, IEquatable<IntPtr>, ISpanFormattable, System::Runtime::Serialization::ISerializable
public value class IntPtr : IComparable<IntPtr>, IEquatable<IntPtr>, IParsable<IntPtr>, ISpanParsable<IntPtr>, System::Numerics::IAdditionOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::IAdditiveIdentity<IntPtr, IntPtr>, System::Numerics::IBinaryInteger<IntPtr>, System::Numerics::IBinaryNumber<IntPtr>, System::Numerics::IBitwiseOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::IComparisonOperators<IntPtr, IntPtr, bool>, System::Numerics::IDecrementOperators<IntPtr>, System::Numerics::IDivisionOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::IEqualityOperators<IntPtr, IntPtr, bool>, System::Numerics::IIncrementOperators<IntPtr>, System::Numerics::IMinMaxValue<IntPtr>, System::Numerics::IModulusOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::IMultiplicativeIdentity<IntPtr, IntPtr>, System::Numerics::IMultiplyOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::INumber<IntPtr>, System::Numerics::INumberBase<IntPtr>, System::Numerics::IShiftOperators<IntPtr, int, IntPtr>, System::Numerics::ISignedNumber<IntPtr>, System::Numerics::ISubtractionOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::IUnaryNegationOperators<IntPtr, IntPtr>, System::Numerics::IUnaryPlusOperators<IntPtr, IntPtr>, System::Runtime::Serialization::ISerializable
public value class IntPtr : IComparable<IntPtr>, IEquatable<IntPtr>, IParsable<IntPtr>, ISpanParsable<IntPtr>, IUtf8SpanParsable<IntPtr>, System::Numerics::IAdditionOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::IAdditiveIdentity<IntPtr, IntPtr>, System::Numerics::IBinaryInteger<IntPtr>, System::Numerics::IBinaryNumber<IntPtr>, System::Numerics::IBitwiseOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::IComparisonOperators<IntPtr, IntPtr, bool>, System::Numerics::IDecrementOperators<IntPtr>, System::Numerics::IDivisionOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::IEqualityOperators<IntPtr, IntPtr, bool>, System::Numerics::IIncrementOperators<IntPtr>, System::Numerics::IMinMaxValue<IntPtr>, System::Numerics::IModulusOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::IMultiplicativeIdentity<IntPtr, IntPtr>, System::Numerics::IMultiplyOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::INumber<IntPtr>, System::Numerics::INumberBase<IntPtr>, System::Numerics::IShiftOperators<IntPtr, int, IntPtr>, System::Numerics::ISignedNumber<IntPtr>, System::Numerics::ISubtractionOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::IUnaryNegationOperators<IntPtr, IntPtr>, System::Numerics::IUnaryPlusOperators<IntPtr, IntPtr>, System::Runtime::Serialization::ISerializable
public value class IntPtr : IEquatable<IntPtr>, System::Runtime::Serialization::ISerializable
public value class IntPtr : System::Runtime::Serialization::ISerializable
public struct IntPtr
public readonly struct IntPtr : IComparable, IComparable<IntPtr>, IEquatable<IntPtr>, IFormattable, System.Runtime.Serialization.ISerializable
public readonly struct IntPtr : IComparable, IComparable<IntPtr>, IEquatable<IntPtr>, ISpanFormattable, System.Runtime.Serialization.ISerializable
public readonly struct IntPtr : IComparable<IntPtr>, IEquatable<IntPtr>, IParsable<IntPtr>, ISpanParsable<IntPtr>, System.Numerics.IAdditionOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.IAdditiveIdentity<IntPtr,IntPtr>, System.Numerics.IBinaryInteger<IntPtr>, System.Numerics.IBinaryNumber<IntPtr>, System.Numerics.IBitwiseOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.IComparisonOperators<IntPtr,IntPtr,bool>, System.Numerics.IDecrementOperators<IntPtr>, System.Numerics.IDivisionOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.IEqualityOperators<IntPtr,IntPtr,bool>, System.Numerics.IIncrementOperators<IntPtr>, System.Numerics.IMinMaxValue<IntPtr>, System.Numerics.IModulusOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.IMultiplicativeIdentity<IntPtr,IntPtr>, System.Numerics.IMultiplyOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.INumber<IntPtr>, System.Numerics.INumberBase<IntPtr>, System.Numerics.IShiftOperators<IntPtr,int,IntPtr>, System.Numerics.ISignedNumber<IntPtr>, System.Numerics.ISubtractionOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.IUnaryNegationOperators<IntPtr,IntPtr>, System.Numerics.IUnaryPlusOperators<IntPtr,IntPtr>, System.Runtime.Serialization.ISerializable
public readonly struct IntPtr : IComparable<IntPtr>, IEquatable<IntPtr>, IParsable<IntPtr>, ISpanParsable<IntPtr>, IUtf8SpanParsable<IntPtr>, System.Numerics.IAdditionOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.IAdditiveIdentity<IntPtr,IntPtr>, System.Numerics.IBinaryInteger<IntPtr>, System.Numerics.IBinaryNumber<IntPtr>, System.Numerics.IBitwiseOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.IComparisonOperators<IntPtr,IntPtr,bool>, System.Numerics.IDecrementOperators<IntPtr>, System.Numerics.IDivisionOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.IEqualityOperators<IntPtr,IntPtr,bool>, System.Numerics.IIncrementOperators<IntPtr>, System.Numerics.IMinMaxValue<IntPtr>, System.Numerics.IModulusOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.IMultiplicativeIdentity<IntPtr,IntPtr>, System.Numerics.IMultiplyOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.INumber<IntPtr>, System.Numerics.INumberBase<IntPtr>, System.Numerics.IShiftOperators<IntPtr,int,IntPtr>, System.Numerics.ISignedNumber<IntPtr>, System.Numerics.ISubtractionOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.IUnaryNegationOperators<IntPtr,IntPtr>, System.Numerics.IUnaryPlusOperators<IntPtr,IntPtr>, System.Runtime.Serialization.ISerializable
public struct IntPtr : IEquatable<IntPtr>, System.Runtime.Serialization.ISerializable
public readonly struct IntPtr : IEquatable<IntPtr>, System.Runtime.Serialization.ISerializable
[System.Serializable]
public struct IntPtr : System.Runtime.Serialization.ISerializable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct IntPtr : System.Runtime.Serialization.ISerializable
public struct IntPtr : System.Runtime.Serialization.ISerializable
type nativeint = struct
type nativeint = struct
    interface IFormattable
    interface ISerializable
type nativeint = struct
    interface ISpanFormattable
    interface IFormattable
    interface ISerializable
type nativeint = struct
    interface IFormattable
    interface IParsable<nativeint>
    interface ISpanFormattable
    interface ISpanParsable<nativeint>
    interface IAdditionOperators<nativeint, nativeint, nativeint>
    interface IAdditiveIdentity<nativeint, nativeint>
    interface IBinaryInteger<nativeint>
    interface IBinaryNumber<nativeint>
    interface IBitwiseOperators<nativeint, nativeint, nativeint>
    interface IComparisonOperators<nativeint, nativeint, bool>
    interface IEqualityOperators<nativeint, nativeint, bool>
    interface IDecrementOperators<nativeint>
    interface IDivisionOperators<nativeint, nativeint, nativeint>
    interface IIncrementOperators<nativeint>
    interface IModulusOperators<nativeint, nativeint, nativeint>
    interface IMultiplicativeIdentity<nativeint, nativeint>
    interface IMultiplyOperators<nativeint, nativeint, nativeint>
    interface INumber<nativeint>
    interface INumberBase<nativeint>
    interface ISubtractionOperators<nativeint, nativeint, nativeint>
    interface IUnaryNegationOperators<nativeint, nativeint>
    interface IUnaryPlusOperators<nativeint, nativeint>
    interface IShiftOperators<nativeint, int, nativeint>
    interface IMinMaxValue<nativeint>
    interface ISignedNumber<nativeint>
    interface ISerializable
type nativeint = struct
    interface IFormattable
    interface IParsable<nativeint>
    interface ISpanFormattable
    interface ISpanParsable<nativeint>
    interface IAdditionOperators<nativeint, nativeint, nativeint>
    interface IAdditiveIdentity<nativeint, nativeint>
    interface IBinaryInteger<nativeint>
    interface IBinaryNumber<nativeint>
    interface IBitwiseOperators<nativeint, nativeint, nativeint>
    interface IComparisonOperators<nativeint, nativeint, bool>
    interface IEqualityOperators<nativeint, nativeint, bool>
    interface IDecrementOperators<nativeint>
    interface IDivisionOperators<nativeint, nativeint, nativeint>
    interface IIncrementOperators<nativeint>
    interface IModulusOperators<nativeint, nativeint, nativeint>
    interface IMultiplicativeIdentity<nativeint, nativeint>
    interface IMultiplyOperators<nativeint, nativeint, nativeint>
    interface INumber<nativeint>
    interface INumberBase<nativeint>
    interface ISubtractionOperators<nativeint, nativeint, nativeint>
    interface IUnaryNegationOperators<nativeint, nativeint>
    interface IUnaryPlusOperators<nativeint, nativeint>
    interface IUtf8SpanFormattable
    interface IUtf8SpanParsable<nativeint>
    interface IShiftOperators<nativeint, int, nativeint>
    interface IMinMaxValue<nativeint>
    interface ISignedNumber<nativeint>
    interface ISerializable
type nativeint = struct
    interface IFormattable
    interface IParsable<nativeint>
    interface ISpanFormattable
    interface ISpanParsable<nativeint>
    interface IUtf8SpanFormattable
    interface IUtf8SpanParsable<nativeint>
    interface IAdditionOperators<nativeint, nativeint, nativeint>
    interface IAdditiveIdentity<nativeint, nativeint>
    interface IBinaryInteger<nativeint>
    interface IBinaryNumber<nativeint>
    interface IBitwiseOperators<nativeint, nativeint, nativeint>
    interface IComparisonOperators<nativeint, nativeint, bool>
    interface IEqualityOperators<nativeint, nativeint, bool>
    interface IDecrementOperators<nativeint>
    interface IDivisionOperators<nativeint, nativeint, nativeint>
    interface IIncrementOperators<nativeint>
    interface IModulusOperators<nativeint, nativeint, nativeint>
    interface IMultiplicativeIdentity<nativeint, nativeint>
    interface IMultiplyOperators<nativeint, nativeint, nativeint>
    interface INumber<nativeint>
    interface INumberBase<nativeint>
    interface ISubtractionOperators<nativeint, nativeint, nativeint>
    interface IUnaryNegationOperators<nativeint, nativeint>
    interface IUnaryPlusOperators<nativeint, nativeint>
    interface IShiftOperators<nativeint, int, nativeint>
    interface IMinMaxValue<nativeint>
    interface ISignedNumber<nativeint>
    interface ISerializable
type nativeint = struct
    interface ISerializable
[<System.Serializable>]
type nativeint = struct
    interface ISerializable
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type nativeint = struct
    interface ISerializable
Public Structure IntPtr
Public Structure IntPtr
Implements IComparable, IComparable(Of IntPtr), IEquatable(Of IntPtr), IFormattable, ISerializable
Public Structure IntPtr
Implements IComparable, IComparable(Of IntPtr), IEquatable(Of IntPtr), ISerializable, ISpanFormattable
Public Structure IntPtr
Implements IAdditionOperators(Of IntPtr, IntPtr, IntPtr), IAdditiveIdentity(Of IntPtr, IntPtr), IBinaryInteger(Of IntPtr), IBinaryNumber(Of IntPtr), IBitwiseOperators(Of IntPtr, IntPtr, IntPtr), IComparable(Of IntPtr), IComparisonOperators(Of IntPtr, IntPtr, Boolean), IDecrementOperators(Of IntPtr), IDivisionOperators(Of IntPtr, IntPtr, IntPtr), IEqualityOperators(Of IntPtr, IntPtr, Boolean), IEquatable(Of IntPtr), IIncrementOperators(Of IntPtr), IMinMaxValue(Of IntPtr), IModulusOperators(Of IntPtr, IntPtr, IntPtr), IMultiplicativeIdentity(Of IntPtr, IntPtr), IMultiplyOperators(Of IntPtr, IntPtr, IntPtr), INumber(Of IntPtr), INumberBase(Of IntPtr), IParsable(Of IntPtr), ISerializable, IShiftOperators(Of IntPtr, Integer, IntPtr), ISignedNumber(Of IntPtr), ISpanParsable(Of IntPtr), ISubtractionOperators(Of IntPtr, IntPtr, IntPtr), IUnaryNegationOperators(Of IntPtr, IntPtr), IUnaryPlusOperators(Of IntPtr, IntPtr)
Public Structure IntPtr
Implements IAdditionOperators(Of IntPtr, IntPtr, IntPtr), IAdditiveIdentity(Of IntPtr, IntPtr), IBinaryInteger(Of IntPtr), IBinaryNumber(Of IntPtr), IBitwiseOperators(Of IntPtr, IntPtr, IntPtr), IComparable(Of IntPtr), IComparisonOperators(Of IntPtr, IntPtr, Boolean), IDecrementOperators(Of IntPtr), IDivisionOperators(Of IntPtr, IntPtr, IntPtr), IEqualityOperators(Of IntPtr, IntPtr, Boolean), IEquatable(Of IntPtr), IIncrementOperators(Of IntPtr), IMinMaxValue(Of IntPtr), IModulusOperators(Of IntPtr, IntPtr, IntPtr), IMultiplicativeIdentity(Of IntPtr, IntPtr), IMultiplyOperators(Of IntPtr, IntPtr, IntPtr), INumber(Of IntPtr), INumberBase(Of IntPtr), IParsable(Of IntPtr), ISerializable, IShiftOperators(Of IntPtr, Integer, IntPtr), ISignedNumber(Of IntPtr), ISpanParsable(Of IntPtr), ISubtractionOperators(Of IntPtr, IntPtr, IntPtr), IUnaryNegationOperators(Of IntPtr, IntPtr), IUnaryPlusOperators(Of IntPtr, IntPtr), IUtf8SpanParsable(Of IntPtr)
Public Structure IntPtr
Implements IEquatable(Of IntPtr), ISerializable
Public Structure IntPtr
Implements ISerializable
Наследование
IntPtr
Атрибуты
Реализации
IComparable IComparable<IntPtr> IEquatable<IntPtr> IFormattable ISerializable ISpanFormattable IComparable<TSelf> IEquatable<TSelf> IParsable<IntPtr> IParsable<TSelf> ISpanParsable<IntPtr> ISpanParsable<TSelf> IAdditionOperators<IntPtr,IntPtr,IntPtr> IAdditionOperators<TSelf,TSelf,TSelf> IAdditiveIdentity<IntPtr,IntPtr> IAdditiveIdentity<TSelf,TSelf> IBinaryInteger<IntPtr> IBinaryNumber<IntPtr> IBinaryNumber<TSelf> IBitwiseOperators<IntPtr,IntPtr,IntPtr> IBitwiseOperators<TSelf,TSelf,TSelf> IComparisonOperators<IntPtr,IntPtr,Boolean> IComparisonOperators<TSelf,TSelf,Boolean> IDecrementOperators<IntPtr> IDecrementOperators<TSelf> IDivisionOperators<IntPtr,IntPtr,IntPtr> IDivisionOperators<TSelf,TSelf,TSelf> IEqualityOperators<IntPtr,IntPtr,Boolean> IEqualityOperators<TSelf,TOther,TResult> IEqualityOperators<TSelf,TSelf,Boolean> IIncrementOperators<IntPtr> IIncrementOperators<TSelf> IMinMaxValue<IntPtr> IModulusOperators<IntPtr,IntPtr,IntPtr> IModulusOperators<TSelf,TSelf,TSelf> IMultiplicativeIdentity<IntPtr,IntPtr> IMultiplicativeIdentity<TSelf,TSelf> IMultiplyOperators<IntPtr,IntPtr,IntPtr> IMultiplyOperators<TSelf,TSelf,TSelf> INumber<IntPtr> INumber<TSelf> INumberBase<IntPtr> INumberBase<TSelf> IShiftOperators<IntPtr,Int32,IntPtr> IShiftOperators<TSelf,Int32,TSelf> ISignedNumber<IntPtr> ISubtractionOperators<IntPtr,IntPtr,IntPtr> ISubtractionOperators<TSelf,TSelf,TSelf> IUnaryNegationOperators<IntPtr,IntPtr> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<IntPtr,IntPtr> IUnaryPlusOperators<TSelf,TSelf> IUtf8SpanFormattable IUtf8SpanParsable<IntPtr> IUtf8SpanParsable<TSelf>

Примеры

В следующем примере управляемые указатели используются для изменения символов в массиве. После инициализации String объекта и его длины он выполняет следующие действия:

  1. Вызывает метод для копирования Marshal.StringToHGlobalAnsi строки Юникода в неуправляемую память в виде однобайтового символа ANSI. Метод возвращает IntPtr объект , указывающий на начало неуправляемой строки. В примере Visual Basic этот указатель используется напрямую; В примерах C++, F# и C# он приводится к указателю на байт.

  2. Вызывает метод для Marshal.AllocHGlobal выделения того же количества байтов, что и неуправляемая строка. Метод возвращает IntPtr объект , указывающий на начало неуправляемого блока памяти. В примере Visual Basic этот указатель используется напрямую; В примерах C++, F# и C# он приводится к указателю на байт.

  3. В примере Visual Basic определяется переменная с именем offset , равная длине строки ANSI. Он используется для определения смещения в неуправляемой памяти, в которую копируется следующий символ в строке ANSI. Поскольку его начальное значение — это длина строки, операция копирования копирует символ от начала строки до конца блока памяти.

    В примерах C#, F# и C++ метод вызывается ToPointer , чтобы получить неуправляемый указатель на начальный адрес строки и неуправляемый блок памяти. Они добавляют один указатель меньше длины строки в начальный адрес строки ANSI. Так как указатель неуправляемой строки теперь указывает на конец строки, операция копирования скопирует символ из конца строки в начало блока памяти.

  4. Использует цикл для копирования каждого символа из строки в неуправляемый блок памяти.

    В примере Visual Basic вызывается Marshal.ReadByte(IntPtr, Int32) метод для считывания байта (или однобайтового символа) с указанным смещением от управляемого указателя к строке ANSI. Смещение увеличивается с каждой итерацией цикла. Затем он вызывает Marshal.WriteByte(IntPtr, Int32, Byte) метод для записи байта в адрес памяти, определенный начальным адресом неуправляемого блока памяти плюс offset. Затем он уменьшает .offset

    В примерах C#, F# и C++ выполняется операция копирования, затем уменьшается указатель на адрес следующего расположения в неуправляемой строке ANSI и увеличивается указатель на следующий адрес в неуправляемом блоке.

  5. Все примеры вызывают Marshal.PtrToStringAnsi для преобразования неуправляемого блока памяти, содержащего скопированную строку ANSI, в управляемый объект Юникода String .

  6. После отображения исходных и обратных строк все примеры вызывают FreeHGlobal метод , чтобы освободить память, выделенную для неуправляемой строки ANSI и неуправляемого блока памяти.

using namespace System;
using namespace System::Runtime::InteropServices;

class NotTooSafeStringReverse
{
public:
    static void Main()
    {
        String^ stringA = "I seem to be turned around!";
        int copylen = stringA->Length;

        // Allocate HGlobal memory for source and destination strings
        IntPtr sptr = Marshal::StringToHGlobalAnsi(stringA);
        IntPtr dptr = Marshal::AllocHGlobal(copylen + 1);

        char *src = (char *)sptr.ToPointer();
        char *dst = (char *)dptr.ToPointer();

        if (copylen > 0)
        {
            // set the source pointer to the end of the string
            // to do a reverse copy.
            src += copylen - 1;

            while (copylen-- > 0)
            {
                *dst++ = *src--;
            }
            *dst = 0;
        }
        String^ stringB = Marshal::PtrToStringAnsi(dptr);

        Console::WriteLine("Original:\n{0}\n", stringA);
        Console::WriteLine("Reversed:\n{0}", stringB);

        // Free HGlobal memory
        Marshal::FreeHGlobal(dptr);
        Marshal::FreeHGlobal(sptr);
    }
};

int main()
{
    NotTooSafeStringReverse::Main();
}

// The progam has the following output:
//
// Original:
// I seem to be turned around!
//
// Reversed:
// !dnuora denrut eb ot mees I
using System;
using System.Runtime.InteropServices;

class NotTooSafeStringReverse
{
    static public void Main()
    {
        string stringA = "I seem to be turned around!";
        int copylen = stringA.Length;

        // Allocate HGlobal memory for source and destination strings
        IntPtr sptr = Marshal.StringToHGlobalAnsi(stringA);
        IntPtr dptr = Marshal.AllocHGlobal(copylen + 1);

        // The unsafe section where byte pointers are used.
        unsafe
        {
            byte *src = (byte *)sptr.ToPointer();
            byte *dst = (byte *)dptr.ToPointer();

            if (copylen > 0)
            {
                // set the source pointer to the end of the string
                // to do a reverse copy.
                src += copylen - 1;

                while (copylen-- > 0)
                {
                    *dst++ = *src--;
                }
                *dst = 0;
            }
        }
        string stringB = Marshal.PtrToStringAnsi(dptr);

        Console.WriteLine("Original:\n{0}\n", stringA);
        Console.WriteLine("Reversed:\n{0}", stringB);

        // Free HGlobal memory
        Marshal.FreeHGlobal(dptr);
        Marshal.FreeHGlobal(sptr);
    }
}

// The progam has the following output:
//
// Original:
// I seem to be turned around!
//
// Reversed:
// !dnuora denrut eb ot mees I
#nowarn "9"
open System.Runtime.InteropServices
open FSharp.NativeInterop

[<EntryPoint>]
let main _ = 
    let stringA = "I seem to be turned around!"
    let mutable copylen = stringA.Length

    // Allocate HGlobal memory for source and destination strings
    let sptr = Marshal.StringToHGlobalAnsi stringA
    let dptr = Marshal.AllocHGlobal(copylen + 1)

    let mutable src: byte nativeptr = sptr.ToPointer() |> NativePtr.ofVoidPtr
    let mutable dst: byte nativeptr = dptr.ToPointer() |> NativePtr.ofVoidPtr

    if copylen > 0 then
        // set the source pointer to the end of the string
        // to do a reverse copy.
        src <- 
            NativePtr.toNativeInt src + nativeint (copylen - 1) 
            |> NativePtr.ofNativeInt

        while copylen > 0 do
            copylen <- copylen - 1
            NativePtr.read src |> NativePtr.write dst
            dst <- NativePtr.toNativeInt dst + 1n |> NativePtr.ofNativeInt
            src <- NativePtr.toNativeInt src - 1n |> NativePtr.ofNativeInt
        NativePtr.write dst 0uy

    let stringB = Marshal.PtrToStringAnsi dptr

    printfn $"Original:\n{stringA}\n"
    printfn $"Reversed:\n{stringB}"

    // Free HGlobal memory
    Marshal.FreeHGlobal dptr
    Marshal.FreeHGlobal sptr
    0

// The progam has the following output:
//
// Original:
// I seem to be turned around!
//
// Reversed:
// !dnuora denrut eb ot mees I
Imports System.Runtime.InteropServices

Public Module Example
    Public Sub Main()
        Dim stringA As String = "I seem to be turned around!"
        Dim copylen As Integer = stringA.Length

        ' Allocate HGlobal memory for source and destination strings
        Dim sptr As IntPtr = Marshal.StringToHGlobalAnsi(stringA)
        Dim dptr As IntPtr = Marshal.AllocHGlobal(copylen)
        Dim offset As Integer = copylen - 1

         For ctr As Integer = 0 To copylen - 1
            Dim b As Byte = Marshal.ReadByte(sptr, ctr)
            Marshal.WriteByte(dptr, offset, b)
            offset -= 1
         Next

        Dim stringB As String = Marshal.PtrToStringAnsi(dptr)

        Console.WriteLine("Original:{1}{0}{1}", stringA, vbCrLf)
        Console.WriteLine("Reversed:{1}{0}{1}", stringB, vbCrLf)

        ' Free HGlobal memory
        Marshal.FreeHGlobal(dptr)
        Marshal.FreeHGlobal(sptr)
    End Sub
End Module
' The example displays the following output:
'       Original:
'       I seem to be turned around!
'
'       Reversed:
'       !dnuora denrut eb ot mees I

Комментарии

Тип IntPtr предназначен для целого числа, размер которого совпадает с размером указателя. То есть экземпляр этого типа должен быть 32-разрядным в 32-разрядном процессе и 64 битом в 64-разрядном процессе.

Тип IntPtr может использоваться языками, поддерживающими указатели, и в качестве общего средства ссылки на данные между языками, которые поддерживают и не поддерживают указатели.

IntPtr Объекты также можно использовать для хранения дескрипторов. Например, экземпляры IntPtr широко используются в System.IO.FileStream классе для хранения дескрипторов файлов.

Примечание

Использование IntPtr в качестве указателя или дескриптора подвержено ошибкам и небезопасно. Это просто целочисленный тип, который можно использовать в качестве формата обмена для указателей и дескрипторов из-за одного размера. Помимо конкретных требований к обмену, например для передачи данных на язык, который не поддерживает указатели, для представления указателей следует использовать правильно типизированный указатель, а SafeHandle также для представления дескрипторов.

Этот тип реализует ISerializable. В .NET 5 и более поздних версиях этот тип также реализует IFormattable интерфейсы . В .NET 7 и более поздних версиях этот тип также реализует интерфейсы IBinaryInteger<TSelf>, IMinMaxValue<TSelf>и ISignedNumber<TSelf> .

В C# начиная с версии 9.0 можно использовать встроенный nint тип для определения целых чисел собственного размера. Этот тип представлен внутренним типом IntPtr и обеспечивает операции и преобразования, подходящие для целочисленных типов. Дополнительные сведения см. в разделе Типы nint и nuint.

В C# начиная с версии 11 и при использовании среды выполнения .NET 7 или более поздней версии является псевдонимом для IntPtr так же, nint как int и псевдонимом для Int32.

Конструкторы

IntPtr(Int32)

Инициализирует новый экземпляр , IntPtr используя указанное 32-разрядное целое число со знаком.

IntPtr(Int64)

Инициализирует новый экземпляр , IntPtr используя указанное 64-разрядное целое число со знаком.

IntPtr(Void*)

Инициализирует новый экземпляр структуры IntPtr с использованием заданного указателя на незаданный тип.

Поля

Zero

Доступное только для чтения поле, представляющее целое число со знаком, инициализированное нулевым значением.

Свойства

MaxValue

Возвращает максимально возможное значение .IntPtr

MinValue

Возвращает наименьшее возможное значение .IntPtr

Size

Получает размер этого экземпляра.

Методы

Abs(IntPtr)

Вычисляет абсолютное значение.

Add(IntPtr, Int32)

Добавляет смещение в целое число со знаком.

Clamp(IntPtr, IntPtr, IntPtr)

Зажимает значение до минимального и максимального значений включительно.

CompareTo(IntPtr)

Сравнивает текущий экземпляр с другим объектом того же типа и возвращает целое число, которое показывает, расположен ли текущий экземпляр перед, после или на той же позиции в порядке сортировки, что и другой объект.

CompareTo(Object)

Сравнивает текущий экземпляр с другим объектом того же типа и возвращает целое число, которое показывает, расположен ли текущий экземпляр перед, после или на той же позиции в порядке сортировки, что и другой объект.

CopySign(IntPtr, IntPtr)

Копирует знак значения в знак другого значения.

CreateChecked<TOther>(TOther)

Создает экземпляр текущего типа из значения, вызывая исключение переполнения для всех значений, которые выходят за пределы диапазона, представляющего текущий тип.

CreateSaturating<TOther>(TOther)

Создает экземпляр текущего типа из значения, насыщая все значения, которые выходят за пределы представляемого диапазона текущего типа.

CreateTruncating<TOther>(TOther)

Создает экземпляр текущего типа из значения, усекая все значения, которые выходят за пределы представляемого диапазона текущего типа.

DivRem(IntPtr, IntPtr)

Вычисляет частное и оставшееся число двух значений.

Equals(IntPtr)

Указывает, равен ли текущий объект другому объекту того же типа.

Equals(Object)

Возвращает значение, показывающее, равен ли данный экземпляр заданному объекту.

GetHashCode()

Возвращает хэш-код данного экземпляра.

IsEvenInteger(IntPtr)

Определяет, представляет ли значение четное целое число.

IsNegative(IntPtr)

Определяет, является ли значение отрицательным.

IsOddInteger(IntPtr)

Определяет, представляет ли значение нечетное целое число.

IsPositive(IntPtr)

Определяет, является ли значение положительным.

IsPow2(IntPtr)

Определяет, является ли значение степенью 2.

LeadingZeroCount(IntPtr)

Вычисляет число начальных нулей в значении.

Log2(IntPtr)

Вычисляет значение log2.

Max(IntPtr, IntPtr)

Сравнивает два значения, чтобы вычислить большее значение.

MaxMagnitude(IntPtr, IntPtr)

Сравнивает два значения, чтобы вычислить большее значение.

Min(IntPtr, IntPtr)

Сравнивает два значения для вычисления меньшего значения.

MinMagnitude(IntPtr, IntPtr)

Сравнивает два значения для вычисления меньшего значения.

Parse(ReadOnlySpan<Byte>, IFormatProvider)

Анализирует диапазон символов UTF-8 в значение.

Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)

Анализирует диапазон символов UTF-8 в значение.

Parse(ReadOnlySpan<Char>, IFormatProvider)

Анализирует диапазон символов в значение.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Преобразует доступное только для чтения представление символов числа в указанном стиле и формате, зависят от языка и региональных параметров, в эквивалентное ей собственное целое число со знаком.

Parse(String)

Преобразует строковое представление числа в эквивалентное ему собственное целое число со знаком.

Parse(String, IFormatProvider)

Преобразует строковое представление числа в формате, зависящем от языка и региональных параметров, в эквивалентное ему собственное целое число со знаком.

Parse(String, NumberStyles)

Преобразует строковое представление числа в указанном стиле в эквивалентное ему собственное целое число со знаком.

Parse(String, NumberStyles, IFormatProvider)

Преобразует строковое представление числа в указанном стиле и формате, зависящем от языка и региональных параметров, в эквивалентное ему собственное целое число со знаком.

PopCount(IntPtr)

Вычисляет количество битов, заданных в значении .

RotateLeft(IntPtr, Int32)

Поворачивает значение влево на заданную величину.

RotateRight(IntPtr, Int32)

Поворачивает значение вправо на заданную величину.

Sign(IntPtr)

Вычисляет знак значения.

Subtract(IntPtr, Int32)

Вычитает смещение из целого числа со знаком.

ToInt32()

Преобразует значение этого экземпляра в формат 32-разрядного целого числа со знаком.

ToInt64()

Преобразует значение этого экземпляра в формат 64-разрядного целого числа со знаком.

ToPointer()

Преобразует значение этого экземпляра в указатель незаданного типа.

ToString()

Преобразует числовое значение текущего объекта IntPtr в эквивалентное ему строковое представление.

ToString(IFormatProvider)

Преобразует числовое значение данного экземпляра в эквивалентное ему строковое представление с использованием указанного формата и сведений об особенностях форматирования для данного языка и региональных параметров.

ToString(String)

Преобразует числовое значение текущего объекта IntPtr в эквивалентное ему строковое представление.

ToString(String, IFormatProvider)

Форматирует значение текущего экземпляра, используя указанный формат.

TrailingZeroCount(IntPtr)

Вычисляет число конечных нулей в значении.

TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Пытается отформатировать значение текущего экземпляра как UTF-8 в предоставленный диапазон байтов.

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Пытается отформатировать значение текущего экземпляра в указанный диапазон символов.

TryParse(ReadOnlySpan<Byte>, IFormatProvider, IntPtr)

Пытается проанализировать диапазон символов UTF-8 в значение.

TryParse(ReadOnlySpan<Byte>, IntPtr)

Пытается преобразовать диапазон символов UTF-8, содержащий строковое представление числа, в эквивалентное ей целое число со знаком.

TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, IntPtr)

Пытается проанализировать диапазон символов UTF-8 в значение.

TryParse(ReadOnlySpan<Char>, IFormatProvider, IntPtr)

Пытается проанализировать строку в значение.

TryParse(ReadOnlySpan<Char>, IntPtr)

Преобразует доступное только для чтения представление символов числа в эквивалентное ей собственное целое число со знаком. Возвращает значение, указывающее, успешно ли выполнено преобразование.

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, IntPtr)

Преобразует доступное только для чтения представление символов числа в указанном стиле и формате, зависят от языка и региональных параметров, в эквивалентное ей собственное целое число со знаком. Возвращает значение, указывающее, успешно ли выполнено преобразование.

TryParse(String, IFormatProvider, IntPtr)

Пытается проанализировать строку в значение.

TryParse(String, IntPtr)

Преобразует строковое представление числа в эквивалентное ему собственное целое число со знаком. Возвращает значение, указывающее, успешно ли выполнено преобразование.

TryParse(String, NumberStyles, IFormatProvider, IntPtr)

Преобразует строковое представление числа в указанном стиле и формате, зависящем от языка и региональных параметров, в эквивалентное ему собственное целое число со знаком. Возвращает значение, указывающее, успешно ли выполнено преобразование.

Операторы

Addition(IntPtr, Int32)

Добавляет смещение в целое число со знаком.

Equality(IntPtr, IntPtr)

Определяет, равны ли два заданных экземпляра класса IntPtr.

Explicit(Int32 to IntPtr)

Преобразует 32-разрядное целочисленное значение со знаком в IntPtr.

Explicit(Int64 to IntPtr)

Преобразует 64-разрядное целочисленное значение со знаком в IntPtr.

Explicit(IntPtr to Int32)

Преобразует значение заданной структуры IntPtr в формат 32-разрядного целого числа со знаком.

Explicit(IntPtr to Int64)

Преобразует значение заданной структуры IntPtr в формат 64-разрядного целого числа со знаком.

Explicit(IntPtr to Void*)

Преобразует значение заданной структуры IntPtr в указатель на незаданный тип.

Этот интерфейс API CLS-несовместим.

Explicit(Void* to IntPtr)

Преобразует заданный указатель на незаданный тип в IntPtr.

Этот интерфейс API CLS-несовместим.

Inequality(IntPtr, IntPtr)

Определяет, являются ли два заданных экземпляра класса IntPtr неравными.

Subtraction(IntPtr, Int32)

Вычитает смещение из целого числа со знаком.

Явные реализации интерфейса

IAdditionOperators<IntPtr,IntPtr,IntPtr>.Addition(IntPtr, IntPtr)

Добавляет два значения вместе для вычисления их суммы.

IAdditionOperators<IntPtr,IntPtr,IntPtr>.CheckedAddition(IntPtr, IntPtr)

Добавляет два значения вместе для вычисления их суммы.

IAdditiveIdentity<IntPtr,IntPtr>.AdditiveIdentity

Возвращает аддитивное удостоверение текущего типа.

IBinaryInteger<IntPtr>.GetByteCount()

Возвращает количество байтов, которые будут записаны в составе TryWriteLittleEndian(Span<Byte>, Int32).

IBinaryInteger<IntPtr>.GetShortestBitLength()

Возвращает длину (в битах) представления текущего значения в дополнение к кратчайшему двум.

IBinaryInteger<IntPtr>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, IntPtr)

Представляет целое число со знаком, где битовая ширина совпадает с указателем.

IBinaryInteger<IntPtr>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, IntPtr)

Представляет целое число со знаком, где битовая ширина совпадает с указателем.

IBinaryInteger<IntPtr>.TryWriteBigEndian(Span<Byte>, Int32)

Пытается записать текущее значение в формате big-endian в заданный диапазон.

IBinaryInteger<IntPtr>.TryWriteLittleEndian(Span<Byte>, Int32)

Пытается записать текущее значение в малобайтовом формате в заданный диапазон.

IBinaryNumber<IntPtr>.AllBitsSet

Возвращает экземпляр двоичного типа, в котором заданы все биты.

IBitwiseOperators<IntPtr,IntPtr,IntPtr>.BitwiseAnd(IntPtr, IntPtr)

Вычисляет побитовое и двух значений.

IBitwiseOperators<IntPtr,IntPtr,IntPtr>.BitwiseOr(IntPtr, IntPtr)

Вычисляет побитовое значение или из двух значений.

IBitwiseOperators<IntPtr,IntPtr,IntPtr>.ExclusiveOr(IntPtr, IntPtr)

Вычисляет исключающее значение или из двух значений.

IBitwiseOperators<IntPtr,IntPtr,IntPtr>.OnesComplement(IntPtr)

Вычисляет представление с дополнением к единицам заданного значения.

IComparisonOperators<IntPtr,IntPtr,Boolean>.GreaterThan(IntPtr, IntPtr)

Сравнивает два значения, чтобы определить, какое значение больше.

IComparisonOperators<IntPtr,IntPtr,Boolean>.GreaterThanOrEqual(IntPtr, IntPtr)

Сравнивает два значения, чтобы определить, какое значение больше или равно.

IComparisonOperators<IntPtr,IntPtr,Boolean>.LessThan(IntPtr, IntPtr)

Сравнивает два значения, чтобы определить, какое значение меньше.

IComparisonOperators<IntPtr,IntPtr,Boolean>.LessThanOrEqual(IntPtr, IntPtr)

Сравнивает два значения, чтобы определить, какое значение меньше или равно.

IDecrementOperators<IntPtr>.CheckedDecrement(IntPtr)

Уменьшает значение.

IDecrementOperators<IntPtr>.Decrement(IntPtr)

Уменьшает значение.

IDivisionOperators<IntPtr,IntPtr,IntPtr>.Division(IntPtr, IntPtr)

Делит одно значение на другое для вычисления их частного значения.

IEquatable<IntPtr>.Equals(IntPtr)

Возвращает значение, указывающее, равен ли этот экземпляр другому целому значению со знаком.

IIncrementOperators<IntPtr>.CheckedIncrement(IntPtr)

Увеличивает значение.

IIncrementOperators<IntPtr>.Increment(IntPtr)

Увеличивает значение.

IMinMaxValue<IntPtr>.MaxValue

Возвращает максимальное значение текущего типа.

IMinMaxValue<IntPtr>.MinValue

Возвращает минимальное значение текущего типа.

IModulusOperators<IntPtr,IntPtr,IntPtr>.Modulus(IntPtr, IntPtr)

Делит два значения для вычисления их модуля или остатка.

IMultiplicativeIdentity<IntPtr,IntPtr>.MultiplicativeIdentity

Возвращает мультипликативное удостоверение текущего типа.

IMultiplyOperators<IntPtr,IntPtr,IntPtr>.CheckedMultiply(IntPtr, IntPtr)

Умножает два значения вместе для вычисления их продукта.

IMultiplyOperators<IntPtr,IntPtr,IntPtr>.Multiply(IntPtr, IntPtr)

Умножает два значения вместе для вычисления их продукта.

INumber<IntPtr>.MaxNumber(IntPtr, IntPtr)

Сравнивает два значения для вычисления, которое больше, и возвращает другое значение, если входные данные имеют значение NaN.

INumber<IntPtr>.MinNumber(IntPtr, IntPtr)

Сравнивает два значения для вычисления меньшего значения и возвращает другое значение, если входные данные имеют значение NaN.

INumberBase<IntPtr>.IsCanonical(IntPtr)

Определяет, находится ли значение в своем каноническом представлении.

INumberBase<IntPtr>.IsComplexNumber(IntPtr)

Определяет, представляет ли значение комплексное число.

INumberBase<IntPtr>.IsFinite(IntPtr)

Определяет, является ли значение конечным.

INumberBase<IntPtr>.IsImaginaryNumber(IntPtr)

Определяет, представляет ли значение чистое мнимое число.

INumberBase<IntPtr>.IsInfinity(IntPtr)

Определяет, является ли значение бесконечным.

INumberBase<IntPtr>.IsInteger(IntPtr)

Определяет, представляет ли значение целое число.

INumberBase<IntPtr>.IsNaN(IntPtr)

Определяет, является ли значение NaN.

INumberBase<IntPtr>.IsNegativeInfinity(IntPtr)

Определяет, является ли значение отрицательным бесконечностью.

INumberBase<IntPtr>.IsNormal(IntPtr)

Определяет, является ли значение нормальным.

INumberBase<IntPtr>.IsPositiveInfinity(IntPtr)

Определяет, является ли значение положительным бесконечностью.

INumberBase<IntPtr>.IsRealNumber(IntPtr)

Определяет, представляет ли значение реальное число.

INumberBase<IntPtr>.IsSubnormal(IntPtr)

Определяет, является ли значение субнормальным.

INumberBase<IntPtr>.IsZero(IntPtr)

Определяет, равно ли значение нулю.

INumberBase<IntPtr>.MaxMagnitudeNumber(IntPtr, IntPtr)

Сравнивает два значения для вычисления, которое имеет большую величину, и возвращает другое значение, если входные данные имеют значение NaN.

INumberBase<IntPtr>.MinMagnitudeNumber(IntPtr, IntPtr)

Сравнивает два значения для вычисления, которое имеет меньшую величину, и возвращает другое значение, если входные данные имеют значение NaN.

INumberBase<IntPtr>.One

Возвращает значение 1 для типа.

INumberBase<IntPtr>.Radix

Возвращает основание для типа.

INumberBase<IntPtr>.TryConvertFromChecked<TOther>(TOther, IntPtr)

Представляет целое число со знаком, где битовая ширина совпадает с указателем.

INumberBase<IntPtr>.TryConvertFromSaturating<TOther>(TOther, IntPtr)

Представляет целое число со знаком, где битовая ширина совпадает с указателем.

INumberBase<IntPtr>.TryConvertFromTruncating<TOther>(TOther, IntPtr)

Представляет целое число со знаком, где битовая ширина совпадает с указателем.

INumberBase<IntPtr>.TryConvertToChecked<TOther>(IntPtr, TOther)

Пытается преобразовать экземпляр текущего типа в другой тип, вызывая исключение переполнения для всех значений, которые выходят за пределы диапазона, представляющего текущий тип.

INumberBase<IntPtr>.TryConvertToSaturating<TOther>(IntPtr, TOther)

Пытается преобразовать экземпляр текущего типа в другой тип, насыщая все значения, которые выходят за пределы представляемого диапазона текущего типа.

INumberBase<IntPtr>.TryConvertToTruncating<TOther>(IntPtr, TOther)

Пытается преобразовать экземпляр текущего типа в другой тип, усекая все значения, которые выходят за пределы представляемого диапазона текущего типа.

INumberBase<IntPtr>.Zero

Возвращает значение 0 для типа.

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Заполняет объект SerializationInfo данными, необходимыми для сериализации текущего объекта IntPtr.

IShiftOperators<IntPtr,Int32,IntPtr>.LeftShift(IntPtr, Int32)

Сдвигает значение влево на заданную величину.

IShiftOperators<IntPtr,Int32,IntPtr>.RightShift(IntPtr, Int32)

Сдвигает значение вправо на заданную величину.

IShiftOperators<IntPtr,Int32,IntPtr>.UnsignedRightShift(IntPtr, Int32)

Сдвигает значение вправо на заданную величину.

ISignedNumber<IntPtr>.NegativeOne

Возвращает значение -1 для типа.

ISubtractionOperators<IntPtr,IntPtr,IntPtr>.CheckedSubtraction(IntPtr, IntPtr)

Вычитает два значения, чтобы вычислить их разницу.

ISubtractionOperators<IntPtr,IntPtr,IntPtr>.Subtraction(IntPtr, IntPtr)

Вычитает два значения, чтобы вычислить их разницу.

IUnaryNegationOperators<IntPtr,IntPtr>.CheckedUnaryNegation(IntPtr)

Вычисляет проверенное унарное отрицание значения.

IUnaryNegationOperators<IntPtr,IntPtr>.UnaryNegation(IntPtr)

Вычисляет унарное отрицание значения.

IUnaryPlusOperators<IntPtr,IntPtr>.UnaryPlus(IntPtr)

Вычисляет унарный плюс значения.

Применяется к

Потокобезопасность

Данный тип потокобезопасен.

См. также раздел