IntPtr Struktura

Definice

Typ specifický pro platformu, který se používá k reprezentaci ukazatele nebo popisovače.A platform-specific type that is used to represent a pointer or a handle.

public value class IntPtr
public value class IntPtr : IComparable, IComparable<IntPtr>, IEquatable<IntPtr>, IFormattable, 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 struct IntPtr : IComparable, IComparable<IntPtr>, IEquatable<IntPtr>, IFormattable, System.Runtime.Serialization.ISerializable
public 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 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 IEquatable(Of IntPtr), ISerializable
Public Structure IntPtr
Implements ISerializable
Dědičnost
IntPtr
Atributy
Implementuje

Příklady

Následující příklad používá spravované ukazatele k vrácení znaků v poli.The following example uses managed pointers to reverse the characters in an array. Poté, co inicializuje String objekt a získá jeho délku, provede následující:After it initializes a String object and gets its length, it does the following:

  1. Volá Marshal.StringToHGlobalAnsi metodu pro zkopírování řetězce Unicode do nespravované paměti jako znak ANSI (Byte).Calls the Marshal.StringToHGlobalAnsi method to copy the Unicode string to unmanaged memory as an ANSI (one-byte) character. Metoda vrátí IntPtr objekt, který odkazuje na začátek nespravovaného řetězce.The method returns an IntPtr object that points to the beginning of the unmanaged string. Visual Basic příklad používá tento ukazatel přímo; v příkladech jazyka C++ a C# je přetypování na ukazatel na bajt.The Visual Basic example uses this pointer directly; in the C++ and C# examples, it is cast to a pointer to a byte.

  2. Volá Marshal.AllocHGlobal metodu pro přidělení stejného počtu bajtů, jako se nespravovaný řetězec zabírá.Calls the Marshal.AllocHGlobal method to allocate the same number of bytes as the unmanaged string occupies. Metoda vrátí IntPtr objekt, který odkazuje na začátek nespravovaného bloku paměti.The method returns an IntPtr object that points to the beginning of the unmanaged block of memory. Visual Basic příklad používá tento ukazatel přímo; v příkladech jazyka C++ a C# je přetypování na ukazatel na bajt.The Visual Basic example uses this pointer directly; in the C++ and C# examples, it is cast to a pointer to a byte.

  3. Příklad Visual Basic definuje proměnnou s názvem offset , která se rovná délce řetězce ANSI.The Visual Basic example defines a variable named offset that is equal to the length of the ANSI string. Slouží k určení posunu do nespravované paměti, ke které je zkopírován další znak v řetězci ANSI.It is used to determine the offset into unmanaged memory to which the next character in the ANSI string is copied. Vzhledem k tomu, že počáteční hodnota je délka řetězce, operace kopírování zkopíruje znak ze začátku řetězce na konec bloku paměti.Because its starting value is the length of the string, the copy operation will copy a character from the start of the string to the end of the memory block.

    Příklady C# a C++ volají ToPointer metodu pro získání nespravovaného ukazatele na počáteční adresu řetězce a nespravovaného bloku paměti a přidávají jednu méně než délku řetězce na počáteční adresu řetězce ANSI.The C# and C++ examples call the ToPointer method to get an unmanaged pointer to the starting address of the string and the unmanaged block of memory, and they add one less than the length of the string to the starting address of the ANSI string. Vzhledem k tomu, že ukazatel nespravovaného řetězce teď odkazuje na konec řetězce, operace kopírování zkopíruje znak z konce řetězce na začátek bloku paměti.Because the unmanaged string pointer now points to the end of the string, the copy operation will copy a character from the end of the string to the start of the memory block.

  4. Používá smyčku ke kopírování každého znaku z řetězce do nespravovaného bloku paměti.Uses a loop to copy each character from the string to the unmanaged block of memory.

    Visual Basic příklad volá Marshal.ReadByte(IntPtr, Int32) metodu pro čtení bajtu (nebo jednobajtových znaku) na zadaném posunu od spravovaného ukazatele na řetězec ANSI.The Visual Basic example calls the Marshal.ReadByte(IntPtr, Int32) method to read the byte (or one-byte character) at a specified offset from the managed pointer to the ANSI string. Posun se zvyšuje s každou iterací smyčky.The offset is incremented with each iteration of the loop. Pak zavolá Marshal.WriteByte(IntPtr, Int32, Byte) metodu pro zápis bajtu do adresy paměti definované počáteční adresou nespravovaného bloku paměti plus offset .It then calls the Marshal.WriteByte(IntPtr, Int32, Byte) method to write the byte to the memory address defined by the starting address of the unmanaged block of memory plus offset. Pak se sníží offset .It then decrements offset.

    Příklady jazyka C# a C++ provádějí operaci kopírování a pak snižují ukazatel na adresu dalšího umístění v nespravovaném řetězci ANSI a zvýší ukazatel na další adresu v nespravovaném bloku.The C# and C++ examples perform the copy operation, then decrement the pointer to the address of the next location in the unmanaged ANSI string and increment the pointer to the next address in the unmanaged block.

  5. Všechny příklady volají Marshal.PtrToStringAnsi k převedení nespravovaného bloku paměti obsahujícího zkopírovaný řetězec ANSI na spravovaný objekt Unicode String .All examples call the Marshal.PtrToStringAnsi to convert the unmanaged memory block containing the copied ANSI string to a managed Unicode String object.

  6. Po zobrazení původního a vráceného řetězce všechny příklady volají FreeHGlobal metodu pro uvolnění paměti přidělené nespravovanému řetězci ANSI a nespravovanému bloku paměti.After displaying the original and reversed strings, all examples call the FreeHGlobal method to free the memory allocated for the unmanaged ANSI string and the unmanaged block of memory.

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
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

