IntPtr Struktura

Definice

Obor názvů:

System

Sestavení:

System.Runtime.dll

Zdroj:

IntPtr.cs

Představuje celé číslo se sadou, 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ání jeho délky provede následující:

1. Zavolá metodu Marshal.StringToHGlobalAnsi pro zkopírování řetězce Unicode do nespravované paměti jako znak ANSI (jeden 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 pro C++, F# a C# se přetypuje na ukazatel na bajt.

2. Volá metodu Marshal.AllocHGlobal k přidělení stejného počtu 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 pro 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 do konce bloku paměti.

   Příklady V jazycích 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í o jednu méně než délku řetězce na počáteční adresu řetězce ANSI. Vzhledem k tomu, že ukazatel nespravovaného řetězce nyní ukazuje 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.

   Visual Basic příklad volá metodu Marshal.ReadByte(IntPtr, Int32) čtení bajtu (nebo jednobajtů znak) v zadaném posunu od spravovaného ukazatele na řetězec ANSI. Posun se každou iterací smyčky navyšuje. Potom 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. Potom sníží offsethodnotu .

   Příklady v jazycích C#, F# a C++ provádějí operaci kopírování, poté zmenší ukazatel na adresu dalšího umístění v nespravovaném řetězci ANSI a navyšují ukazatel na další adresu v nespravovaném bloku.

5. Všechny příklady volají k Marshal.PtrToStringAnsi převodu nespravovaného paměťového bloku obsahujícího zkopírovaný řetězec ANSI na spravovaný objekt Unicode String .

6. Po zobrazení původních a obrácených řetězců volají všechny příklady metodu FreeHGlobal k uvolnění paměti přidělené nespravovanému řetězci ANSI a nespravovanému bloku 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 jako 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 může být používán jazyky, které podporují ukazatele, a jako běžný způsob odkazování na data mezi jazyky, které podporují a nepodporují ukazatele.

IntPtr objekty lze také použít k držení úchytů. Například instance IntPtr se ve System.IO.FileStream třídě často používají k uložení popisovačů souborů.

Poznámka

Použití IntPtr jako ukazatele nebo popisovače je náchylné k chybám a nebezpečné. Jedná se jednoduše o celočíselný typ, který se dá použít jako formát výměny pro ukazatele a popisovače, protože má stejnou velikost. Kromě specifických požadavků na výměnu, jako je například předávání dat do jazyka, který nepodporuje ukazatele, by měl být správně zadaný ukazatel použit k reprezentaci ukazatelů a SafeHandle měl by se používat 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 také implementuje IBinaryInteger<TSelf>rozhraní , IMinMaxValue<TSelf>a ISignedNumber<TSelf> .

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

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

Konstruktory

IntPtr(Int32)	Inicializuje novou instanci pomocí zadaného 32bitového celočíselného IntPtr podpisu.
IntPtr(Int64)	Inicializuje novou instanci IntPtr s použitím zadaného 64bitového celého čísla se signedmmi sadou.
IntPtr(Void*)	Inicializuje novou instanci pomocí zadaného IntPtr ukazatele na neurčeného typu.

Pole

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

Vlastnosti

MaxValue	Získá největší možnou hodnotu parametru 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 celočíselnému číslu se signýmmi hodnotou.
Clamp(IntPtr, IntPtr, IntPtr)	Upne hodnotu na minimální a maximální hodnotu včetně.
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.
CreateChecked<TOther>(TOther)	Vytvoří instanci aktuálního typu z hodnoty a 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 a 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)	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é celočíselné číslo.
IsNegative(IntPtr)	Určuje, jestli 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, jestli je hodnota mocninou dvou.
LeadingZeroCount(IntPtr)	Vypočítá počet počátečních nul v hodnotě.
Log2(IntPtr)	Vypočítá log2 hodnoty.
Max(IntPtr, IntPtr)	Porovná dvě hodnoty s výpočtem, který je větší.
MaxMagnitude(IntPtr, IntPtr)	Porovná dvě hodnoty s výpočtem, který je větší.
Min(IntPtr, IntPtr)	Porovná dvě hodnoty s výpočtem, který je menší.
MinMagnitude(IntPtr, IntPtr)	Porovná dvě hodnoty s výpočtem, který je menší.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Parsuje rozsah znaků UTF-8 na hodnotu.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Parsuje rozsah znaků UTF-8 na hodnotu.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Parsuje rozsah znaků na hodnotu.
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 signovaný nativní celočíselný ekvivalent.
Parse(String)	Převede řetězcovou reprezentaci čísla na jeho znakový nativní celočíselný ekvivalent.
Parse(String, IFormatProvider)	Převede řetězcovou reprezentaci čísla v zadaném formátu specifickém pro jazykovou verzi na jeho signovaný nativní celočíselný ekvivalent.
Parse(String, NumberStyles)	Převede řetězcovou reprezentaci čísla v zadaném stylu na jeho nativní celočíselný ekvivalent se znaky.
Parse(String, NumberStyles, IFormatProvider)	Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho signovaný nativní celočíselný ekvivalent.
PopCount(IntPtr)	Vypočítá počet bitů, které jsou nastaveny v hodnotě.
RotateLeft(IntPtr, Int32)	Otočí hodnotu zbývající o danou částku.
RotateRight(IntPtr, Int32)	Otočí hodnotu doprava o danou částku.
Sign(IntPtr)	Vypočítá znaménko hodnoty.
Subtract(IntPtr, Int32)	Odečte odsazení od celého čísla signedho. .
ToInt32()	Převede hodnotu této instance na 32bitové podepsané celé číslo.
ToInt64()	Převede hodnotu této instance na 64bitové celé číslo se sadou se sadou.
ToPointer()	Převede hodnotu této instance na ukazatel na neurčeného typu.
ToString()	Převede číselnou hodnotu aktuálního IntPtr objektu na ekvivalentní řetězcovou reprezentaci.
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)	Formá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 zadané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 parsovat rozsah znaků UTF-8 na hodnotu.
TryParse(ReadOnlySpan<Byte>, IntPtr)	Pokusí se převést znakový rozsah UTF-8 obsahující řetězcové vyjádření čísla na jeho ekvivalent celého čísla se znaménkem.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, IntPtr)	Pokusí se parsovat rozsah znaků UTF-8 na hodnotu.
TryParse(ReadOnlySpan<Char>, IFormatProvider, IntPtr)	Pokusí se parsovat řetězec na hodnotu.
TryParse(ReadOnlySpan<Char>, IntPtr)	Převede rozsah znaků reprezentace čísla jen pro čtení na jeho znaménku nativní celočíselný ekvivalent. Vrácená hodnota označuje, jestli převod proběhl úspěšně.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, IntPtr)	Převede rozsah znaků reprezentace čísla jen pro čtení v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho nativní celočíselný ekvivalent se znaménkem. Vrácená hodnota označuje, jestli převod proběhl úspěšně.
TryParse(String, IFormatProvider, IntPtr)	Pokusí se parsovat řetězec na hodnotu.
TryParse(String, IntPtr)	Převede řetězcovou reprezentaci čísla na jeho signedý nativní celočíselný ekvivalent. 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 symbol nativní celočíselný ekvivalent. Vrácená hodnota označuje, jestli převod proběhl úspěšně.

