IntPtr IntPtr IntPtr IntPtr Struct

Définition

Type spécifique à la plateforme, utilisé pour représenter un pointeur ou un handle.A platform-specific type that is used to represent a pointer or a handle.

public value class IntPtr : System::Runtime::Serialization::ISerializable
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public struct IntPtr : System.Runtime.Serialization.ISerializable
type nativeint = struct
    interface ISerializable
Public Structure IntPtr
Implements ISerializable
Héritage
Attributs
Implémente

Exemples

L’exemple suivant utilise des pointeurs managés pour inverser les caractères dans un tableau.The following example uses managed pointers to reverse the characters in an array. Après avoir initialisé un String de l’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:

  1. Appelle le Marshal.StringToHGlobalAnsi méthode pour copier la chaîne Unicode à la mémoire non managée comme caractère ANSI (un octet).Calls the Marshal.StringToHGlobalAnsi method to copy the Unicode string to unmanaged memory as an ANSI (one-byte) character. 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. L’exemple Visual Basic utilise ce pointeur directement ; dans les exemples C++ et c#, elle est convertie en un pointeur vers un octet.The Visual Basic example uses this pointer directly; in the C++ and C# examples, it is cast to a pointer to a byte.

  2. Appelle le Marshal.AllocHGlobal méthode pour allouer le même nombre d’octets comme occupe de 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. L’exemple Visual Basic utilise ce pointeur directement ; dans les exemples C++ et c#, elle est convertie en un pointeur vers un octet.The Visual Basic example uses this pointer directly; in the C++ and C# examples, it is cast to a pointer to a byte.

  3. L’exemple Visual Basic définit une variable nommée offset qui est égal à la longueur de la chaîne ANSI.The Visual Basic example defines a variable named offset that is equal to the length of the ANSI string. Il est utilisé pour déterminer le décalage dans la mémoire non managée dans lequel la charte suivante dans la chaîne ANSI est copiée.It is used to determine the offset into unmanaged memory to which the next charter in the ANSI string is copied. Étant donné que sa valeur de départ est la longueur de la chaîne, l’opération de copie copie un caractère à partir du début de la chaîne à la fin du bloc de mémoire.Because its starting value is the length of the string, the copy operation will copy a character from the start of the string to the end of the memory block.

    L’appel d’exemples c# et C++ le ToPointer méthode pour obtenir un pointeur non managé à l’adresse de départ de la chaîne et le bloc non géré de la mémoire, et ils ajoutent un inférieur à la longueur de la chaîne à l’adresse de début de la chaîne ANSI.The C# and C++ examples call the ToPointer method to get an unmanaged pointer to the starting address of the string and the unmanaged block of memory, and they add 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ée 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 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.

  4. Utilise une boucle pour copier chaque caractère de la chaîne pour le bloc de mémoire non managée.Uses a loop to copy each character from the string to the unmanaged block of memory.

    L’exemple Visual Basic appelle le Marshal.ReadByte(IntPtr, Int32) méthode pour lire les octets (ou un caractère de sur un octet) à l’offset spécifié à partir du pointeur managé vers la chaîne ANSI.The Visual Basic example calls the Marshal.ReadByte(IntPtr, Int32) method to read the byte (or one-byte character) at a specified offset from the managed pointer to the ANSI string. Le décalage est incrémenté à chaque itération de la boucle.The offset is incremented with each iteration of the loop. Il appelle ensuite la Marshal.WriteByte(IntPtr, Int32, Byte) méthode pour écrire les octets à l’adresse mémoire défini par l’adresse de début du bloc non managé de mémoire plu offset.It then calls the Marshal.WriteByte(IntPtr, Int32, Byte) method to write the byte to the memory address defined by the starting address of the unmanaged block of memory plus offset. Il décrémente ensuite offset.It then decrements offset.

    Les exemples c# et C++ effectuer l’opération de copie, puis décrémentent le pointeur vers l’adresse de l’emplacement suivant dans la chaîne ANSI non managée et incrémentent le pointeur vers l’adresse suivante dans le bloc non géré.The C# and C++ examples perform the copy operation, then decrement the pointer to the address of the next location in the unmanaged ANSI string and increment the pointer to the next address in the unmanaged block.

  5. Tous les exemples appellent la Marshal.PtrToStringAnsi pour convertir le bloc de mémoire non managée qui contient la chaîne ANSI copiée Unicode managé String objet.All examples call the Marshal.PtrToStringAnsi to convert the unmanaged memory block containing the copied ANSI string to a managed Unicode String object.

  6. Après avoir affiché les chaînes d’origine et inversés, tous les exemples appellent le FreeHGlobal 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, all examples call the 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