Poznámky

IntPtrTyp je navržen jako celé číslo, jehož velikost je specifická pro platformu.The IntPtr type is designed to be an integer whose size is platform-specific. To znamená, že instance tohoto typu by měla být 32-bity na 32 hardwaru a operačních systémech a 64-bitů 64 v 16bitovém hardwaru a operačních systémech.That is, an instance of this type is expected to be 32-bits on 32-bit hardware and operating systems, and 64-bits on 64-bit hardware and operating systems.

IntPtrTyp lze použít v jazycích, které podporují ukazatele a jako běžné prostředky pro odkazování na data mezi jazyky, které provádějí a nepodporují ukazatele.The IntPtr type can be used by languages that support pointers and as a common means of referring to data between languages that do and do not support pointers.

IntPtr objekty lze také použít k uložení popisovačů.IntPtr objects can also be used to hold handles. Například instance IntPtr jsou často používány ve System.IO.FileStream třídě pro uchovávání popisovačů souborů.For example, instances of IntPtr are used extensively in the System.IO.FileStream class to hold file handles.

IntPtrTyp je kompatibilní se specifikací CLS, zatímco UIntPtr typ není.The IntPtr type is CLS-compliant, while the UIntPtr type is not. IntPtrV modulu CLR (Common Language Runtime) se používá pouze typ.Only the IntPtr type is used in the common language runtime. Tento UIntPtr typ je k dispozici většinou pro zachování architektury symetrie s IntPtr typem.The UIntPtr type is provided mostly to maintain architectural symmetry with the IntPtr type.

Tento typ implementuje ISerializable rozhraní, a v rozhraní .net 5,0 a novějších IFormattable rozhraních.This type implements the ISerializable, and, in .NET 5.0 and later, the IFormattable interfaces.

Konstruktory

IntPtr(Int32)

Inicializuje novou instanci IntPtr pomocí zadaného ukazatele nebo popisovače 32.Initializes a new instance of IntPtr using the specified 32-bit pointer or handle.

IntPtr(Int64)

Inicializuje novou instanci IntPtr pomocí zadaného ukazatele 64.Initializes a new instance of IntPtr using the specified 64-bit pointer.

IntPtr(Void*)

Inicializuje novou instanci s IntPtr použitím zadaného ukazatele na nespecifikovaný typ.Initializes a new instance of IntPtr using the specified pointer to an unspecified type.

Pole

Zero

Pole určené jen pro čtení, které představuje ukazatel nebo popisovač, které byly inicializovány na nulu.A read-only field that represents a pointer or handle that has been initialized to zero.

Vlastnosti

MaxValue

Představuje největší možnou hodnotu IntPtr .Represents the largest possible value of IntPtr.

MinValue

Představuje nejmenší možnou hodnotu IntPtr .Represents the smallest possible value of IntPtr.

Size

Získá velikost této instance.Gets the size of this instance.

Metody

Add(IntPtr, Int32)

Přidá posun k hodnotě ukazatele.Adds an offset to the value of a pointer.

CompareTo(IntPtr)

Porovná aktuální instanci s jiným objektem stejného typu a vrátí celé číslo udávající, zda aktuální instance předchází, následuje nebo se vyskytuje ve stejné pozici v pořadí řazení jako druhý objekt.Compares the current instance with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other object.

CompareTo(Object)

Porovná aktuální instanci s jiným objektem stejného typu a vrátí celé číslo udávající, zda aktuální instance předchází, následuje nebo se vyskytuje ve stejné pozici v pořadí řazení jako druhý objekt.Compares the current instance with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other object.

Equals(IntPtr)

Označuje, zda je aktuální objekt roven jinému objektu stejného typu.Indicates whether the current object is equal to another object of the same type.

Equals(Object)

Vrací hodnotu, která určuje, zda je tato instance rovna zadanému objektu.Returns a value indicating whether this instance is equal to a specified object.

GetHashCode()

Vrátí hodnotu hash pro tuto instanci.Returns the hash code for this instance.

Parse(String)

Převede řetězcové vyjádření čísla na jeho podepsaný nativní celočíselný ekvivalent.Converts the string representation of a number to its signed native integer equivalent.

Parse(String, IFormatProvider)

Převede řetězcové vyjádření čísla v zadaném formátu specifickém pro jazykovou verzi na jeho podepsaný nativní celočíselný ekvivalent.Converts the string representation of a number in a specified culture-specific format to its signed native integer equivalent.

Parse(String, NumberStyles)

