IntPtr.ToPointer IntPtr.ToPointer IntPtr.ToPointer Method

Definition

Wichtig

Diese API ist nicht CLS-kompatibel.

Konvertiert den Wert dieser Instanz in einen Zeiger auf einen nicht angegebenen Typ.Converts the value of this instance to a pointer to an unspecified type.

public:
 void* ToPointer();
[System.CLSCompliant(false)]
public void* ToPointer ();
member this.ToPointer : unit -> nativeptr<unit>

Gibt zurück

Void*

Ein Zeiger auf Void, d. h. ein Zeiger auf Speicher, der Daten eines nicht angegebenen Typs enthält.A pointer to Void; that is, a pointer to memory containing data of an unspecified type.

Beispiele

Im folgenden Beispiel wird die verwaltete Zeiger, der Zeichen in einem Array umzukehren.The following example uses managed pointers to reverse the characters in an array. Nach dem Initialisieren einer String -Objekt und ruft seine Länge bewirkt Folgendes:After it initializes a String object and gets its length, it does the following:

  • Ruft die Marshal.StringToHGlobalAnsi Methode, um die Unicode-Zeichenfolge als ANSI (1-Byte-Zeichen) in nicht verwalteten Speicher zu kopieren.Calls the Marshal.StringToHGlobalAnsi method to copy the Unicode string to unmanaged memory as ANSI (one-byte) characters. Die Methode gibt ein IntPtr -Objekt, auf den Anfang des nicht verwalteten Zeichenfolge verweist.The method returns an IntPtr object that points to the beginning of the unmanaged string.

  • Ruft die Marshal.AllocHGlobal Methode, um die gleiche Anzahl von Bytes zu belegen, wie die nicht verwaltete Zeichenfolge belegt.Calls the Marshal.AllocHGlobal method to allocate the same number of bytes as the unmanaged string occupies. Die Methode gibt ein IntPtr Objekt, das an den Anfang des nicht verwaltete Speicherblocks zeigt.The method returns an IntPtr object that points to the beginning of the unmanaged block of memory.

  • Ruft die ToPointer Methode, um ein nicht verwalteter Zeiger auf die Startadresse der Zeichenfolge und der nicht verwalteten Speicherblock zu erhalten und fügt eine kleiner als die Länge der Zeichenfolge, die die Startadresse der ANSI-Zeichenfolge.Calls the ToPointer method to get an unmanaged pointer to the starting address of the string and the unmanaged block of memory, and adds one less than the length of the string to the starting address of the ANSI string. Da der nicht verwalteten Zeichenfolgenzeiger jetzt bis zum Ende der Zeichenfolge verweist, wird der Kopiervorgang ein Zeichen vom Ende der Zeichenfolge an den Anfang des Speicherblocks kopieren.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.

  • Verwendet eine Schleife um jedes Zeichen aus der Zeichenfolge in den nicht verwalteten Speicherblock zu kopieren.Uses a loop to copy each character from the string to the unmanaged block of memory. Nach jedem Kopiervorgang es verringert den Zeiger auf die Adresse des nächsten Speicherort in der nicht verwalteten ANSI-Zeichenfolge und den Zeiger auf die nächste Adresse im nicht verwalteten Block erhöht.After each copy operation, it decrements the pointer to the address of the next location in the unmanaged ANSI string and increments the pointer to the next address in the unmanaged block.

  • Ruft die Marshal.PtrToStringAnsi den nicht verwaltete Speicherblock, der mit der kopierten ANSI-Zeichenfolge in eine verwaltete Unicode konvertiert String Objekt.Calls the Marshal.PtrToStringAnsi to convert the unmanaged memory block containing the copied ANSI string to a managed Unicode String object.

  • Nach dem Anzeigen der ursprünglichen und umgekehrten Zeichenfolgen, ruft der Marshal.FreeHGlobal Methode, um die Speichermenge für die nicht verwalteten ANSI-Zeichenfolge und der nicht verwalteten Speicherblock freizugeben.After displaying the original and reversed strings, calls the Marshal.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

Gilt für: