IntPtr Struktura

Definice

Obor názvů:

System

Sestavení:

System.Runtime.dll

Zdroj:

IntPtr.cs

Představuje celé číslo se signedem, kde je bitová šířka stejná jako ukazatel.

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

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

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)

Dědičnost

Object

ValueType

IntPtr

Implementuje

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>

Příklady

Následující příklad používá spravované ukazatele k obrácení znaků v poli. Po inicializaci objektu String a získá jeho délku, provede následující:

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

2. Volá 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.

3. Příklad jazyka Visual Basic definuje proměnnou s názvem offset, která se rovná délce řetězce ANSI. Slouží k určení posunu do nespravované paměti, do které se zkopíruje další znak v řetězci ANSI. Vzhledem k tomu, že jeho 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í metodu ToPointer, která získá nespravovaný ukazatel na počáteční adresu řetězce a nespravovaného bloku paměti a přidají jednu 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.

4. 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 1 bajtu) v zadaném posunu od spravovaného ukazatele na řetězec ANSI. Posun se zvýší o každou iteraci smyčky. Potom volá Marshal.WriteByte(IntPtr, Int32, Byte) metodu zápisu bajtu na adresu paměti definovanou počáteční adresou nespravovaného bloku paměti plus offset. Pak se sníží offset.

   Příklady C#, F# a C++ provádějí operaci kopírování a potom 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.

5. Všechny příklady volají Marshal.PtrToStringAnsi pro převod nespravovaného bloku paměti obsahujícího zkopírovaný řetězec ANSI na spravovaný objekt Unicode String objektu.

6. Po zobrazení původních a obrácený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 se očekává, že instance tohoto typu bude 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 IntPtr se ve třídě System.IO.FileStream používají k ukládání popisovačů souborů.

Poznámka

Použití IntPtr jako ukazatele nebo úchytu je náchylné k chybám a nebezpečné. Jedná se jednoduše o celočíselný typ, který lze použít jako formát výměny pro ukazatele a úchyty z důvodu 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 by se měl použít k reprezentaci popisovačů.

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

V jazyce C# od verze 9.0 můžete k definování celých čísel nativní velikosti použít integrovaný typ nint. Tento typ je reprezentován interním typem IntPtr a poskytuje operace a převody, které jsou vhodné pro celočíselné typy. Další informace najdete v tématu devátých a nuintových typů.

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

Konstruktory

IntPtr(Int32)	Inicializuje novou instanci IntPtr pomocí zadaného 32bitového signed integer.
IntPtr(Int64)	Inicializuje novou instanci IntPtr pomocí zadaného 64bitového signed integer.
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 hodnotu IntPtr.
MinValue	Získá nejmenší možnou hodnotu IntPtr.
Size	Získá velikost této instance.

Metody

