IntPtr.ToPointer IntPtr.ToPointer IntPtr.ToPointer Method

Definizione

Importante

Questa API non è conforme a CLS.

Converte il valore dell'istanza in un puntatore a un tipo non specificato.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>

Restituisce

Void*

Puntatore all'oggetto Void, ovvero puntatore a una memoria contenente dati di un tipo non specificato.A pointer to Void; that is, a pointer to memory containing data of an unspecified type.

Esempi

Nell'esempio seguente vengono usati i puntatori gestiti per invertire i caratteri in una matrice.The following example uses managed pointers to reverse the characters in an array. Dopo l'inizializzazione String di un oggetto e la relativa lunghezza, viene eseguito quanto segue:After it initializes a String object and gets its length, it does the following:

  • Chiama il Marshal.StringToHGlobalAnsi metodo per copiare la stringa Unicode nella memoria non gestita come caratteri ANSI (a un byte).Calls the Marshal.StringToHGlobalAnsi method to copy the Unicode string to unmanaged memory as ANSI (one-byte) characters. Il metodo restituisce un IntPtr oggetto che punta all'inizio della stringa non gestita.The method returns an IntPtr object that points to the beginning of the unmanaged string.

  • Chiama il Marshal.AllocHGlobal metodo per allocare lo stesso numero di byte occupato dalla stringa non gestita.Calls the Marshal.AllocHGlobal method to allocate the same number of bytes as the unmanaged string occupies. Il metodo restituisce un IntPtr oggetto che punta all'inizio del blocco di memoria non gestita.The method returns an IntPtr object that points to the beginning of the unmanaged block of memory.

  • Chiama il ToPointer metodo per ottenere un puntatore non gestito all'indirizzo iniziale della stringa e il blocco di memoria non gestita e aggiunge un valore inferiore alla lunghezza della stringa all'indirizzo iniziale della stringa ANSI.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. Poiché il puntatore di stringa non gestita punta ora alla fine della stringa, l'operazione di copia copierà un carattere dalla fine della stringa all'inizio del blocco di memoria.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.

  • Usa un ciclo per copiare ogni carattere dalla stringa al blocco di memoria non gestito.Uses a loop to copy each character from the string to the unmanaged block of memory. Al termine di ogni operazione di copia, il puntatore viene decrementato all'indirizzo della posizione successiva nella stringa ANSI non gestita e il puntatore viene incrementato all'indirizzo successivo nel blocco non gestito.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.

  • Chiama per convertire il blocco di memoria non gestita contenente la stringa ANSI copiata in un oggetto Unicode String gestito. Marshal.PtrToStringAnsiCalls the Marshal.PtrToStringAnsi to convert the unmanaged memory block containing the copied ANSI string to a managed Unicode String object.

  • Dopo aver visualizzato le stringhe originali e invertite, chiama Marshal.FreeHGlobal il metodo per liberare la memoria allocata per la stringa ANSI non gestita e il blocco di memoria non gestita.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

Si applica a