Převede řetězcové vyjádření čísla v zadaném stylu na jeho podepsaný nativní celočíselný ekvivalent.Converts the string representation of a number in a specified style to its signed native integer equivalent.

Parse(String, NumberStyles, IFormatProvider)

Převede řetězcové vyjádření čísla v zadaném stylu a formátu specifického pro jazykovou verzi na jeho podepsaný nativní celočíselný ekvivalent.Converts the string representation of a number in a specified style and culture-specific format to its signed native integer equivalent.

Subtract(IntPtr, Int32)

Odečte posun od hodnoty ukazatele.Subtracts an offset from the value of a pointer.

ToInt32()

Převede hodnotu této instance na celé číslo se znaménkem (32).Converts the value of this instance to a 32-bit signed integer.

ToInt64()

Převede hodnotu této instance na celé číslo se znaménkem (64).Converts the value of this instance to a 64-bit signed integer.

ToPointer()

Převede hodnotu této instance na ukazatel na nespecifikovaný typ.Converts the value of this instance to a pointer to an unspecified type.

ToString()

Převede číselnou hodnotu aktuálního IntPtr objektu na odpovídající řetězcovou reprezentaci.Converts the numeric value of the current IntPtr object to its equivalent string representation.

ToString(IFormatProvider)

Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření pomocí určeného formátu a informací o formátování specifických pro jazykovou verzi.Converts the numeric value of this instance to its equivalent string representation using the specified format and culture-specific format information.

ToString(String)

Převede číselnou hodnotu aktuálního IntPtr objektu na odpovídající řetězcovou reprezentaci.Converts the numeric value of the current IntPtr object to its equivalent string representation.

ToString(String, IFormatProvider)

Zformátuje hodnotu aktuální instance pomocí zadaného formátu.Formats the value of the current instance using the specified format.

TryParse(String, IntPtr)

Převede řetězcové vyjádření čísla na jeho podepsaný nativní celočíselný ekvivalent.Converts the string representation of a number to its signed native integer equivalent. Návratová hodnota označuje, zda převod proběhl úspěšně.A return value indicates whether the conversion succeeded.

TryParse(String, NumberStyles, IFormatProvider, IntPtr)

Převede řetězcové vyjádření čísla v zadaném stylu a formátu specifického pro jazykovou verzi na jeho podepsaný nativní celočíselný ekvivalent.Converts the string representation of a number in a specified style and culture-specific format to its signed native integer equivalent. Návratová hodnota označuje, zda převod proběhl úspěšně.A return value indicates whether the conversion succeeded.

Operátory

Addition(IntPtr, Int32)

Přidá posun k hodnotě ukazatele.Adds an offset to the value of a pointer.

Equality(IntPtr, IntPtr)

Určuje, zda jsou obě zadané instance objektu IntPtr stejné.Determines whether two specified instances of IntPtr are equal.

Explicit(Int32 to IntPtr)

Převede hodnotu zašifrovaného celého čísla se znaménkem na hodnotu (32) IntPtr .Converts the value of a 32-bit signed integer to an IntPtr.

Explicit(Int64 to IntPtr)

Převede hodnotu zašifrovaného celého čísla se znaménkem na hodnotu (64) IntPtr .Converts the value of a 64-bit signed integer to an IntPtr.

Explicit(IntPtr to Int32)

Převede hodnotu určenou IntPtr na celé číslo se znaménkem 32.Converts the value of the specified IntPtr to a 32-bit signed integer.

Explicit(IntPtr to Int64)

Převede hodnotu určenou IntPtr na celé číslo se znaménkem 64.Converts the value of the specified IntPtr to a 64-bit signed integer.

Explicit(IntPtr to Void*)

Převede hodnotu zadaného IntPtr na ukazatel na nespecifikovaný typ.Converts the value of the specified IntPtr to a pointer to an unspecified type.

Toto rozhraní API neodpovídá specifikaci CLS.This API is not CLS-compliant.

Explicit(Void* to IntPtr)

Převede zadaný ukazatel na nespecifikovaný typ na IntPtr .Converts the specified pointer to an unspecified type to an IntPtr.

Toto rozhraní API neodpovídá specifikaci CLS.This API is not CLS-compliant.

Inequality(IntPtr, IntPtr)

Určuje, jestli jsou dvě zadané instance objektu IntPtr odlišné.Determines whether two specified instances of IntPtr are not equal.

Subtraction(IntPtr, Int32)

Odečte posun od hodnoty ukazatele.Subtracts an offset from the value of a pointer.

Explicitní implementace rozhraní

IEquatable<IntPtr>.Equals(IntPtr)

Vrátí hodnotu, která označuje, zda je tato instance rovna jinému ukazateli se znaménkem celého čísla.Returns a value that indicates whether this instance is equal to another signed integer pointer.

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Naplní SerializationInfo objekt daty potřebnými k serializaci aktuálního IntPtr objektu.Populates a SerializationInfo object with the data needed to serialize the current IntPtr object.

Platí pro

Bezpečný přístup z více vláken

Tento typ je bezpečný pro přístup z více vláken.This type is thread safe.

Viz také