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 (单字节) 字符的形式将 Unicode 字符串复制到非托管内存。 该方法返回一个 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 字符串的非托管内存块转换为托管 Unicode 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 对象还可用于保存句柄。 例如,类中System.IO.FileStream广泛使用的IntPtr实例来保存文件句柄。

类型 IntPtr 符合 CLS,而 UIntPtr 该类型不合规。 仅在公共语言运行时中使用类型 IntPtr 。 此 UIntPtr 类型主要提供用于维护具有该 IntPtr 类型的体系结构对称性。

此类型实现接口,并在 .NET 5 及更高版本中IFormattable实现ISerializable接口。

在从版本 9.0 开始的 C# 中,可以使用内置 nint 类型定义本机大小的整数。 此类型由 IntPtr 内部类型表示,并提供适用于整数类型的操作和转换。 有关详细信息,请参阅 nint 和 nuint 类型

构造函数

IntPtr(Int32)

使用指定的 32 位指针或句柄初始化 IntPtr 的新实例。

IntPtr(Int64)

使用指定的 64 位指针初始化 IntPtr 的新实例。

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 对象。

适用于

线程安全性

此类型是线程安全的。

另请参阅