IntPtr.ToPointer Methode

public:
 void* ToPointer();

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

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

Retouren

Een aanwijzer naar Void; dat wil gezegd, een aanwijzer naar het geheugen met gegevens van een niet-opgegeven type.

Kenmerken

CLSCompliantAttribute

Voorbeelden

In het volgende voorbeeld worden beheerde aanwijzers gebruikt om de tekens in een matrix om te draaien. Nadat een String object is geïnitialiseerd en de lengte ervan heeft opgehaald, doet het het volgende:

• Roept de Marshal.StringToHGlobalAnsi methode aan om de Unicode-tekenreeks te kopiëren naar onbeheerd geheugen als ANSI-tekens (een-byte). De methode retourneert een IntPtr object dat verwijst naar het begin van de onbeheerde tekenreeks.

• Roept de Marshal.AllocHGlobal methode aan om hetzelfde aantal bytes toe te wijzen als de niet-beheerde tekenreeks in beslag neemt. De methode retourneert een IntPtr object dat verwijst naar het begin van het onbeheerde geheugenblok.

• Roept de ToPointer methode aan om een onbeheerde aanwijzer op te halen naar het beginadres van de tekenreeks en het onbeheerde geheugenblok en voegt er één toe die kleiner is dan de lengte van de tekenreeks aan het beginadres van de ANSI-tekenreeks. Omdat de niet-beheerde tekenreeks aanwijzer nu verwijst naar het einde van de tekenreeks, kopieert de kopieerbewerking een teken van het einde van de tekenreeks naar het begin van het geheugenblok.

• Hiermee wordt een lus gebruikt om elk teken van de tekenreeks naar het niet-beheerde geheugenblok te kopiëren. Na elke kopieerbewerking wordt de aanwijzer afgedwongen op het adres van de volgende locatie in de onbeheerde ANSI-tekenreeks en wordt de aanwijzer verhoogd naar het volgende adres in het niet-beheerde blok.

• Roept het Marshal.PtrToStringAnsi aan om het niet-beheerde geheugenblok met de gekopieerde ANSI-tekenreeks te converteren naar een beheerd Unicode-object String .

• Nadat de oorspronkelijke en omgekeerde tekenreeksen zijn weergegeven, roept u de Marshal.FreeHGlobal methode aan om het geheugen vrij te maken dat is toegewezen voor de niet-beheerde ANSI-tekenreeks en het onbeheerde geheugenblok.

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