__ptr32, __ptr64

Específico de Microsoft

Use __ptr32 para representar un puntero nativo en un sistema de 32 bits. Use __ptr64 para representar un puntero nativo en un sistema de 64 bits.

Los __ptr32 modificadores y __ptr64 son extensiones específicas de Microsoft para escenarios de interoperabilidad. Para código x64 estándar de 32 bits (x86) o estándar, use punteros nativos en su lugar.

En el ejemplo siguiente se muestra cómo declarar cada uno de estos tipos de puntero:

int * __ptr32 p32;
int * __ptr64 p64;

En un sistema de 32 bits, un puntero declarado con __ptr64 se trata como un puntero de 32 bits y trunca los 32 bits superiores de cualquier dirección de 64 bits asignada. En un sistema de 64 bits, un puntero declarado con __ptr32 se trata como un puntero de 32 bits y trunca los 32 bits superiores de cualquier dirección de 64 bits asignada. Este truncamiento puede provocar un puntero no válido si la dirección de 64 bits está por encima de 4 GB.

Nota:

No se puede usar __ptr32 ni __ptr64 al compilar con /clr:pure. De lo contrario, el compilador genera el error C2472. Las opciones del compilador /clr:pure y /clr:safe están en desuso en Microsoft Visual Studio 2015 y no se admiten en Microsoft Visual Studio 2017.

Para la compatibilidad con versiones anteriores, y _ptr64 son sinónimos de __ptr32 y __ptr64 a _ptr32 menos que especifique la opción del compilador /Za (Deshabilitar extensiones de lenguaje).

Ejemplo

En el ejemplo siguiente se muestra cómo declarar y asignar punteros con las palabras clave __ptr32 y __ptr64.

Este código funciona en x86, pero podría bloquearse en x64.

• Funciona cuando se compila para 32 bits porque __ptr64 los punteros se tratan como punteros de 32 bits en x86. En x86 (32 bits), malloc devuelve una dirección de 32 bits que se ajusta a p64.
• Puede bloquearse cuando se compila para 64 bits porque, en x64, malloc devuelve un puntero de 64 bits truncado a 32 bits por esta línea: p32 = (int* __ptr32)malloc(4);. Truncar una dirección de 64 bits a una dirección de 32 bits podría dar lugar a un puntero no válido si la asignación se produjo por encima de 4 GB. En ese caso, *p32 = 32 podría intentar acceder a una dirección truncada que no forma parte del espacio de direcciones del proceso, lo que provoca una infracción de acceso. Incluso si funciona una vez, podría producir un error más adelante si el asignador de memoria devuelve una dirección superior.

#include <cstdlib>
#include <iostream>

int main()
{
    using namespace std;

    int* __ptr32 p32;
    int* __ptr64 p64;

    p64 = (int* __ptr64)malloc(4);
    *p64 = 64; // Works on x86 and x64
    cout << *p64 << endl; 
    
    p32 = (int* __ptr32)malloc(4);
    *p32 = 32; // Works on x86. Possible exception on x64
    cout << *p32 << endl;
}

64
32

FIN de Específicos de Microsoft

Consulte también

Tipos integrados