IntPtr.ToPointer Metodo

public:
 void* ToPointer();

[System.CLSCompliant(false)]
public void* ToPointer ();

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

Restituisce

Void*

Puntatore all'oggetto Void, ovvero puntatore a una memoria contenente dati di un tipo non specificato.

Attributi

CLSCompliantAttribute

Esempio

Nell'esempio seguente vengono usati puntatori gestiti per invertire i caratteri in una matrice. Dopo l'inizializzazione di un String oggetto e la relativa lunghezza, esegue le operazioni seguenti:

• Chiama il Marshal.StringToHGlobalAnsi metodo per copiare la stringa Unicode nella memoria non gestita come caratteri ANSI (un byte). Il metodo restituisce un IntPtr oggetto che punta all'inizio della stringa non gestita.

• Chiama il Marshal.AllocHGlobal metodo per allocare lo stesso numero di byte occupato dalla stringa non gestita. Il metodo restituisce un IntPtr oggetto che punta all'inizio del blocco di memoria non gestito.

• Chiama il ToPointer metodo per ottenere un puntatore non gestito all'indirizzo iniziale della stringa e al blocco di memoria non gestito e aggiunge uno minore della lunghezza della stringa all'indirizzo iniziale della stringa ANSI. Poiché il puntatore stringa non gestito punta ora alla fine della stringa, l'operazione di copia copierà un carattere dalla fine della stringa all'inizio del blocco di memoria.

• Usa un ciclo per copiare ogni carattere dalla stringa al blocco di memoria non gestito. Dopo ogni operazione di copia, decrementa il puntatore all'indirizzo della posizione successiva nella stringa ANSI non gestita e incrementa il puntatore all'indirizzo successivo nel blocco non gestito.

• Chiama per Marshal.PtrToStringAnsi convertire il blocco di memoria non gestito contenente la stringa ANSI copiata in un oggetto Unicode String gestito.

• Dopo aver visualizzato le stringhe originali e invertite, chiama il Marshal.FreeHGlobal metodo per liberare la memoria allocata per la stringa ANSI non gestita e il blocco di memoria non gestito.

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

#nowarn "9"
open System.Runtime.InteropServices
open FSharp.NativeInterop

[<EntryPoint>]
let main _ =
    let stringA = "I seem to be turned around!"
    let mutable copylen = stringA.Length

    // Allocate HGlobal memory for source and destination strings
    let sptr = Marshal.StringToHGlobalAnsi stringA
    let dptr = Marshal.AllocHGlobal(copylen + 1)

    let mutable src: byte nativeptr = sptr.ToPointer() |> NativePtr.ofVoidPtr
    let mutable dst: byte nativeptr = dptr.ToPointer() |> NativePtr.ofVoidPtr

    if copylen > 0 then
        // set the source pointer to the end of the string
        // to do a reverse copy.
        src <- 
            NativePtr.toNativeInt src + nativeint (copylen - 1) 
            |> NativePtr.ofNativeInt

        while copylen > 0 do
            copylen <- copylen - 1
            NativePtr.read src |> NativePtr.write dst
            dst <- NativePtr.toNativeInt dst + 1n |> NativePtr.ofNativeInt
            src <- NativePtr.toNativeInt src - 1n |> NativePtr.ofNativeInt
        NativePtr.write dst 0uy

    let stringB = Marshal.PtrToStringAnsi dptr

    printfn $"Original:\n{stringA}\n"
    printfn $"Reversed:\n{stringB}"

    // Free HGlobal memory
    Marshal.FreeHGlobal dptr
    Marshal.FreeHGlobal sptr
    0

// The progam has the following output:
//
// Original:
// I seem to be turned around!
//
// Reversed:
// !dnuora denrut eb ot mees I

Si applica a