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 : IAdditionOperators<IntPtr, IntPtr, IntPtr>, IAdditiveIdentity<IntPtr, IntPtr>, IBinaryInteger<IntPtr>, IBinaryNumber<IntPtr>, IBitwiseOperators<IntPtr, IntPtr, IntPtr>, IComparable<IntPtr>, IComparisonOperators<IntPtr, IntPtr>, IDecrementOperators<IntPtr>, IDivisionOperators<IntPtr, IntPtr, IntPtr>, IEqualityOperators<IntPtr, IntPtr>, IEquatable<IntPtr>, IIncrementOperators<IntPtr>, IMinMaxValue<IntPtr>, IModulusOperators<IntPtr, IntPtr, IntPtr>, IMultiplicativeIdentity<IntPtr, IntPtr>, IMultiplyOperators<IntPtr, IntPtr, IntPtr>, INumber<IntPtr>, IParseable<IntPtr>, IShiftOperators<IntPtr, IntPtr>, ISignedNumber<IntPtr>, ISpanParseable<IntPtr>, ISubtractionOperators<IntPtr, IntPtr, IntPtr>, IUnaryNegationOperators<IntPtr, IntPtr>, 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 : IAdditionOperators<IntPtr,IntPtr,IntPtr>, IAdditiveIdentity<IntPtr,IntPtr>, IBinaryInteger<IntPtr>, IBinaryNumber<IntPtr>, IBitwiseOperators<IntPtr,IntPtr,IntPtr>, IComparable<IntPtr>, IComparisonOperators<IntPtr,IntPtr>, IDecrementOperators<IntPtr>, IDivisionOperators<IntPtr,IntPtr,IntPtr>, IEqualityOperators<IntPtr,IntPtr>, IEquatable<IntPtr>, IIncrementOperators<IntPtr>, IMinMaxValue<IntPtr>, IModulusOperators<IntPtr,IntPtr,IntPtr>, IMultiplicativeIdentity<IntPtr,IntPtr>, IMultiplyOperators<IntPtr,IntPtr,IntPtr>, INumber<IntPtr>, IParseable<IntPtr>, IShiftOperators<IntPtr,IntPtr>, ISignedNumber<IntPtr>, ISpanParseable<IntPtr>, ISubtractionOperators<IntPtr,IntPtr,IntPtr>, IUnaryNegationOperators<IntPtr,IntPtr>, 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 ISpanFormattable
    interface IFormattable
    interface ISerializable
    interface IBinaryInteger<nativeint>
    interface IBinaryNumber<nativeint>
    interface IBitwiseOperators<nativeint, nativeint, nativeint>
    interface INumber<nativeint>
    interface IAdditionOperators<nativeint, nativeint, nativeint>
    interface IAdditiveIdentity<nativeint, nativeint>
    interface IComparisonOperators<nativeint, nativeint>
    interface IEqualityOperators<nativeint, nativeint>
    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 IParseable<nativeint>
    interface ISpanParseable<nativeint>
    interface ISubtractionOperators<nativeint, nativeint, nativeint>
    interface IUnaryNegationOperators<nativeint, nativeint>
    interface IUnaryPlusOperators<nativeint, nativeint>
    interface IShiftOperators<nativeint, nativeint>
    interface IMinMaxValue<nativeint>
    interface ISignedNumber<nativeint>
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), IDecrementOperators(Of IntPtr), IDivisionOperators(Of IntPtr, IntPtr, IntPtr), IEqualityOperators(Of IntPtr, IntPtr), 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), IParseable(Of IntPtr), ISerializable, IShiftOperators(Of IntPtr, IntPtr), ISignedNumber(Of IntPtr), ISpanParseable(Of IntPtr), ISubtractionOperators(Of IntPtr, IntPtr, IntPtr), IUnaryNegationOperators(Of IntPtr, IntPtr), IUnaryPlusOperators(Of IntPtr, IntPtr)
Public Structure IntPtr
Implements IEquatable(Of IntPtr), ISerializable
Public Structure IntPtr
Implements ISerializable
Наследование
IntPtr
Атрибуты
Реализации

Примеры

В следующем примере управляемые указатели используются для отмены символов в массиве. После инициализации 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 является CLS-совместимым, в то время как UIntPtr тип не является. IntPtr В среде CLR используется только тип. Тип UIntPtr предоставляется в основном для поддержания симметрии архитектуры с типом IntPtr .

Этот тип реализует интерфейсы ISerializableи интерфейсы в .NET 5 и более поздних версиях IFormattable .

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

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

IntPtr(Int32)

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

IntPtr(Int64)

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

IntPtr(Void*)

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

Поля

Zero

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

Свойства

MaxValue

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

MinValue

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

Size

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

Методы

Add(IntPtr, Int32)

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

CompareTo(IntPtr)

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

CompareTo(Object)

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

Equals(IntPtr)

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

Equals(Object)

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

GetHashCode()

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

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

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

Parse(String)

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

Parse(String, IFormatProvider)

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

Parse(String, NumberStyles)

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

Parse(String, NumberStyles, IFormatProvider)

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

Subtract(IntPtr, Int32)

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

ToInt32()

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

ToInt64()

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

ToPointer()

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

ToString()

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

ToString(IFormatProvider)

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

ToString(String)

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

ToString(String, IFormatProvider)

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

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

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

TryParse(ReadOnlySpan<Char>, IntPtr)

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

TryParse(ReadOnlySpan<Char>, NumberStyles, 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)

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

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

IEquatable<IntPtr>.Equals(IntPtr)

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

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

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

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

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

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

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