Imports System
Imports System.Runtime.InteropServices

Public Module Example
    Public Sub Main()
        Dim stringA As String = "I seem to be turned around!"
        Dim copylen As Integer = stringA.Length

        ' Allocate HGlobal memory for source and destination strings
        Dim sptr As IntPtr = Marshal.StringToHGlobalAnsi(stringA)
        Dim dptr As IntPtr = Marshal.AllocHGlobal(copylen)
        Dim offset As Integer = copylen - 1

         For ctr As Integer = 0 To copylen - 1
            Dim b As Byte = Marshal.ReadByte(sptr, ctr)
            Marshal.WriteByte(dptr, offset, b)
            offset -= 1
         Next

        Dim stringB As String = Marshal.PtrToStringAnsi(dptr)

        Console.WriteLine("Original:{1}{0}{1}", stringA, vbCrLf)
        Console.WriteLine("Reversed:{1}{0}{1}", stringB, vbCrLf)

        ' Free HGlobal memory
        Marshal.FreeHGlobal(dptr)
        Marshal.FreeHGlobal(sptr)
    End Sub
End Module
' The example displays the following output:
'       Original:
'       I seem to be turned around!
'
'       Reversed:
'       !dnuora denrut eb ot mees I

Remarques

Le IntPtr type est conçu pour être un entier dont la taille est spécifique à la plateforme.The IntPtr type is designed to be an integer whose size is platform-specific. Autrement dit, une instance de ce type est censée être de matériel 32 bits et les systèmes d’exploitation 32 bits et 64 bits sur les systèmes d’exploitation et de matériel 64 bits.That is, an instance of this type is expected to be 32-bits on 32-bit hardware and operating systems, and 64-bits on 64-bit hardware and operating systems.

Le IntPtr type peut être utilisé par les langages qui prennent en charge les pointeurs et comme un moyen commun de faire référence aux données entre les langages qui sont et ne prennent pas en charge les pointeurs.The IntPtr type can be used by languages that support pointers, and as a common means of referring to data between languages that do and do not support pointers.

IntPtr objets peuvent également être utilisés pour contenir des handles.IntPtr objects can also be used to hold handles. Par exemple, les instances de IntPtr sont largement utilisées dans le System.IO.FileStream classe destinée à contenir les descripteurs de fichiers.For example, instances of IntPtr are used extensively in the System.IO.FileStream class to hold file handles.

Le IntPtr type est conforme CLS, alors que le UIntPtr type n’est pas.The IntPtr type is CLS-compliant, while the UIntPtr type is not. Uniquement la IntPtr type est utilisé dans le common language runtime.Only the IntPtr type is used in the common language runtime. Le UIntPtr type est fourni principalement pour assurer une symétrie architecturale avec le IntPtr type.The UIntPtr type is provided mostly to maintain architectural symmetry with the IntPtr type.

Ce type implémente le ISerializable interface.This type implements the ISerializable interface.

Constructeurs

IntPtr(Int32) IntPtr(Int32) IntPtr(Int32) IntPtr(Int32)

Initialise une nouvelle instance de IntPtr à l'aide du pointeur ou handle 32 bits spécifié.Initializes a new instance of IntPtr using the specified 32-bit pointer or handle.

IntPtr(Int64) IntPtr(Int64) IntPtr(Int64) IntPtr(Int64)

Initialise une nouvelle instance de IntPtr à l'aide du pointeur 64 bits spécifié.Initializes a new instance of IntPtr using the specified 64-bit pointer.

IntPtr(Void*) IntPtr(Void*) IntPtr(Void*) IntPtr(Void*)

Initialise une nouvelle instance de IntPtr à l'aide du pointeur spécifié vers un type non spécifié.Initializes a new instance of IntPtr using the specified pointer to an unspecified type.

Champs

Zero Zero Zero Zero

Champ en lecture seule qui représente un pointeur ou un handle remis à zéro.A read-only field that represents a pointer or handle that has been initialized to zero.

Propriétés

Size Size Size Size

Obtient la taille de cette instance.Gets the size of this instance.

Méthodes

Add(IntPtr, Int32) Add(IntPtr, Int32) Add(IntPtr, Int32) Add(IntPtr, Int32)

Ajoute un offset à la valeur d'un pointeur.Adds an offset to the value of a pointer.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Retourne une valeur indiquant si cette instance équivaut à un objet spécifié.Returns a value indicating whether this instance is equal to a specified object.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Retourne le code de hachage de cette instance.Returns the hash code for this instance.

Subtract(IntPtr, Int32) Subtract(IntPtr, Int32) Subtract(IntPtr, Int32) Subtract(IntPtr, Int32)

