IntPtr Struktura

Reference

Definice

Obor názvů:: System

Sestavení:: System.Runtime.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Představuje celé číslo, ve kterém je bitová šířka stejná jako ukazatel.

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>, System::Numerics::IDecrementOperators<IntPtr>, System::Numerics::IDivisionOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::IEqualityOperators<IntPtr, IntPtr>, 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, 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>, System.Numerics.IDecrementOperators<IntPtr>, System.Numerics.IDivisionOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.IEqualityOperators<IntPtr,IntPtr>, 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,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>
    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 INumber<nativeint>
    interface INumberBase<nativeint>
    interface ISubtractionOperators<nativeint, nativeint, nativeint>
    interface IUnaryNegationOperators<nativeint, nativeint>
    interface IUnaryPlusOperators<nativeint, nativeint>
    interface IShiftOperators<nativeint, 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), 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), INumberBase(Of IntPtr), IParsable(Of IntPtr), ISerializable, IShiftOperators(Of IntPtr, IntPtr), ISignedNumber(Of IntPtr), ISpanParsable(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

Dědičnost: Object

ValueType
IntPtr

Atributy: SerializableAttribute ComVisibleAttribute

Implementuje: IComparable IComparable<IntPtr> IEquatable<IntPtr> IFormattable ISerializable ISpanFormattable IComparable<TOther> IComparable<TSelf> IEquatable<TOther> 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> System.Numerics.IComparisonOperators<IntPtr,IntPtr> System.Numerics.IComparisonOperators<TSelf,TSelf> IDecrementOperators<IntPtr> IDecrementOperators<TSelf> IDivisionOperators<IntPtr,IntPtr,IntPtr> IDivisionOperators<TSelf,TSelf,TSelf> System.Numerics.IEqualityOperators<IntPtr,IntPtr> System.Numerics.IEqualityOperators<TSelf,TOther> System.Numerics.IEqualityOperators<TSelf,TSelf> 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> System.Numerics.IShiftOperators<IntPtr,IntPtr> System.Numerics.IShiftOperators<TSelf,TSelf> ISignedNumber<IntPtr> ISubtractionOperators<IntPtr,IntPtr,IntPtr> ISubtractionOperators<TSelf,TSelf,TSelf> IUnaryNegationOperators<IntPtr,IntPtr> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<IntPtr,IntPtr> IUnaryPlusOperators<TSelf,TSelf>

Příklady

Následující příklad používá spravované ukazatele k obrácení znaků v poli. Jakmile inicializuje objekt a získá jeho délku String , provede toto:

Volá metodu Marshal.StringToHGlobalAnsi , která zkopíruje řetězec Unicode do nespravované paměti jako znak ANSI (1 bajt). Metoda vrátí IntPtr objekt, který odkazuje na začátek nespravovaného řetězce. Příklad jazyka Visual Basic používá tento ukazatel přímo; V příkladech jazyka C++, F# a C# se přetypuje na ukazatel na bajt.
Zavolá metodu Marshal.AllocHGlobal , aby přidělila stejný počet bajtů jako nespravovaný řetězec zabírá. Metoda vrátí IntPtr objekt, který odkazuje na začátek nespravovaného bloku paměti. Příklad jazyka Visual Basic používá tento ukazatel přímo; V příkladech jazyka C++, F# a C# se přetypuje na ukazatel na bajt.
Příklad jazyka Visual Basic definuje proměnnou, která se rovná délce offset řetězce ANSI. Slouží k určení posunu do nespravované paměti, do které se zkopíruje další znak řetězce ANSI. Vzhledem k tomu, že počáteční hodnota je délka řetězce, operace kopírování zkopíruje znak od začátku řetězce na konec bloku paměti.

Příklady jazyka C#, F# 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řidají jeden menší než délku řetězce na počáteční adresu řetězce ANSI. Protože nespravovaný ukazatel ř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.
Pomocí smyčky zkopíruje každý znak z řetězce do nespravovaného bloku paměti.

Příklad jazyka Visual Basic volá metodu Marshal.ReadByte(IntPtr, Int32) ke čtení bajtu (nebo znaku bajtů) v zadaném posunu od spravovaného ukazatele na řetězec ANSI. Posun se zvýší s každou iterací smyčky. Pak zavolá metodu Marshal.WriteByte(IntPtr, Int32, Byte) pro zápis bajtu na adresu paměti definovanou počáteční adresou nespravovaného bloku paměti plus offset. Pak se dekrementuje offset.

Příklady C#, F# a C++ provádějí operaci kopírování a pak dekrementují ukazatel na adresu dalšího umístění v nespravovaném řetězci ANSI a zvýší ukazatel na další adresu v nespravovaném bloku.
Všechny příklady volají Marshal.PtrToStringAnsi převod nespravovaného bloku paměti obsahující zkopírovaný řetězec ANSI na spravovaný objekt Unicode String .
Po zobrazení původních a reverzních řetězců všechny příklady volají metodu FreeHGlobal , která uvolní paměť přidělenou pro nespravovaný řetězec ANSI a nespravovaný blok paměti.

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

Poznámky

Typ IntPtr je navržený tak, aby byl celé číslo, jehož velikost je stejná jako ukazatel. To znamená, že instance tohoto typu má být 32 bitů v 32bitovém procesu a 64 bitů v 64bitovém procesu.

Typ IntPtr lze použít jazyky, které podporují ukazatele a jako běžný způsob odkazování na data mezi jazyky, které dělají a nepodporují ukazatele.

IntPtr Objekty lze použít také k uložení úchytů. Například instance se IntPtr ve třídě používají široce System.IO.FileStream k ukládání popisovačů souborů.

Poznámka

Použití IntPtr jako ukazatele nebo úchytu je náchylné k chybám a nebezpečné. Je to jednoduše celočíselný typ, který lze použít jako formát výměny ukazatelů a úchytů kvůli stejné velikosti. Mimo konkrétní požadavky na výměnu, například pro předávání dat do jazyka, který nepodporuje ukazatele, by se měl použít správně zadaný ukazatel k reprezentaci ukazatelů a SafeHandle měl by se použít k reprezentaci popisovačů.

Tento typ implementuje ISerializable. V .NET 5 a novějších verzích tento typ také implementuje IFormattable rozhraní. V .NET 7 a novějších verzích tento typ implementuje IBinaryInteger<TSelf>také rozhraní , IMinMaxValue<TSelf>a ISignedNumber<TSelf> rozhraní.

V jazyce C# od verze 9.0 můžete pomocí integrovaného nint typu definovat celá čísla nativní velikosti. Tento typ je reprezentován IntPtr interně a poskytuje operace a převody, které jsou vhodné pro celočíselné typy. Další informace najdete v tématu nint a nuint typy.

V jazyce C# od verze 11 a při cílení na modul runtime nint .NET 7 nebo novější je alias pro stejným způsobem jako int alias IntPtr pro Int32.

Konstruktory

IntPtr(Int32)	Inicializuje novou instanci IntPtr pomocí zadaného 32bitového bitového integeru.
IntPtr(Int64)	Inicializuje novou instanci IntPtr použití zadaného 64bitového bitového integeru.
IntPtr(Void*)	Inicializuje novou instanci IntPtr pomocí zadaného ukazatele na nezadanou typ.

Pole

Zero	Pole jen pro čtení, které představuje celé číslo, které bylo inicializováno na nulu.

Vlastnosti

MaxValue	Získá největší možnou IntPtrhodnotu .
MinValue	Získá nejmenší možnou IntPtrhodnotu .
Size	Získá velikost této instance.

Metody

Abs(IntPtr)	Vypočítá absolutní hodnotu.
Add(IntPtr, Int32)	Přidá posun do podepsaného celého čísla.
Clamp(IntPtr, IntPtr, IntPtr)	Upne hodnotu na inkluzivní minimum a maximální hodnotu.
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.
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.
CopySign(IntPtr, IntPtr)	Zkopíruje znaménko hodnoty na znaménko jiné hodnoty.
DivRem(IntPtr, IntPtr)	Vypočítá podíl a zbytek dvou hodnot.
Equals(IntPtr)	Určuje, zda se aktuální objekt rovná jinému objektu stejného typu.
Equals(Object)	Vrací hodnotu, která určuje, zda je tato instance rovna zadanému objektu.
GetHashCode()	Vrátí hodnotu hash pro tuto instanci.
IsEvenInteger(IntPtr)	Určuje, jestli hodnota představuje sudé číslo.
IsNegative(IntPtr)	Určuje, jestli je hodnota záporná.
IsOddInteger(IntPtr)	Určuje, jestli hodnota představuje liché celočíselné číslo.
IsPositive(IntPtr)	Určuje, jestli je hodnota kladná.
IsPow2(IntPtr)	Určuje, jestli je hodnota mocninou dvou.
LeadingZeroCount(IntPtr)	Vypočítá počet úvodních nul v hodnotě.
Log2(IntPtr)	Vypočítá protokol 2 hodnoty.
Max(IntPtr, IntPtr)	Porovná dvě hodnoty k výpočtu, což je větší.
MaxMagnitude(IntPtr, IntPtr)	Porovná dvě hodnoty k výpočtu, což je větší.
Min(IntPtr, IntPtr)	Porovná dvě hodnoty k výpočtu, což je menší.
MinMagnitude(IntPtr, IntPtr)	Porovná dvě hodnoty k výpočtu, což je menší.
Parse(ReadOnlySpan<Char>, IFormatProvider)
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Převede rozsah znaků jen pro čtení reprezentace čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho nativní celočíselné ekvivalenty.
Parse(String)	Převede řetězcovou reprezentaci čísla na jeho nativní celočíselné ekvivalenty.
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.
Parse(String, NumberStyles)	Převede řetězcovou reprezentaci čísla v zadaném stylu na jeho podepsaný nativní celočíselné ekvivalent.
Parse(String, NumberStyles, IFormatProvider)	Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho podepsaný nativní celočíselné ekvivalent.
PopCount(IntPtr)	Vypočítá počet bitů, které jsou nastavené v hodnotě.
RotateLeft(IntPtr, Int32)	Otočí hodnotu doleva o danou částku.
RotateRight(IntPtr, Int32)	Otočí hodnotu doprava o danou částku.
Sign(IntPtr)	Vypočítá znaménko hodnoty.
Subtract(IntPtr, Int32)	Odečte posun od signed integer.
ToInt32()	Převede hodnotu této instance na 32bitové celé číslo se signtegerem.
ToInt64()	Převede hodnotu této instance na 64bitové celé číslo se signtegerem.
ToPointer()	Převede hodnotu této instance na ukazatel na nezadaného typu.
ToString()	Převede číselnou hodnotu aktuálního IntPtr objektu na ekvivalentní řetězcové vyjádření.
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.
ToString(String)	Převede číselnou hodnotu aktuálního IntPtr objektu na ekvivalentní řetězcovou reprezentaci.
ToString(String, IFormatProvider)	Naformátuje hodnotu aktuální instance pomocí zadaného formátu.
TrailingZeroCount(IntPtr)	Vypočítá počet koncových nul v hodnotě.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Pokusí se naformátovat hodnotu aktuální instance do zadaného rozsahu znaků.
TryParse(ReadOnlySpan<Char>, IFormatProvider, IntPtr)
TryParse(ReadOnlySpan<Char>, IntPtr)	Převede rozsah znaků jen pro čtení reprezentace čísla na jeho nativní celočíselné ekvivalenty. Vrácená hodnota označuje, jestli převod proběhl úspěšně.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, IntPtr)	Převede rozsah znaků jen pro čtení reprezentace čísla v zadaném stylu a jazykové verzi na jeho nativní celočíselné ekvivalenty. Vrácená hodnota označuje, jestli převod proběhl úspěšně.
TryParse(String, IFormatProvider, IntPtr)
TryParse(String, IntPtr)	Převede řetězcovou reprezentaci čísla na jeho nativní celočíselné ekvivalenty. Vrácená hodnota označuje, jestli převod proběhl úspěšně.
TryParse(String, NumberStyles, IFormatProvider, IntPtr)	Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho nativní celočíselné ekvivalenty. Vrácená hodnota označuje, jestli převod proběhl úspěšně.

