IntPtr.ToPointer Método

Definición

Importante

Esta API no es conforme a CLS.

Convierte el valor de esta instancia a un puntero a un tipo no especificado.Converts the value of this instance to a pointer to an unspecified type.

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

Devoluciones

Void*

Puntero a Void; es decir, puntero a memoria que contiene datos de un tipo no especificado.A pointer to Void; that is, a pointer to memory containing data of an unspecified type.

Atributos

Ejemplos

En el ejemplo siguiente se usan punteros administrados para invertir los caracteres de una matriz.The following example uses managed pointers to reverse the characters in an array. Después de inicializar un String objeto y de obtener su longitud, hace lo siguiente:After it initializes a String object and gets its length, it does the following:

  • Llama al Marshal.StringToHGlobalAnsi método para copiar la cadena Unicode en la memoria no administrada como caracteres ANSI (un byte).Calls the Marshal.StringToHGlobalAnsi method to copy the Unicode string to unmanaged memory as ANSI (one-byte) characters. El método devuelve un IntPtr objeto que apunta al principio de la cadena no administrada.The method returns an IntPtr object that points to the beginning of the unmanaged string.

  • Llama al Marshal.AllocHGlobal método para asignar el mismo número de bytes que ocupa la cadena no administrada.Calls the Marshal.AllocHGlobal method to allocate the same number of bytes as the unmanaged string occupies. El método devuelve un IntPtr objeto que apunta al principio del bloque de memoria no administrada.The method returns an IntPtr object that points to the beginning of the unmanaged block of memory.

  • Llama al ToPointer método para obtener un puntero no administrado a la dirección inicial de la cadena y el bloque de memoria no administrado, y agrega una cadena inferior a la longitud de la cadena a la dirección de inicio de la cadena 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. Dado que el puntero de la cadena no administrada apunta ahora al final de la cadena, la operación de copia copiará un carácter desde el final de la cadena hasta el inicio del bloque de 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 bucle para copiar cada carácter de la cadena en el bloque de memoria no administrado.Uses a loop to copy each character from the string to the unmanaged block of memory. Después de cada operación de copia, se reduce el puntero a la dirección de la siguiente ubicación en la cadena ANSI no administrada y se incrementa el puntero a la siguiente dirección del bloque no administrado.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.

  • Llama Marshal.PtrToStringAnsi a para convertir el bloque de memoria no administrada que contiene la cadena ANSI copiada en un objeto Unicode administrado String .Calls the Marshal.PtrToStringAnsi to convert the unmanaged memory block containing the copied ANSI string to a managed Unicode String object.

  • Después de mostrar las cadenas originales e invertidas, llama al Marshal.FreeHGlobal método para liberar la memoria asignada para la cadena ANSI no administrada y el bloque de memoria no administrado.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

Se aplica a