Soustrait un offset de la valeur d'un pointeur.Subtracts an offset from the value of a pointer.

ToInt32() ToInt32() ToInt32() ToInt32()

Convertit la valeur de cette instance en entier 32 bits signé.Converts the value of this instance to a 32-bit signed integer.

ToInt64() ToInt64() ToInt64() ToInt64()

Convertit la valeur de cette instance en entier 64 bits signé.Converts the value of this instance to a 64-bit signed integer.

ToPointer() ToPointer() ToPointer() ToPointer()

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.

ToString(String) ToString(String) ToString(String) ToString(String)

Convertit la valeur numérique de l'objet IntPtr actuel dans sa représentation sous forme chaîne équivalente.Converts the numeric value of the current IntPtr object to its equivalent string representation.

ToString() ToString() ToString() ToString()

Convertit la valeur numérique de l'objet IntPtr actuel dans sa représentation sous forme chaîne équivalente.Converts the numeric value of the current IntPtr object to its equivalent string representation.

Opérateurs

Addition(IntPtr, Int32) Addition(IntPtr, Int32) Addition(IntPtr, Int32) Addition(IntPtr, Int32)

Ajoute un offset à la valeur d'un pointeur.Adds an offset to the value of a pointer.

Equality(IntPtr, IntPtr) Equality(IntPtr, IntPtr) Equality(IntPtr, IntPtr) Equality(IntPtr, IntPtr)

Détermine si deux instances spécifiées de IntPtr sont égales.Determines whether two specified instances of IntPtr are equal.

Explicit(Void* to IntPtr) Explicit(Void* to IntPtr) Explicit(Void* to IntPtr) Explicit(Void* to IntPtr)

Convertit le pointeur spécifié vers un type non spécifié en IntPtr.Converts the specified pointer to an unspecified type to an IntPtr.

Cette API n'est pas conforme CLS.This API is not CLS-compliant.

Explicit(IntPtr to Int64) Explicit(IntPtr to Int64) Explicit(IntPtr to Int64) Explicit(IntPtr to Int64)

Convertit la valeur du IntPtr spécifié en entier 64 bits signé.Converts the value of the specified IntPtr to a 64-bit signed integer.

Explicit(IntPtr to Void*) Explicit(IntPtr to Void*) Explicit(IntPtr to Void*) Explicit(IntPtr to Void*)

Convertit la valeur du IntPtr spécifié en pointeur de type non spécifié.Converts the value of the specified IntPtr to a pointer to an unspecified type.

Cette API n'est pas conforme CLS.This API is not CLS-compliant.

Explicit(Int64 to IntPtr) Explicit(Int64 to IntPtr) Explicit(Int64 to IntPtr) Explicit(Int64 to IntPtr)

Convertit la valeur d'un entier 64 bits signé en IntPtr.Converts the value of a 64-bit signed integer to an IntPtr.

Explicit(Int32 to IntPtr) Explicit(Int32 to IntPtr) Explicit(Int32 to IntPtr) Explicit(Int32 to IntPtr)

Convertit la valeur d'un entier 32 bits signé en IntPtr.Converts the value of a 32-bit signed integer to an IntPtr.

Explicit(IntPtr to Int32) Explicit(IntPtr to Int32) Explicit(IntPtr to Int32) Explicit(IntPtr to Int32)

Convertit la valeur du IntPtr spécifié en entier 32 bits signé.Converts the value of the specified IntPtr to a 32-bit signed integer.

Inequality(IntPtr, IntPtr) Inequality(IntPtr, IntPtr) Inequality(IntPtr, IntPtr) Inequality(IntPtr, IntPtr)

Détermine si deux instances spécifiées de IntPtr ne sont pas égales.Determines whether two specified instances of IntPtr are not equal.

Subtraction(IntPtr, Int32) Subtraction(IntPtr, Int32) Subtraction(IntPtr, Int32) Subtraction(IntPtr, Int32)

Soustrait un offset de la valeur d'un pointeur.Subtracts an offset from the value of a pointer.

Implémentations d’interfaces explicites

IEquatable<IntPtr>.Equals(IntPtr) IEquatable<IntPtr>.Equals(IntPtr) IEquatable<IntPtr>.Equals(IntPtr) IEquatable<IntPtr>.Equals(IntPtr)
ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Remplit un objet SerializationInfo des données nécessaires à la sérialisation de l'objet IntPtr actuel.Populates a SerializationInfo object with the data needed to serialize the current IntPtr object.

S’applique à

Cohérence de thread

Ce type est thread-safe.This type is thread safe.

Voir aussi