Abs(IntPtr)	Vypočítá absolutní hodnotu.
Add(IntPtr, Int32)	Přidá posun k podepsanému celočíselnému číslu.
Clamp(IntPtr, IntPtr, IntPtr)	Uchytá hodnotu na inkluzivní minimální a maximální hodnotu.
CompareTo(IntPtr)	Porovná aktuální instanci s jiným objektem stejného typu a vrátí celé číslo, které určuje, zda aktuální instance předchází, následuje nebo se vyskytuje ve stejném pořadí řazení jako druhý objekt.
CompareTo(Object)	Porovná aktuální instanci s jiným objektem stejného typu a vrátí celé číslo, které určuje, zda aktuální instance předchází, následuje nebo se vyskytuje ve stejném pořadí řazení jako druhý objekt.
CopySign(IntPtr, IntPtr)	Zkopíruje znaménko hodnoty na znaménko jiné hodnoty.
CreateChecked<TOther>(TOther)	Vytvoří instanci aktuálního typu z hodnoty, která vyvolá výjimku přetečení pro všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu.
CreateSaturating<TOther>(TOther)	Vytvoří instanci aktuálního typu z hodnoty, která saturuje všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu.
CreateTruncating<TOther>(TOther)	Vytvoří instanci aktuálního typu z hodnoty a zkrátí všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu.
DivRem(IntPtr, IntPtr)	Vypočítá podíl a zbytek dvou hodnot.
Equals(IntPtr)	Určuje, zda je aktuální objekt roven jinému objektu stejného typu.
Equals(Object)	Vrátí hodnotu určující, zda je tato instance rovna zadanému objektu.
GetHashCode()	Vrátí kód hash pro tuto instanci.
IsEvenInteger(IntPtr)	Určuje, zda hodnota představuje sudé celočíselné číslo.
IsNegative(IntPtr)	Určuje, zda je hodnota záporná.
IsOddInteger(IntPtr)	Určuje, zda hodnota představuje liché celočíselné číslo.
IsPositive(IntPtr)	Určuje, jestli je hodnota kladná.
IsPow2(IntPtr)	Určuje, zda je hodnota mocnina 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 s výpočty, které jsou větší.
MaxMagnitude(IntPtr, IntPtr)	Porovná dvě hodnoty s výpočty, které jsou větší.
Min(IntPtr, IntPtr)	Porovná dvě hodnoty s výpočetními prostředky, které jsou menší.
MinMagnitude(IntPtr, IntPtr)	Porovná dvě hodnoty s výpočetními prostředky, které jsou menší.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Parsuje rozsah znaků UTF-8 do hodnoty.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Parsuje rozsah znaků UTF-8 do hodnoty.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Parsuje rozsah znaků do hodnoty.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Převede rozsah znaků jen pro čtení reprezentace čísla v zadaném stylu a jazykové verzi na jeho nativní celočíselné ekvivalenty.
Parse(String)	Převede řetězcové vyjádření čísla na jeho podepsaný nativní celočíselné ekvivalent.
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ězcové vyjádření čí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 nativní celočíselné ekvivalenty.
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 signedm.
ToInt64()	Převede hodnotu této instance na 64bitové celé číslo se signedm.
ToPointer()	Převede hodnotu této instance na ukazatel na nezadanou hodnotu.
ToString()	Převede číselnou hodnotu aktuálního objektu IntPtr na ekvivalentní řetězcové vyjádření.
ToString(IFormatProvider)	Převede číselnou hodnotu této instance na ekvivalentní řetězcové vyjádření pomocí zadaného formátu a informací o formátu specifickém pro jazykovou verzi.
ToString(String)	Převede číselnou hodnotu aktuálního objektu IntPtr na ekvivalentní řetězcové vyjádření.
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<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Pokusí se naformátovat hodnotu aktuální instance jako UTF-8 do poskytnutého rozsahu bajtů.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Pokusí se naformátovat hodnotu aktuální instance do zadaného rozsahu znaků.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, IntPtr)	Pokusí se analyzovat rozsah znaků UTF-8 do hodnoty.
TryParse(ReadOnlySpan<Byte>, IntPtr)	Pokusí se převést rozsah znaků UTF-8 obsahující řetězcovou reprezentaci čísla na jeho znaménko ekvivalent.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, IntPtr)	Pokusí se analyzovat rozsah znaků UTF-8 do hodnoty.
TryParse(ReadOnlySpan<Char>, IFormatProvider, IntPtr)	Pokusí se analyzovat řetězec do hodnoty.
TryParse(ReadOnlySpan<Char>, IntPtr)	Převede rozsah znaků jen pro čtení reprezentace čísla na jeho nativní celé číslo se znaménkem. Vrácená hodnota označuje, zda byl převod ú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, zda byl převod úspěšný.
TryParse(String, IFormatProvider, IntPtr)	Pokusí se analyzovat řetězec do hodnoty.
TryParse(String, IntPtr)	Převede řetězcové vyjádření čísla na jeho podepsaný nativní celočíselné ekvivalent. Vrácená hodnota označuje, zda byl převod ú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, zda byl převod úspěšný.

Operátory

Addition(IntPtr, Int32)	Přidá posun k podepsanému celočíselnému číslu.
Equality(IntPtr, IntPtr)	Určuje, zda jsou dvě zadané instance IntPtr stejné.
Explicit(Int32 to IntPtr)	Převede hodnotu 32bitového signed integer na IntPtr.
Explicit(Int64 to IntPtr)	Převede hodnotu 64bitového signed integer na IntPtr.
Explicit(IntPtr to Int32)	Převede hodnotu zadaného IntPtr na 32bitové celé číslo se signedm.
Explicit(IntPtr to Int64)	Převede hodnotu zadaného IntPtr na 64bitové celé číslo se signedm.
Explicit(IntPtr to Void*)	Převede hodnotu zadaného IntPtr na ukazatel na nezadaný typ. Toto rozhraní API nedodržuje předpisy CLS.
Explicit(Void* to IntPtr)	Převede zadaný ukazatel na nezadanou typ na IntPtr. Toto rozhraní API nedodržuje předpisy CLS.
Inequality(IntPtr, IntPtr)	Určuje, zda se dvě zadané instance IntPtr nerovnají.
Subtraction(IntPtr, Int32)	Odečte posun od signed integer.

Explicitní implementace rozhraní