Operátory

Addition(IntPtr, Int32)	Přidá posun k celočíselnému číslu se signýmmi hodnotou.
Equality(IntPtr, IntPtr)	Určuje, zda jsou obě zadané instance objektu IntPtr stejné.
Explicit(Int32 to IntPtr)	Převede hodnotu 32bitového celočíselného čísla se signoumm sadou na IntPtrhodnotu .
Explicit(Int64 to IntPtr)	Převede hodnotu 64bitového celočíselného čísla se signoumm sadou na IntPtrhodnotu .
Explicit(IntPtr to Int32)	Převede hodnotu zadaného IntPtr na 32bitové celé číslo se signoum sadou.
Explicit(IntPtr to Int64)	Převede hodnotu zadaného IntPtr na celé číslo se 64bitovým signedm. .
Explicit(IntPtr to Void*)	Převede hodnotu zadaného IntPtr na ukazatel na neurčeného typu. Toto rozhraní API neodpovídá specifikaci CLS.
Explicit(Void* to IntPtr)	Převede zadaný ukazatel na neurčeného typu na IntPtr. 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 odsazení od celého čísla signedho. .

Explicitní implementace rozhraní

IAdditionOperators<IntPtr,IntPtr,IntPtr>.Addition(IntPtr, IntPtr)	Sečte dvě hodnoty pro výpočet jejich součtu.
IAdditionOperators<IntPtr,IntPtr,IntPtr>.CheckedAddition(IntPtr, IntPtr)	Sečte dvě hodnoty pro výpočet jejich součtu.
IAdditiveIdentity<IntPtr,IntPtr>.AdditiveIdentity	Získá přídavnou 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ší dvě reprezentace komplementu aktuální hodnoty.
IBinaryInteger<IntPtr>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, IntPtr)	Představuje celé číslo se sadou, kde je bitová šířka stejná jako ukazatel.
IBinaryInteger<IntPtr>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, IntPtr)	Představuje celé číslo se sadou, kde je bitová šířka stejná jako ukazatel.
IBinaryInteger<IntPtr>.TryWriteBigEndian(Span<Byte>, Int32)	Pokusí se zapsat aktuální hodnotu do daného rozsahu ve formátu big-endian.
IBinaryInteger<IntPtr>.TryWriteLittleEndian(Span<Byte>, Int32)	Pokusí se zapsat aktuální hodnotu do daného rozsahu ve formátu little-endian.
IBinaryNumber<IntPtr>.AllBitsSet	Získá instanci binárního typu, ve kterém jsou nastaveny všechny bity.
IBitwiseOperators<IntPtr,IntPtr,IntPtr>.BitwiseAnd(IntPtr, IntPtr)	Vypočítá bitové hodnoty 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é hodnoty s doplňkem.
IComparisonOperators<IntPtr,IntPtr,Boolean>.GreaterThan(IntPtr, IntPtr)	Porovná dvě hodnoty a určí, která 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)	Sníží hodnotu.
IDecrementOperators<IntPtr>.Decrement(IntPtr)	Sníží hodnotu.
IDivisionOperators<IntPtr,IntPtr,IntPtr>.Division(IntPtr, IntPtr)	Vydělí jednu hodnotu jinou za účelem výpočtu jejich podílu.
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)	Vydělí dvě hodnoty za účelem výpočtu jejich modulu nebo zbytku.
IMultiplicativeIdentity<IntPtr,IntPtr>.MultiplicativeIdentity	Získá násobitelnou identitu aktuálního typu.
IMultiplyOperators<IntPtr,IntPtr,IntPtr>.CheckedMultiply(IntPtr, IntPtr)	Vynásobí dvě hodnoty a vypočítá jejich součin.
IMultiplyOperators<IntPtr,IntPtr,IntPtr>.Multiply(IntPtr, IntPtr)	Vynásobí dvě hodnoty a vypočítá jejich součin.
INumber<IntPtr>.MaxNumber(IntPtr, IntPtr)	Porovná dvě hodnoty s výpočtem, který je větší, a vrátí druhou hodnotu, pokud je NaNvstup .
INumber<IntPtr>.MinNumber(IntPtr, IntPtr)	Porovná dvě hodnoty s výpočtem, který je menší, a vrátí druhou hodnotu, pokud je NaNvstup .
INumberBase<IntPtr>.IsCanonical(IntPtr)	Určuje, jestli je hodnota v kanonické reprezentaci.
INumberBase<IntPtr>.IsComplexNumber(IntPtr)	Určuje, jestli hodnota představuje komplexní číslo.
INumberBase<IntPtr>.IsFinite(IntPtr)	Určuje, jestli je hodnota konečná.
INumberBase<IntPtr>.IsImaginaryNumber(IntPtr)	Určuje, jestli hodnota představuje čisté imaginární číslo.
INumberBase<IntPtr>.IsInfinity(IntPtr)	Určuje, jestli je hodnota nekonečná.
INumberBase<IntPtr>.IsInteger(IntPtr)	Určuje, jestli hodnota představuje integrální číslo.
INumberBase<IntPtr>.IsNaN(IntPtr)	Určuje, jestli je hodnota NaN.
INumberBase<IntPtr>.IsNegativeInfinity(IntPtr)	Určuje, jestli je hodnota záporná nekonečno.
INumberBase<IntPtr>.IsNormal(IntPtr)	Určuje, jestli je hodnota normální.
INumberBase<IntPtr>.IsPositiveInfinity(IntPtr)	Určuje, jestli je hodnota kladné nekonečno.
INumberBase<IntPtr>.IsRealNumber(IntPtr)	Určuje, jestli hodnota představuje reálné číslo.
INumberBase<IntPtr>.IsSubnormal(IntPtr)	Určuje, jestli je hodnota podnormální.
INumberBase<IntPtr>.IsZero(IntPtr)	Určuje, zda je hodnota nula.
INumberBase<IntPtr>.MaxMagnitudeNumber(IntPtr, IntPtr)	Porovná dvě hodnoty pro výpočet, který má větší velikost a vrátí druhou hodnotu, pokud je NaNvstup .
INumberBase<IntPtr>.MinMagnitudeNumber(IntPtr, IntPtr)	Porovná dvě hodnoty pro výpočet, který má menší velikost a vrátí druhou hodnotu, pokud je NaNvstup .
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 sadou, kde je bitová šířka stejná jako ukazatel.
INumberBase<IntPtr>.TryConvertFromSaturating<TOther>(TOther, IntPtr)	Představuje celé číslo se sadou, kde je bitová šířka stejná jako ukazatel.
INumberBase<IntPtr>.TryConvertFromTruncating<TOther>(TOther, IntPtr)	Představuje celé číslo se sadou, 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, 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, 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í SerializationInfo objekt daty potřebnými k serializaci aktuálního IntPtr objektu.
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á zkontrolované unární negace 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