Operátory

Addition(IntPtr, Int32)	Přidá posun do podepsaného celého čísla.
Equality(IntPtr, IntPtr)	Určuje, zda jsou obě zadané instance objektu IntPtr stejné.
Explicit(Int32 to IntPtr)	Převede hodnotu 32bitového bitového signtegeru IntPtrna hodnotu .
Explicit(Int64 to IntPtr)	Převede hodnotu 64bitového bitového celého čísla na IntPtrhodnotu .
Explicit(IntPtr to Int32)	Převede hodnotu zadaného IntPtr na 32bitové celé číslo podepsaného.
Explicit(IntPtr to Int64)	Převede hodnotu zadaného IntPtr na 64bitové podepsané celé číslo.
Explicit(IntPtr to Void*)	Převede hodnotu zadaného na ukazatel na nezadanou IntPtr typ. Toto rozhraní API neodpovídá specifikaci CLS.
Explicit(Void* to IntPtr)	Převede zadaný ukazatel na nezadanou typ na IntPtrtyp . Toto rozhraní API neodpovídá specifikaci CLS.
Inequality(IntPtr, IntPtr)	Určuje, jestli jsou dvě zadané instance objektu IntPtr odlišné.
Subtraction(IntPtr, Int32)	Odečte posun od podepsaného celého čísla.

Explicitní implementace rozhraní

IBinaryInteger<IntPtr>.GetByteCount()	Získá počet bajtů, které budou zapsány jako součást TryWriteLittleEndian(Span<Byte>, Int32).
IBinaryInteger<IntPtr>.GetShortestBitLength()	Získá délku v bitech nejkratšího dvou doplňku reprezentace aktuální hodnoty.
IBinaryInteger<IntPtr>.TryWriteBigEndian(Span<Byte>, Int32)	Pokusí se napsat aktuální hodnotu ve formátu big-endian do daného rozsahu.
IBinaryInteger<IntPtr>.TryWriteLittleEndian(Span<Byte>, Int32)	Pokusí se napsat aktuální hodnotu v malém endian formátu do daného rozsahu.
IEquatable<IntPtr>.Equals(IntPtr)	Vrátí hodnotu, která označuje, zda je tato instance rovna jinému podepsanému celočíselnému číslu.
ISerializable.GetObjectData(SerializationInfo, StreamingContext)	SerializationInfo Naplní objekt daty potřebnými k serializaci aktuálního IntPtr objektu.

Platí pro

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

Tento typ je bezpečný pro přístup z více vláken.

Viz také

UIntPtr