IAdditionOperators<IntPtr,IntPtr,IntPtr>.Addition(IntPtr, IntPtr)	Sečte dvě hodnoty ke výpočtu jejich součtu.
IAdditionOperators<IntPtr,IntPtr,IntPtr>.CheckedAddition(IntPtr, IntPtr)	Sečte dvě hodnoty ke výpočtu jejich součtu.
IAdditiveIdentity<IntPtr,IntPtr>.AdditiveIdentity	Získá přídatnou identitu aktuálního typu.
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>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, IntPtr)	Představuje celé číslo se signedem, kde je bitová šířka stejná jako ukazatel.
IBinaryInteger<IntPtr>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, IntPtr)	Představuje celé číslo se signedem, kde je bitová šířka stejná jako ukazatel.
IBinaryInteger<IntPtr>.TryWriteBigEndian(Span<Byte>, Int32)	Pokusí se na daný rozsah napsat aktuální hodnotu ve formátu big-endian.
IBinaryInteger<IntPtr>.TryWriteLittleEndian(Span<Byte>, Int32)	Pokusí se na daný rozsah napsat aktuální hodnotu v malém endian formátu.
IBinaryNumber<IntPtr>.AllBitsSet	Získá instanci binárního typu, ve které jsou nastaveny všechny bity.
IBitwiseOperators<IntPtr,IntPtr,IntPtr>.BitwiseAnd(IntPtr, IntPtr)	Vypočítá bitové a dvě hodnoty.
IBitwiseOperators<IntPtr,IntPtr,IntPtr>.BitwiseOr(IntPtr, IntPtr)	Vypočítá bitové nebo dvě hodnoty.
IBitwiseOperators<IntPtr,IntPtr,IntPtr>.ExclusiveOr(IntPtr, IntPtr)	Vypočítá výhradní nebo dvě hodnoty.
IBitwiseOperators<IntPtr,IntPtr,IntPtr>.OnesComplement(IntPtr)	Vypočítá reprezentaci daného doplňku.
IComparisonOperators<IntPtr,IntPtr,Boolean>.GreaterThan(IntPtr, IntPtr)	Porovná dvě hodnoty a určí, která hodnota je větší.
IComparisonOperators<IntPtr,IntPtr,Boolean>.GreaterThanOrEqual(IntPtr, IntPtr)	Porovná dvě hodnoty a určí, která hodnota je větší nebo rovna.
IComparisonOperators<IntPtr,IntPtr,Boolean>.LessThan(IntPtr, IntPtr)	Porovná dvě hodnoty a určí, která hodnota je menší.
IComparisonOperators<IntPtr,IntPtr,Boolean>.LessThanOrEqual(IntPtr, IntPtr)	Porovná dvě hodnoty a určí, která hodnota je menší nebo rovna.
IDecrementOperators<IntPtr>.CheckedDecrement(IntPtr)	Dekrementuje hodnotu.
IDecrementOperators<IntPtr>.Decrement(IntPtr)	Dekrementuje hodnotu.
IDivisionOperators<IntPtr,IntPtr,IntPtr>.Division(IntPtr, IntPtr)	Vydělí jednu hodnotu jinou, aby se vypočítá jejich podíl.
IIncrementOperators<IntPtr>.CheckedIncrement(IntPtr)	Zvýší hodnotu.
IIncrementOperators<IntPtr>.Increment(IntPtr)	Zvýší hodnotu.
IMinMaxValue<IntPtr>.MaxValue	Získá maximální hodnotu aktuálního typu.
IMinMaxValue<IntPtr>.MinValue	Získá minimální hodnotu aktuálního typu.
IModulusOperators<IntPtr,IntPtr,IntPtr>.Modulus(IntPtr, IntPtr)	Rozdělí dvě hodnoty dohromady a vypočítá jejich moduly nebo zbytek.
IMultiplicativeIdentity<IntPtr,IntPtr>.MultiplicativeIdentity	Získá multiplikativní identitu aktuálního typu.
IMultiplyOperators<IntPtr,IntPtr,IntPtr>.CheckedMultiply(IntPtr, IntPtr)	Vynásobí dvě hodnoty dohromady pro výpočet jejich produktu.
IMultiplyOperators<IntPtr,IntPtr,IntPtr>.Multiply(IntPtr, IntPtr)	Vynásobí dvě hodnoty dohromady pro výpočet jejich produktu.
INumber<IntPtr>.MaxNumber(IntPtr, IntPtr)	Porovná dvě hodnoty k výpočtu, který je větší a vrátí druhou hodnotu, pokud je vstup NaN.
INumber<IntPtr>.MinNumber(IntPtr, IntPtr)	Porovná dvě hodnoty a vypočítá menší hodnotu a vrátí druhou hodnotu, pokud je vstup NaN.
INumberBase<IntPtr>.IsCanonical(IntPtr)	Určuje, zda je hodnota v kanonickém vyjádření.
INumberBase<IntPtr>.IsComplexNumber(IntPtr)	Určuje, zda hodnota představuje komplexní číslo.
INumberBase<IntPtr>.IsFinite(IntPtr)	Určuje, zda je hodnota konečná.
INumberBase<IntPtr>.IsImaginaryNumber(IntPtr)	Určuje, jestli hodnota představuje čisté imaginární číslo.
INumberBase<IntPtr>.IsInfinity(IntPtr)	Určuje, zda je hodnota nekonečná.
INumberBase<IntPtr>.IsInteger(IntPtr)	Určuje, zda hodnota představuje celočíselné číslo.
INumberBase<IntPtr>.IsNaN(IntPtr)	Určuje, jestli je hodnota NaN.
INumberBase<IntPtr>.IsNegativeInfinity(IntPtr)	Určuje, zda je hodnota záporná nekonečno.
INumberBase<IntPtr>.IsNormal(IntPtr)	Určuje, zda je hodnota normální.
INumberBase<IntPtr>.IsPositiveInfinity(IntPtr)	Určuje, jestli je hodnota kladná nekonečno.
INumberBase<IntPtr>.IsRealNumber(IntPtr)	Určuje, zda hodnota představuje reálné číslo.
INumberBase<IntPtr>.IsSubnormal(IntPtr)	Určuje, jestli je hodnota podnormální.
INumberBase<IntPtr>.IsZero(IntPtr)	Určuje, jestli je hodnota nula.
INumberBase<IntPtr>.MaxMagnitudeNumber(IntPtr, IntPtr)	Porovná dvě hodnoty k výpočtu, které mají větší velikost a vrátí druhou hodnotu, pokud je vstup NaN.
INumberBase<IntPtr>.MinMagnitudeNumber(IntPtr, IntPtr)	Porovná dvě hodnoty k výpočtu, které mají menší velikost a vrátí druhou hodnotu, pokud je vstup NaN.
INumberBase<IntPtr>.One	Získá hodnotu 1 pro typ.
INumberBase<IntPtr>.Radix	Získá radix nebo základ pro typ.
INumberBase<IntPtr>.TryConvertFromChecked<TOther>(TOther, IntPtr)	Představuje celé číslo se signedem, kde je bitová šířka stejná jako ukazatel.
INumberBase<IntPtr>.TryConvertFromSaturating<TOther>(TOther, IntPtr)	Představuje celé číslo se signedem, kde je bitová šířka stejná jako ukazatel.
INumberBase<IntPtr>.TryConvertFromTruncating<TOther>(TOther, IntPtr)	Představuje celé číslo se signedem, kde je bitová šířka stejná jako ukazatel.
INumberBase<IntPtr>.TryConvertToChecked<TOther>(IntPtr, TOther)	Pokusí se převést instanci aktuálního typu na jiný typ a vyvolá výjimku přetečení pro všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu.
INumberBase<IntPtr>.TryConvertToSaturating<TOther>(IntPtr, TOther)	Pokusí se převést instanci aktuálního typu na jiný typ a nasytí všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu.
INumberBase<IntPtr>.TryConvertToTruncating<TOther>(IntPtr, TOther)	Pokusí se převést instanci aktuálního typu na jiný typ a zkrátí všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu.
INumberBase<IntPtr>.Zero	Získá hodnotu 0 pro typ.
ISerializable.GetObjectData(SerializationInfo, StreamingContext)	Naplní objekt SerializationInfo daty potřebnými k serializaci aktuálního objektu IntPtr.
IShiftOperators<IntPtr,Int32,IntPtr>.LeftShift(IntPtr, Int32)	Posune hodnotu doleva o danou částku.
IShiftOperators<IntPtr,Int32,IntPtr>.RightShift(IntPtr, Int32)	Posune hodnotu doprava o danou částku.
IShiftOperators<IntPtr,Int32,IntPtr>.UnsignedRightShift(IntPtr, Int32)	Posune hodnotu doprava o danou částku.
ISignedNumber<IntPtr>.NegativeOne	Získá hodnotu -1 pro typ.
ISubtractionOperators<IntPtr,IntPtr,IntPtr>.CheckedSubtraction(IntPtr, IntPtr)	Odečte dvě hodnoty pro výpočet jejich rozdílu.
ISubtractionOperators<IntPtr,IntPtr,IntPtr>.Subtraction(IntPtr, IntPtr)	Odečte dvě hodnoty pro výpočet jejich rozdílu.
IUnaryNegationOperators<IntPtr,IntPtr>.CheckedUnaryNegation(IntPtr)	Vypočítá zaškrtnutou unární negaci hodnoty.
IUnaryNegationOperators<IntPtr,IntPtr>.UnaryNegation(IntPtr)	Vypočítá unární negaci hodnoty.
IUnaryPlusOperators<IntPtr,IntPtr>.UnaryPlus(IntPtr)	Vypočítá unární plus hodnoty.

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