IntPtr.ToPointer IntPtr.ToPointer IntPtr.ToPointer Method

Définition

Important

Cette API n’est pas conforme CLS.

Convertit la valeur de cette instance en pointeur vers un type non spécifié.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>

Retours

Void*

Pointeur vers Void ; c'est-à-dire, un pointeur vers une mémoire contenant des données de type non spécifié.A pointer to Void; that is, a pointer to memory containing data of an unspecified type.

Exemples

L’exemple suivant utilise des pointeurs managés pour inverser les caractères d’un tableau.The following example uses managed pointers to reverse the characters in an array. Après avoir initialisé un String objet et obtient sa longueur, il effectue les opérations suivantes :After it initializes a String object and gets its length, it does the following:

  • Appelle la Marshal.StringToHGlobalAnsi méthode pour copier la chaîne Unicode dans la mémoire non managée sous forme de caractères ANSI (un octet).Calls the Marshal.StringToHGlobalAnsi method to copy the Unicode string to unmanaged memory as ANSI (one-byte) characters. La méthode retourne un IntPtr objet qui pointe vers le début de la chaîne non managée.The method returns an IntPtr object that points to the beginning of the unmanaged string.

  • Appelle la Marshal.AllocHGlobal méthode pour allouer le même nombre d’octets que celui occupé par la chaîne non managée.Calls the Marshal.AllocHGlobal method to allocate the same number of bytes as the unmanaged string occupies. La méthode retourne un IntPtr objet qui pointe vers le début du bloc de mémoire non managé.The method returns an IntPtr object that points to the beginning of the unmanaged block of memory.

  • Appelle la ToPointer méthode pour recevoir un pointeur non managé vers l’adresse de début de la chaîne et le bloc de mémoire non managée, et ajoute une valeur inférieure à la longueur de la chaîne à l’adresse de départ de la chaîne 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. Étant donné que le pointeur de chaîne non managé pointe maintenant vers la fin de la chaîne, l’opération de copie copie un caractère à partir de la fin de la chaîne jusqu’au début du bloc de mémoire.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.

  • Utilise une boucle pour copier chaque caractère de la chaîne dans le bloc de mémoire non managée.Uses a loop to copy each character from the string to the unmanaged block of memory. Après chaque opération de copie, il décrémente le pointeur vers l’adresse de l’emplacement suivant dans la chaîne ANSI non managée et incrémente le pointeur vers l’adresse suivante dans le bloc non managé.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.

  • Appelle pour convertir le bloc de mémoire non managé contenant la chaîne ANSI copiée en objet Unicode String managé. Marshal.PtrToStringAnsiCalls the Marshal.PtrToStringAnsi to convert the unmanaged memory block containing the copied ANSI string to a managed Unicode String object.

  • Après avoir affiché les chaînes d’origine et inversée Marshal.FreeHGlobal , appelle la méthode pour libérer la mémoire allouée pour la chaîne ANSI non managée et le bloc de mémoire non managée.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

S’applique à