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 werden verwaltete Zeiger verwendet, um die Zeichen in einem Array umzukehren.The following example uses managed pointers to reverse the characters in an array. Nachdem Sie ein String -Objekt initialisiert und seine Länge erhalten hat, wird Folgendes ausgeführt:After it initializes a String object and gets its length, it does the following:

  • Ruft die Marshal.StringToHGlobalAnsi -Methode auf, um die Unicode-Zeichenfolge als ANSI-Zeichen (ein Byte) in den 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 IntPtr ein Objekt zurück, das auf den Anfang der nicht verwalteten Zeichenfolge zeigt.The method returns an IntPtr object that points to the beginning of the unmanaged string.

  • Ruft die Marshal.AllocHGlobal -Methode auf, um die gleiche Anzahl von Bytes zuzuordnen, 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 IntPtr ein Objekt zurück, das auf den Anfang des nicht verwalteten Speicherblocks zeigt.The method returns an IntPtr object that points to the beginning of the unmanaged block of memory.

  • Ruft die ToPointer -Methode auf, um einen nicht verwalteten Zeiger auf die Startadresse der Zeichenfolge und den nicht verwalteten Speicherblock zu erhalten, und fügt eine geringere Länge als die Länge der Zeichenfolge zur Startadresse der ANSI-Zeichenfolge hinzu.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 verwaltete Zeichen folgen Zeiger nun auf das Ende der Zeichenfolge zeigt, kopiert der Kopiervorgang ein Zeichen vom Ende der Zeichenfolge bis zum Anfang des Speicherblocks.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 wird der Zeiger auf die Adresse des nächsten Speicher Orts in der nicht verwalteten ANSI-Zeichenfolge verringert und der 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 den Marshal.PtrToStringAnsi auf, um den nicht verwalteten Speicherblock mit der kopierten ANSI-Zeichenfolge String in ein verwaltetes Unicode-Objekt zu konvertieren.Calls the Marshal.PtrToStringAnsi to convert the unmanaged memory block containing the copied ANSI string to a managed Unicode String object.

  • Nachdem Sie die ursprünglichen und umgekehrten Zeichen folgen angezeigt haben Marshal.FreeHGlobal , ruft die-Methode auf, um den für die nicht verwalteten ANSI-Zeichenfolge und den nicht verwalteten Speicherblock zugeordneten Arbeitsspeicher 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: