IntPtr Struktura

Definicja

Typ specyficzny dla platformy, który jest używany do reprezentowania wskaźnika lub dojścia.A platform-specific type that is used to represent a pointer or a handle.

public value class IntPtr : System::Runtime::Serialization::ISerializable
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public struct IntPtr : System.Runtime.Serialization.ISerializable
type nativeint = struct
    interface ISerializable
Public Structure IntPtr
Implements ISerializable
Dziedziczenie
IntPtr
Atrybuty
Implementuje

Przykłady

W poniższym przykładzie są stosowane wskaźniki zarządzane do odwrócenia znaków w tablicy.The following example uses managed pointers to reverse the characters in an array. Po zainicjowaniu String obiektu i otrzymaniu jego długości wykonuje następujące czynności:After it initializes a String object and gets its length, it does the following:

  1. Wywołuje metodę Marshal.StringToHGlobalAnsi , aby skopiować ciąg Unicode do pamięci niezarządzanej jako znak ANSI (jeden-bajtowy).Calls the Marshal.StringToHGlobalAnsi method to copy the Unicode string to unmanaged memory as an ANSI (one-byte) character. Metoda zwraca IntPtr obiekt, który wskazuje na początek niezarządzanego ciągu.The method returns an IntPtr object that points to the beginning of the unmanaged string. Przykład Visual Basic używa tego wskaźnika bezpośrednio; w C++ przykładach C# i jest rzutowane na wskaźnik do bajtu.The Visual Basic example uses this pointer directly; in the C++ and C# examples, it is cast to a pointer to a byte.

  2. Marshal.AllocHGlobal Wywołuje metodę, aby przydzielić taką samą liczbę bajtów co niezarządzany ciąg.Calls the Marshal.AllocHGlobal method to allocate the same number of bytes as the unmanaged string occupies. Metoda zwraca IntPtr obiekt, który wskazuje na początek niezarządzanego bloku pamięci.The method returns an IntPtr object that points to the beginning of the unmanaged block of memory. Przykład Visual Basic używa tego wskaźnika bezpośrednio; w C++ przykładach C# i jest rzutowane na wskaźnik do bajtu.The Visual Basic example uses this pointer directly; in the C++ and C# examples, it is cast to a pointer to a byte.

  3. W Visual Basic przykładzie zdefiniowano zmienną o offset nazwie, która jest równa długości ciągu ANSI.The Visual Basic example defines a variable named offset that is equal to the length of the ANSI string. Służy do określania przesunięcia w pamięci niezarządzanej, do której jest kopiowana Następna karta w ciągu ANSI.It is used to determine the offset into unmanaged memory to which the next charter in the ANSI string is copied. Ponieważ jej wartość początkowa jest długością ciągu, operacja kopiowania skopiuje znak z początku ciągu do końca bloku pamięci.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.

    Przykłady C# C++ wywołują metodę,abyuzyskaćniezarządzanywskaźnikdoadresupoczątkowegociąguiniezarządzanegoblokupamięciorazdodaćjednąmniejsząniżdługośćciągudoadresuToPointer początkowego ciągu 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. Ponieważ wskaźnik niezarządzanego ciągu wskazuje teraz koniec ciągu, operacja kopiowania skopiuje znak z końca ciągu do początku bloku pamięci.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. Używa pętli do kopiowania każdego znaku z ciągu do niezarządzanego bloku pamięci.Uses a loop to copy each character from the string to the unmanaged block of memory.

    Visual Basic przykład wywołuje metodę, Marshal.ReadByte(IntPtr, Int32) aby odczytać bajt (lub jeden-bajtowy znak) w określonym przesunięciu ze wskaźnika zarządzanego do ciągu 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. Przesunięcie jest zwiększane przy każdej iteracji pętli.The offset is incremented with each iteration of the loop. Następnie wywołuje metodę, Marshal.WriteByte(IntPtr, Int32, Byte) aby napisać bajt do adresu pamięci zdefiniowanego przez adres początkowy bloku niezarządzanej pamięci Plus. offsetIt 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. Następnie zmniejsza offset.It then decrements offset.

    Przykłady C# i C++ wykonują operację kopiowania, a następnie zmniejszają wskaźnik do adresu kolejnej lokalizacji w niezarządzanym ciągu ANSI i zwiększają wskaźnik do następnego adresu w bloku niezarządzanym.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. Wszystkie przykłady wywołują Marshal.PtrToStringAnsi metodę, aby przekonwertować niezarządzany blok pamięci zawierający skopiowany ciąg ANSI do zarządzanego String obiektu Unicode.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 wyświetleniu oryginalnych i odwróconych ciągów wszystkie przykłady wywołują FreeHGlobal metodę, aby zwolnić pamięć przydzieloną dla niezarządzanego ciągu ANSI i niezarządzany blok pamięci.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

Uwagi

IntPtr Typ jest przeznaczony do liczby całkowitej, której rozmiar jest specyficzny dla platformy.The IntPtr type is designed to be an integer whose size is platform-specific. Oznacza to, że wystąpienie tego typu powinno być 32-bitów na 32-bitowym sprzęcie i systemach operacyjnych oraz 64-bits na urządzeniach 64-bitowych i systemach operacyjnych.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.

IntPtr Typ może być używany przez Języki, które obsługują wskaźniki, i jako wspólny środek odnoszący się do danych między językami, które wykonują i nie obsługują wskaźników.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.

IntPtrobiekty mogą być również używane do przechowywania uchwytów.IntPtr objects can also be used to hold handles. Na przykład wystąpienia IntPtr są używane System.IO.FileStream w szerokim stopniu w klasie do przechowywania dojść do plików.For example, instances of IntPtr are used extensively in the System.IO.FileStream class to hold file handles.

Typ jest zgodny ze specyfikacją CLS, UIntPtr podczas gdy typ nie jest. IntPtrThe IntPtr type is CLS-compliant, while the UIntPtr type is not. IntPtr Tylko typ jest używany w środowisku uruchomieniowym języka wspólnego.Only the IntPtr type is used in the common language runtime. Typ jest dostarczany głównie w celu utrzymania symetrii architektury IntPtr z typem. UIntPtrThe UIntPtr type is provided mostly to maintain architectural symmetry with the IntPtr type.

Ten typ implementuje ISerializable interfejs.This type implements the ISerializable interface.

Konstruktory

IntPtr(Int32)

Inicjuje nowe wystąpienie IntPtr przy użyciu określonego wskaźnika 32-bitowego lub dojścia.Initializes a new instance of IntPtr using the specified 32-bit pointer or handle.

IntPtr(Int64)

Inicjuje nowe wystąpienie IntPtr przy użyciu określonego wskaźnika 64-bitowego.Initializes a new instance of IntPtr using the specified 64-bit pointer.

IntPtr(Void*)

Inicjuje nowe wystąpienie IntPtr , używając określonego wskaźnika do nieokreślonego typu.Initializes a new instance of IntPtr using the specified pointer to an unspecified type.

Pola

Zero

Pole tylko do odczytu reprezentujące wskaźnik lub uchwyt, który został zainicjowany do zera.A read-only field that represents a pointer or handle that has been initialized to zero.

Właściwości

Size

Pobiera rozmiar tego wystąpienia.Gets the size of this instance.

Metody

Add(IntPtr, Int32)

Dodaje przesunięcie do wartości wskaźnika.Adds an offset to the value of a pointer.

Equals(Object)

Zwraca wartość wskazującą, czy to wystąpienie jest równe podanemu obiektowi.Returns a value indicating whether this instance is equal to a specified object.

GetHashCode()

Zwraca kod skrótu dla tego wystąpienia.Returns the hash code for this instance.

Subtract(IntPtr, Int32)

Odejmuje przesunięcie od wartości wskaźnika.Subtracts an offset from the value of a pointer.

ToInt32()

Konwertuje wartość tego wystąpienia na 32-bitową liczbę całkowitą ze znakiem.Converts the value of this instance to a 32-bit signed integer.

ToInt64()

Konwertuje wartość tego wystąpienia na 64-bitową liczbę całkowitą ze znakiem.Converts the value of this instance to a 64-bit signed integer.

ToPointer()

Konwertuje wartość tego wystąpienia na wskaźnik do nieokreślonego typu.Converts the value of this instance to a pointer to an unspecified type.

ToString()

Konwertuje wartość liczbową bieżącego IntPtr obiektu na jego równoważną reprezentację w postaci ciągu.Converts the numeric value of the current IntPtr object to its equivalent string representation.

ToString(String)

Konwertuje wartość liczbową bieżącego IntPtr obiektu na jego równoważną reprezentację w postaci ciągu.Converts the numeric value of the current IntPtr object to its equivalent string representation.

Operatory

Addition(IntPtr, Int32)

Dodaje przesunięcie do wartości wskaźnika.Adds an offset to the value of a pointer.

Equality(IntPtr, IntPtr)

Określa, IntPtr czy dwa określone wystąpienia są równe.Determines whether two specified instances of IntPtr are equal.

Explicit(Int32 to IntPtr)

Konwertuje wartość 32-bitowej podpisanej liczby całkowitej na IntPtr.Converts the value of a 32-bit signed integer to an IntPtr.

Explicit(Int64 to IntPtr)

Konwertuje wartość 64-bitowej podpisanej liczby całkowitej na IntPtr.Converts the value of a 64-bit signed integer to an IntPtr.

Explicit(IntPtr to Int32)

Konwertuje wartość określoną IntPtr na 32-bitową liczbę całkowitą ze znakiem.Converts the value of the specified IntPtr to a 32-bit signed integer.

Explicit(IntPtr to Int64)

Konwertuje wartość określoną IntPtr na 64-bitową liczbę całkowitą ze znakiem.Converts the value of the specified IntPtr to a 64-bit signed integer.

Explicit(IntPtr to Void*)

Konwertuje wartość określoną IntPtr na wskaźnik do nieokreślonego typu.Converts the value of the specified IntPtr to a pointer to an unspecified type.

Ten interfejs API nie jest zgodny ze specyfikacją CLS.This API is not CLS-compliant.

Explicit(Void* to IntPtr)

Konwertuje określony wskaźnik na nieokreślony typ do IntPtr.Converts the specified pointer to an unspecified type to an IntPtr.

Ten interfejs API nie jest zgodny ze specyfikacją CLS.This API is not CLS-compliant.

Inequality(IntPtr, IntPtr)

Określa, IntPtr czy dwa określone wystąpienia nie są równe.Determines whether two specified instances of IntPtr are not equal.

Subtraction(IntPtr, Int32)

Odejmuje przesunięcie od wartości wskaźnika.Subtracts an offset from the value of a pointer.

Jawne implementacje interfejsu

IEquatable<IntPtr>.Equals(IntPtr)
ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Wypełnia obiekt danymi wymaganymi do serializacji bieżącego IntPtr obiektu. SerializationInfoPopulates a SerializationInfo object with the data needed to serialize the current IntPtr object.

Dotyczy

Bezpieczeństwo wątkowe

Ten typ jest bezpieczny wątkowo.This type is thread safe.

Zobacz też