Puntero (programación informática)

En C , la sintaxis básica para definir un puntero es: ^{[ 4 ]}

int * puntero ;

Esto declara una variable ptrque almacena un puntero a un objeto de tipo int. Se pueden usar otros tipos en lugar de int; por ejemplo, bool *ptrdeclararía un puntero a un objeto de tipo bool.

Una vez declarado un puntero, se le puede asignar una dirección. En C, la dirección de una variable se puede obtener con el &operador unario :

// Declara una variable para un puntero a un entero int * ptr ; // Declara una variable para un entero int a = 5 ; // Asigna la dirección de a a la variable de puntero ptr = &a a ;

*Para desreferenciar el puntero y obtener el objeto al que apunta, se puede usar un asterisco ( *):

printf ( "%d \n " , * ptr ); // Imprime: 5

Existen dos estilos de declaración de un puntero a un objeto intcon nombre ptr:

• int*ptr;, lo que enfatiza que la expresión *ptrtiene tipo int. ^{[ 5 ]}
• int*ptr;, que enfatiza que ptrtiene tipo int*. Este estilo es más frecuente en C++ que en C. ^{[ 6 ] [ 7 ]}

Tanto como declaran ser un puntero a , pero declara ser un . Esto se debe a que se aplica solo a la variable que le sigue inmediatamente. ^{[ 5 ]}int*x,y;int*x,y;xintyint*

El asterisco también se puede usar en el lado izquierdo de una asignación para cambiar el objeto asin tener que estar en el mismo ámbito.

* puntero = 8 ;

Si ase accede a él más tarde, su nuevo valor será 8.

Debido a que el lenguaje C no especifica una inicialización implícita para objetos de duración de almacenamiento automático, ^{[ 8 ]} las variables de puntero a veces pueden apuntar a ubicaciones inesperadas, causando un comportamiento indefinido. Para combatir esto, los punteros a veces se inicializan con un valor de puntero nulo , representado en C por la NULLmacro; ^{[ 9 ]} en C23 y posteriores, nullptrtambién está disponible como alternativa, que es de tipo nullptr_t. ^{[ 10 ]}

int * ptr = NULL ; int * ptr = nullptr ; // desde C23

La desreferenciación de un puntero nulo produce un comportamiento indefinido , ^{[ 11 ]} que puede generar errores y resultados impredecibles.

Este ejemplo puede resultar más claro si se examina la memoria directamente. Supongamos que ase encuentra en la dirección 0x8130 de la memoria y ptren la 0x8134; supongamos también que se trata de una máquina de 32 bits, de modo que un entero tiene 32 bits de ancho. Lo siguiente es lo que habría en la memoria después de ejecutar el siguiente fragmento de código:

int a = 5 ; int * ptr = NULL ;

(El puntero nulo que se muestra aquí es 0x00000000 .) Al asignar la dirección de a :aptr

puntero = &a a ;

produce los siguientes valores de memoria:

Luego, mediante la desreferenciación ptrpor codificación:

* puntero = 8 ;

La computadora tomará el contenido de ptr(que es 0x8130), 'localizará' esa dirección y asignará 8 a esa ubicación, lo que dará como resultado la siguiente memoria:

Claramente, el acceso adará como resultado el valor 8 porque la instrucción anterior modificó el contenido aa través del puntero ptr.

Al configurar estructuras de datos como listas , colas y árboles, es necesario contar con punteros para gestionar su implementación y control. Ejemplos típicos de punteros son los punteros de inicio, los punteros de fin y los punteros de pila . Estos punteros pueden ser absolutos (la dirección física real o una dirección virtual en la memoria virtual ) o relativos (un desplazamiento desde una dirección de inicio absoluta ("base") que generalmente utiliza menos bits que una dirección completa, pero que suele requerir una operación aritmética adicional para su resolución).

Las direcciones relativas son una forma de segmentación manual de memoria y comparten muchas de sus ventajas y desventajas. Un desplazamiento de dos bytes, que contiene un entero sin signo de 16 bits, puede utilizarse para proporcionar direccionamiento relativo para hasta 64 KiB ( ^2¹⁶ bytes) de una estructura de datos. Esto puede extenderse fácilmente a 128, 256 o 512 KiB si la dirección a la que apunta se alinea con un límite de media palabra, palabra o doble palabra (pero, requiriendo una operación adicional de "desplazamiento a la izquierda" —de 1, 2 o 3 bits— para ajustar el desplazamiento por un factor de 2, 4 u 8, antes de sumarle a la dirección base ). Sin embargo, en general, estos esquemas son muy engorrosos, y para mayor comodidad del programador se prefieren las direcciones absolutas (y subyacentemente, un espacio de direcciones plano ).

Un desplazamiento de un byte, como el valor ASCII hexadecimal de un carácter (por ejemplo, X'29'), puede utilizarse para apuntar a un valor entero alternativo (o índice) en una matriz (por ejemplo, X'01'). De esta forma, los caracteres pueden traducirse de manera muy eficiente de " datos sin procesar " a un índice secuencial utilizable y, posteriormente, a una dirección absoluta sin necesidad de una tabla de búsqueda .

int a [ 5 ]; // Declara 5 enteros contiguos int * ptr = a ; // Los nombres de los arrays en las expresiones se evalúan como punteros en la mayoría de los casos ptr [ 0 ] = 1 ; // Los punteros se pueden indexar con la sintaxis de array * ( a + 1 ) = 2 ; // Los arrays se pueden indexar con la sintaxis de puntero * ( 1 + a ) = 2 ; // La suma de punteros es conmutativa 2 [ a ] = 4 ; // El operador de subíndice es conmutativo (quizás inusual)

int a [ 5 ] = { 2 , 4 , 3 , 1 , 5 };

struct LinkedList { void * data ; // datos de este enlace struct LinkedList * next ; // siguiente enlace; NULL si no hay ninguno };

datos ListaEnlazada a = Nil | Cons a ( ListaEnlazada a )

Los punteros se pueden usar para pasar variables por su dirección, lo que permite cambiar su valor. Por ejemplo, considere el siguiente código C :

// Se puede cambiar una copia del entero n dentro de la función sin afectar al código que la llama. void passByValue ( int n ) { n = 12 ; }// En su lugar, se pasa un puntero m. No se crea ninguna copia del valor al que apunta m. void passByAddress ( int * m ) { * m = 14 ; }int main ( void ) { int x = 3 ;// Pasar una copia del valor de x como argumento passByValue ( x ); // El valor se modificó dentro de la función, pero x sigue siendo 3 a partir de ahora.// Pasar la dirección de x como argumento passByAddress ( & x ); // x fue modificado por la función y ahora es igual a 14 aquídevolver 0 ; }

En algunos programas, la cantidad de memoria requerida depende de lo que el usuario ingrese. En estos casos, el programador necesita asignar memoria dinámicamente. Esto se logra asignando memoria en el montón (heap) en lugar de en la pila (stack ), donde generalmente se almacenan las variables (aunque también pueden almacenarse en los registros de la CPU). La asignación dinámica de memoria solo se puede realizar mediante punteros, y no se les pueden asignar nombres , al igual que a las variables comunes .

Los punteros se utilizan para almacenar y gestionar las direcciones de bloques de memoria asignados dinámicamente . Dichos bloques se utilizan para almacenar objetos de datos o matrices de objetos. La mayoría de los lenguajes estructurados y orientados a objetos proporcionan un área de memoria, denominada montón o memoria libre , desde la cual se asignan objetos dinámicamente.

El siguiente ejemplo de código C ilustra cómo se asignan y referencian dinámicamente los objetos de estructura. La biblioteca estándar de C proporciona la función malloc()para asignar bloques de memoria desde el montón. Esta función recibe como parámetro el tamaño del objeto a asignar y devuelve un puntero a un bloque de memoria recién asignado, adecuado para almacenar el objeto, o un puntero nulo si la asignación falla.

// Elemento de inventario de piezas typedef struct { int id ; // Número de pieza char * name ; // Nombre de la pieza float cost ; // Costo } Item ;// Asigna e inicializa un nuevo objeto Item Item * makeItem ( const char * name ) { Item * item ;// Asigna un bloque de memoria para un nuevo objeto Item item = malloc ( sizeof ( * item )); if ( ! item ) { return NULL ; }// Inicializa los miembros del nuevo Item memset ( item , 0 , sizeof ( * item )); item -> id = -1 ; item -> name = NULL ; item -> cost = 0.0 ;// Guarda una copia del nombre en el nuevo Item item -> name = malloc ( strlen ( name ) + 1 ); if ( ! item -> name ) { free ( item ); return NULL ; } strcpy ( item -> name , name );// Devuelve el objeto Item recién creado return item ; }

El siguiente código ilustra cómo se liberan dinámicamente los objetos de memoria, es decir, cómo se devuelven al montón o al espacio de memoria libre. La biblioteca estándar de C proporciona la función free()para liberar un bloque de memoria previamente asignado y devolverlo al montón.

// Desasignar un objeto Item void destroyItem ( Item * item ) { // Comprobar si el puntero al objeto es nulo if ( ! item ) { return ; }// Libera la cadena de nombre guardada dentro del Item if ( item -> name ) { free ( item -> name ); item -> name = NULL ; }// Libera la memoria del objeto Item free ( item ); }

En algunas arquitecturas informáticas, los punteros pueden utilizarse para manipular directamente la memoria o los dispositivos mapeados en memoria.

Asignar direcciones a punteros es una herramienta invaluable al programar microcontroladores . A continuación se muestra un ejemplo simple que declara un puntero de tipo int y lo inicializa con una dirección hexadecimal , en este ejemplo la constante 0x7FFF :

int * dirección_hardware = ( int * ) 0x7FFF ;

A mediados de la década de 1980, acceder a las capacidades de vídeo de los PC mediante la BIOS era lento. Las aplicaciones que requerían un uso intensivo de la pantalla solían acceder directamente a la memoria de vídeo CGA convirtiendo la constante hexadecimal 0xB8000 en un puntero a una matriz de 80 valores enteros sin signo de 16 bits. Cada valor constaba de un código ASCII en el byte bajo y un color en el byte alto. Así, para colocar la letra ' A ' en la fila 5, columna 2, en blanco brillante sobre azul, se escribiría un código como el siguiente:

#define VID ((unsigned short (*)[80])0xB8000)vacío foo ( vacío ) { VID [ 4 ][ 1 ] = 0x1F00 | 'A' ; }

Las tablas de control que se utilizan para controlar el flujo del programa suelen hacer un uso extensivo de punteros. Estos punteros, generalmente integrados en una entrada de la tabla, pueden utilizarse, por ejemplo, para almacenar los puntos de entrada a las subrutinas que se ejecutarán, según ciertas condiciones definidas en la misma entrada. Sin embargo, los punteros también pueden ser simplemente índices a otras tablas separadas, pero asociadas, que contienen una matriz de direcciones reales o las direcciones mismas (dependiendo de las construcciones disponibles en el lenguaje de programación). Asimismo, pueden utilizarse para apuntar a entradas anteriores de la tabla (como en el procesamiento de bucles) o para avanzar y omitir algunas entradas (como en una instrucción switch o una salida anticipada de un bucle). Para este último caso, el puntero puede ser simplemente el número de la entrada de la tabla y transformarse en una dirección real mediante una operación aritmética sencilla.

En C y C++, incluso si dos punteros se comparan como iguales, eso no significa que sean equivalentes. En estos lenguajes y en LLVM , la regla se interpreta como que "el hecho de que dos punteros apunten a la misma dirección no significa que sean iguales en el sentido de que se puedan usar indistintamente", la diferencia entre los punteros se denomina procedencia . ^{[ 15 ]} La conversión a un tipo entero, como uintptr_tes definida por la implementación, y la comparación que proporciona no ofrece más información sobre si los dos punteros son intercambiables. Además, la conversión posterior a bytes y aritmética confundirá a los optimizadores que intentan realizar un seguimiento del uso de punteros, un problema que aún se está dilucidando en la investigación académica. ^{[ 16 ]}

Ada es un lenguaje fuertemente tipado donde todos los punteros tienen tipo y solo se permiten conversiones de tipo seguras. Todos los punteros se inicializan por defecto a null, y cualquier intento de acceder a datos a través de un nullpuntero provoca que se genere una excepción . Los punteros en Ada se denominan tipos de acceso . Ada  83 no permitía aritmética en tipos de acceso (aunque muchos proveedores de compiladores la proporcionaban como una característica no estándar), pero Ada  95 admite aritmética "segura" en tipos de acceso a través del paquete System.Storage_Elements.

Varias versiones antiguas de BASIC para la plataforma Windows admitían la STRPTR()devolución de la dirección de una cadena y VARPTR()de una variable. Visual Basic 5 también admitía la OBJPTR()devolución de la dirección de una interfaz de objeto y el operador ADDRESSOF para devolver la dirección de una función. Todos estos tipos son enteros, pero sus valores son equivalentes a los de los punteros.

Sin embargo, las variantes más recientes de BASIC , como FreeBASIC o BlitzMax , cuentan con implementaciones de punteros exhaustivas. En FreeBASIC, las operaciones aritméticas con punteros ANY (equivalentes a los de C ) se tratan como si el puntero ANY tuviera un ancho de byte. Los punteros ANY no se pueden desreferenciar, como en C. Además, la conversión entre punteros ANY y de cualquier otro tipo no genera advertencias.void *

dim as integer f = 257 dim as any ptr g = @ f dim as integer ptr i = g assert ( * i = 257 ) assert ( ( g + 4 ) = ( @ f + 1 ) )

En C, los punteros son variables que almacenan direcciones y pueden ser nulos . Cada puntero tiene un tipo al que apunta, pero se puede convertir libremente entre tipos de puntero. Sin embargo, no es posible convertir entre un puntero a función y un puntero a objeto. Un tipo de puntero especial llamado "puntero void" permite apuntar a cualquier objeto (que no sea una función), pero está limitado por el hecho de que no se puede desreferenciar directamente. La dirección en sí misma a menudo se puede manipular directamente convirtiendo un puntero a y desde un tipo entero de tamaño suficiente, aunque los resultados son indefinidos; mientras que los estándares C anteriores no tenían un tipo entero que garantizara ser lo suficientemente grande, C99 especifica el uintptr_ttipo definido en <stdint.h>, pero una implementación no necesita proporcionarlo.

La aritmética de punteros , es decir, la capacidad de modificar la dirección de destino de un puntero con operaciones aritméticas (así como comparaciones de magnitud), está restringida por el estándar del lenguaje para permanecer dentro de los límites de un solo objeto de matriz o justo después de él, y de lo contrario invocará un comportamiento indefinido . Sumar o restar de un puntero lo mueve en un múltiplo del tamaño de su tipo de dato . Por ejemplo, sumar 1 a un puntero a valores enteros de 4 bytes incrementará la dirección de byte a la que apunta el puntero en 4. Esto tiene el efecto de incrementar el puntero para que apunte al siguiente elemento en una matriz contigua de enteros, que suele ser el resultado deseado. La aritmética de punteros no se puede realizar en voidpunteros porque el tipo void no tiene tamaño, y por lo tanto no se puede sumar a la dirección a la que apunta, aunque gcc y otros compiladores realizarán aritmética de bytes en void *como una extensión no estándar, tratándolo como si fuera char *.

La aritmética de punteros proporciona al programador una única forma de manejar diferentes tipos: sumar y restar el número de elementos requeridos en lugar del desplazamiento real en bytes. En particular, el estándar C declara explícitamente que la sintaxis a[n], que es el n -ésimo elemento del array , es equivalente a , que es el contenido del elemento apuntado por . Esto implica que, por ejemplo, y acceden al cuarto elemento del array .a*(a + n)a + na[3]3[a]a

Si bien es potente, la aritmética de punteros puede ser fuente de errores informáticos . Tiende a confundir a los programadores novatos , obligándolos a trabajar en contextos diferentes: una expresión puede ser aritmética ordinaria o aritmética de punteros, y a veces es fácil confundirlas. En respuesta a esto, muchos lenguajes de programación modernos de alto nivel no permiten el acceso directo a la memoria mediante direcciones.

El voidpuntero , o void *, es compatible en ANSI C como un tipo de puntero genérico. Un puntero a voidpuede almacenar la dirección de cualquier objeto (no función), ^{[ a ]} ​​y, se convierte implícitamente a cualquier otro tipo de puntero de objeto en la asignación, pero debe convertirse explícitamente si se desreferencia. Antes de ANSI C, K&R usaba char *para el propósito de "puntero independiente del tipo".

int x = 4 ; void * p1 = & x ; int * p2 = p1 ; // void * se convierte implícitamente a int * int a = * p2 ; int b = * ( int * ) p1 ; // al desreferenciar en línea, no hay conversión implícita

C++ es totalmente compatible con punteros y conversión de tipos de C. Además, admite un nuevo grupo de operadores de conversión de tipos para detectar conversiones peligrosas no deseadas en tiempo de compilación. C++ también admite otra forma de referencia, bastante diferente de un puntero, llamada simplemente referencia o tipo de referencia .

Desde C++11 , la biblioteca estándar de C++ también proporciona punteros inteligentes , que pueden utilizarse en algunas situaciones como una alternativa más segura a los punteros primitivos de C.

• std::unique_ptr(Representa la propiedad exclusiva de un recurso, no se puede copiar pero sí se puede mover)
• std::shared_ptr(Representa la propiedad compartida de un recurso; el recurso solo se elimina una vez que se destruye o se restablece el último puntero compartido).
• std::weak_ptr(no representa propiedad, puede apuntar a los recursos de un puntero compartido sin incrementar el contador de referencias)
• std::hazard_pointer(puntero de un solo escritor y múltiples lectores que puede ser propiedad de como máximo un hilo en cualquier momento)

std::unique_ptrSustituye al puntero inteligente anterior std::auto_ptr , que quedó obsoleto en C++11 y se eliminó en C++17.

A diferencia de C, C++ no permite la conversión implícita a void*otros tipos de puntero, ni siquiera en asignaciones. Esta fue una decisión de diseño para evitar conversiones de tipos descuidadas e incluso no intencionadas, aunque la mayoría de los compiladores solo emiten advertencias, no errores, cuando encuentran otras conversiones.

int x = 4 ; void * p1 = & x ; int * p2 = p1 ; // esto falla: no hay conversión implícita desde void* int * p3 = reinterpret_cast < int *> ( p1 ); // conversión de C++

En C++, no existe void&(referencia a void) para complementar void*(puntero a void), porque las referencias se comportan como alias de las variables a las que apuntan, y nunca puede haber una variable cuyo tipo sea void.

struct Integer { int value ; [[ nodiscard ]] int get () const noexcept { return value ; } };Entero s1 ; // construido por defecto, s1.valor = 0 Entero * ps = & s1 ;int Integer ::* ptr = & Integer :: value ; // puntero a Integer::value int ( Integer ::* fp )() const = & Integer :: get ; // puntero a Integer::gets1 . * ptr = 1 ; std :: println ( "{}" , ( s1 . * fp )()); // imprime 1 ps ->* ptr = 2 ; std :: println ( "{}" , ( ps ->* fp )()); // imprime 2

clase X { // ... };clase Y { // ... };char X ::* a ; // puntero a miembro de char char X ::* b [ 5 ]; // matriz de punteros a miembros de char char * X ::* c ; // puntero a miembro a puntero a char(s) char X ::** d ; // puntero a puntero a miembro de char char ( * e )[ 5 ]; // puntero a miembro a matriz(s) de caracteres char X ::* f (); // función que devuelve un puntero a miembro de char char Y ::* X ::* g ; // puntero a miembro a puntero a miembro a puntero a char(s) char X ::* X ::* h ; // puntero a miembro a puntero a miembro a puntero a char(s) char ( X ::* i ())[ 5 ]; // función que devuelve un puntero a miembro a un array de caracteres char ( X ::* j )() // función de puntero a miembro que devuelve un carácter char ( X ::* k [ 5 ])(); // un array de punteros a funciones miembro que devuelven un carácter

En el lenguaje de programación C# , los punteros se admiten marcando los bloques de código que los incluyen con la unsafepalabra clave `pointer`, o a través del System.Runtime.CompilerServicesespacio de nombres para el acceso a punteros. La sintaxis es esencialmente la misma que en C++, y la dirección a la que apunta puede ser memoria administrada o no administrada . Sin embargo, los punteros a memoria administrada (cualquier puntero a un objeto administrado) deben declararse con la fixedpalabra clave `pointer`, lo que impide que el recolector de basura mueva el objeto apuntado como parte de la administración de memoria mientras el puntero está dentro del ámbito, manteniendo así la validez de la dirección del puntero.

Sin embargo, una excepción a esto es el uso de la IntPtrestructura, que es un equivalente administrado en memoria a int*, y no requiere la unsafepalabra clave ni el CompilerServicesensamblado. Este tipo se devuelve a menudo al usar métodos de System.Runtime.InteropServices, por ejemplo:

using System ; using System.Runtime.InteropServices ;// Obtener 16 bytes de memoria de la memoria no administrada del proceso IntPtr pointer = Marshal . AllocHGlobal ( 16 );// Hacer algo con la memoria asignada// Libera la memoria asignada Marshal.FreeHGlobal ( pointer );

El marco .NET incluye muchas clases y métodos en los espacios de nombres Systemy System.Runtime.InteropServices(como la Marshalclase) que convierten tipos .NET (por ejemplo, System.String) a y desde muchos tipos y punteros no administradosLPWSTR (por ejemplo, o void*) para permitir la comunicación con código no administrado . La mayoría de estos métodos tienen los mismos requisitos de permisos de seguridad que el código no administrado, ya que pueden afectar ubicaciones arbitrarias en la memoria.

C# permite el uso de matrices asignadas en la pila en código seguro mediante System.Span. ^{[ 24 ]}

espacio de nombres Wikipedia.Ejemplos ;usando el sistema ;public class Example { static void Main ( string [] args ) { int num = 1024 ; unsafe { // convierte un int en bytes creando un puntero a byte byte * p = ( byte * ) & number ; Console . Write ( "Los 4 bytes del entero son: " ); for ( int i = 0 ; i < sizeof ( int ); ++ i ) { Console . Write ( " {0:X2}" , * p ); ++ p ; } Console . WriteLine (); }// Los arreglos asignados en la pila se pueden hacer mediante punteros o Span<T> unsafe { int * numbers = stackalloc int [ 5 ]; } Span < int > numbers = stackalloc int [ 5 ]; } }

C#, al igual que C y C++, también tiene un void*tipo (puntero void), pero no es muy recomendable. ^{[ 25 ]}

A diferencia de C y C++, el compilador no acepta asteriscos alineados a la derecha. Por ejemplo:

int * a , b ; int * a , * b ; // ilegal en C#

En C y C++, esto declararía acomo int*y bcomo int, pero en C# esto declara ambas variables como int*. ^{[ 25 ]}

El lenguaje de programación COBOL admite punteros a variables. Los objetos de datos primitivos o de grupo (registro) declarados dentro de LINKAGE SECTIONun programa se basan inherentemente en punteros, donde la única memoria asignada dentro del programa es el espacio para la dirección del elemento de datos (normalmente una sola palabra de memoria). En el código fuente del programa, estos elementos de datos se utilizan como cualquier otra WORKING-STORAGEvariable, pero su contenido se accede implícitamente de forma indirecta a través de sus LINKAGEpunteros.

El espacio de memoria para cada objeto de datos al que apunta se asigna normalmente de forma dinámica mediante instrucciones externas CALLo a través de construcciones de lenguaje extendidas integradas, como las instrucciones EXEC CICSo EXEC SQL.

Las versiones extendidas de COBOL también proporcionan variables de puntero declaradas con USAGEISPOINTERcláusulas. Los valores de dichas variables de puntero se establecen y modifican mediante SETsentencias SETADDRESS.

Algunas versiones extendidas de COBOL también proporcionan PROCEDURE-POINTERvariables, que son capaces de almacenar las direcciones del código ejecutable .

El lenguaje PL/I proporciona soporte completo para punteros a todos los tipos de datos (incluidos punteros a estructuras), recursión , multitarea , manejo de cadenas y funciones integradas extensas . PL/I fue un gran salto adelante en comparación con los lenguajes de programación de su época. Los punteros PL/I no tienen tipo, por lo que no se requiere conversión para la desreferenciación o asignación de punteros. La sintaxis de declaración para un puntero es , que declara un puntero llamado "xxx". Los punteros se utilizan con variables. Una variable base se puede declarar con un localizador predeterminado ( o sin ( ), donde xxx es una variable base, que puede ser una variable de elemento, una estructura o una matriz, y ppp es el puntero predeterminado). Dicha variable se puede direccionar sin una referencia de puntero explícita ( , o se puede direccionar con una referencia explícita al localizador predeterminado (ppp), o a cualquier otro puntero ( ).DECLARE xxx POINTER;BASEDDECLARE xxx BASED(ppp);DECLARE xxx BASED;xxx=1;qqq->xxx=1;

La aritmética de punteros no forma parte explícitamente del estándar PL/I, pero la UNSPECfunción integrada y la pseudovariable permiten realizarla, y muchos compiladores admiten expresiones de la forma ptr = ptr±expression. IBM PL/I también dispone de la función integrada PTRADDpara realizar la aritmética. La aritmética de punteros siempre se realiza en bytes.

Los compiladores PL/I de IBM Enterprise tienen una nueva forma de puntero tipado llamada HANDLE.

El lenguaje de programación D es un derivado de C y C++ que admite completamente los punteros y la conversión de tipos de C. Admite aritmética de punteros y también tiene segmentos de puntero. Un puntero en D puede decaer void*implícitamente. ^{[ 26 ]}

En D, es posible usar refpara una referencia, que desreferencia automáticamente, no permite la aritmética de punteros y no permite escapar una función (es decir, a través de return).

Una porción de puntero puede verse como un puntero con una longitud.

import std.stdio ;​​void main ( ) { int [] arr = [ 10 , 20 , 30 , 40 , 50 ] ; int * ptr = & arr [ 0 ]; int [] slice = ptr [ 0..3 ]; // Divide el array desde el índice 0 hasta el 3 (exclusivo) writeln ( "Slice: " , slice ); // Salida: Slice: [10, 20, 30] }

El lenguaje orientado a objetos Eiffel emplea semántica de valor y referencia sin aritmética de punteros. Sin embargo, se proporcionan clases de punteros que ofrecen aritmética de punteros, conversión de tipos, gestión explícita de memoria, interfaz con software que no es Eiffel y otras características.

Fortran-90 introdujo la capacidad de punteros fuertemente tipados. Los punteros de Fortran contienen más que una simple dirección de memoria. También encapsulan los límites inferior y superior de las dimensiones de los arreglos, los pasos (por ejemplo, para admitir secciones de arreglos arbitrarias) y otros metadatos. Se utiliza un operador de asociación para asociar un puntero a una variable que tiene un atributo. La instrucción de Fortran-90 también se puede usar para asociar un puntero a un bloque de memoria. Por ejemplo, el siguiente código podría usarse para definir y crear una estructura de lista enlazada:=>POINTERTARGETALLOCATE

tipo real_list_t real :: sample_data ( 100 ) tipo ( real_list_t ), puntero :: next => null () fin tipotipo ( lista_real_t ), destino :: mi_lista_real tipo ( lista_real_t ), puntero :: lista_real_tempreal_list_temp => my_real_list do  read ( 1 , iostat = ioerr ) real_list_temp % sample_data if ( ioerr /= 0 ) exit  allocate ( real_list_temp % next ) real_list_temp => real_list_temp % next end do

Fortran-2003 añade compatibilidad con punteros a procedimientos. Además, como parte de la función de interoperabilidad con C , Fortran-2003 admite funciones intrínsecas para convertir punteros de estilo C en punteros de Fortran y viceversa.

Go tiene punteros, declarados de forma similar a los punteros de C/C++ pero con el asterisco primero. Por ejemplo, un puntero a Tse escribe *T. A diferencia de C, Go tiene recolección de basura y no permite aritmética de punteros. Los tipos de referencia, como en C++, no existen. Algunos tipos integrados, como mapas y canales, están encapsulados (es decir, internamente son punteros a estructuras mutables) y se inicializan usando la makefunción. En un enfoque para unificar la sintaxis entre punteros y no punteros, ->se ha eliminado el operador de flecha ( ): el operador punto en un puntero se refiere al campo o método del objeto desreferenciado. Sin embargo, esto solo funciona con un nivel de indirección.

En Java no existe una representación explícita de punteros . En su lugar, las estructuras de datos más complejas, como objetos y matrices, se implementan mediante referencias . El lenguaje no proporciona operadores explícitos para la manipulación de punteros. Sin embargo, es posible que el código intente desreferenciar una referencia nula (puntero nulo), lo que genera una excepción java.lang.NullPointerException . El espacio ocupado por los objetos de memoria sin referencias se recupera automáticamente mediante la recolección de basura en tiempo de ejecución. ^{[ 27 ]}

Java proporciona las clases java.lang.ref.WeakReferencey java.lang.ref.PhantomReference, que implementan respectivamente referencias débiles y referencias fantasma .

Los punteros se implementan de forma muy similar a Pascal, al igual que VARlos parámetros en las llamadas a procedimientos. Modula-2 es incluso más fuertemente tipado que Pascal, con menos maneras de eludir el sistema de tipos. Algunas variantes de Modula-2 (como Modula-3 ) incluyen recolección de basura.

Al igual que en Modula-2, se pueden usar punteros. Aún existen menos maneras de eludir el sistema de tipos, por lo que Oberon y sus variantes siguen siendo más seguros con respecto a los punteros que Modula-2 o sus variantes. Como en Modula-3 , la recolección de basura forma parte de la especificación del lenguaje.

A diferencia de muchos lenguajes que utilizan punteros, el estándar ISO Pascal solo permite que los punteros hagan referencia a variables creadas dinámicamente que sean anónimas y no permite que hagan referencia a variables estáticas o locales estándar. ^{[ 28 ]} No tiene aritmética de punteros. Los punteros también deben tener un tipo asociado y un puntero a un tipo no es compatible con un puntero a otro tipo (por ejemplo, un puntero a un char no es compatible con un puntero a un integer). Esto ayuda a eliminar los problemas de seguridad de tipos inherentes a otras implementaciones de punteros, en particular las utilizadas para PL/I o C. También elimina algunos riesgos causados ​​por punteros colgantes , pero la capacidad de liberar dinámicamente el espacio referenciado mediante el disposeprocedimiento estándar (que tiene el mismo efecto que la freefunción de biblioteca que se encuentra en C ) significa que el riesgo de punteros colgantes no se ha eliminado. ^{[ 29 ]}

Sin embargo, en algunas implementaciones de compiladores Pascal (o derivados) comerciales y de código abierto —como Free Pascal , ^{[ 30 ]} Turbo Pascal o Object Pascal en Embarcadero Delphi— se permite que un puntero haga referencia a variables estáticas o locales estándar y se puede convertir de un tipo de puntero a otro. Además, la aritmética de punteros no tiene restricciones: sumar o restar a un puntero lo mueve en esa cantidad de bytes en cualquier dirección, pero usar los Incprocedimientos Decestándar con él mueve el puntero en el tamaño del tipo de datos al que se declara que apunta. También se proporciona un puntero sin tipo bajo el nombre Pointer, que es compatible con otros tipos de puntero.

Tipomeses = ( ene , feb , mar , abr , may , jun , jul , ago , sep , oct , nov , dic ) ;calptr = ^ Tipo_Calendario ;Tipo_de_calendario = registroAnterior , Siguiente : CalPtr ;Mes : Meses ;día : byte ;año : entero ;evento : cadena ;fin ;varEso : ^ entero ;Siguiente calendario ,calendario : ^ calptr ;comenzarnuevo ( calendario )calendario ^. anterior := nil ;calendario ^. siguiente := nil ;Calendario ^. Mes := Sep ;Calendario ^. Día := 11 ;Calendario ^. Año := 2001 ;nuevo ( que ) ;Eso ^ := 1 ;Nuevo ( nextCalendar ) ;nextCalendar ^. prev := Calendar ;nextCalendar ^. Siguiente := NIL ;Nuevo ( Calendario ) ;...Desechar ( eso ) ;Desechar ( calendario ) ;Eliminar ( nextCalendar ) ;fin ;

El lenguaje de programación Perl admite punteros, aunque raramente se utilizan, en forma de las funciones `pack` y `unpack`. Estas están destinadas únicamente a interacciones sencillas con bibliotecas del sistema operativo compiladas. En todos los demás casos, Perl utiliza referencias , que son tipadas y no permiten ningún tipo de aritmética de punteros. Se utilizan para construir estructuras de datos complejas. ^{[ 31 ]}

Rust utiliza referencias, que son similares a los punteros pero garantizan que apuntan a un valor válido. Trabajar con punteros sin formato es menos común, generalmente para la programación de sistemas de bajo nivel. Los punteros sin formato solo se pueden desreferenciar dentro de un unsafebloque . ^{[ 32 ] [ 33 ] [ 34 ]} Las operaciones con punteros sin formato se encuentran en std::ptr.

En Rust, no existe una constante de puntero nulo. En su lugar, se proporciona mediante std::ptr::null().

Rust también tiene varios tipos de punteros inteligentes:

• std::boxed::Box: equivalente a C++ std::unique_ptr^{[ 35 ]}
• std::rc::Rc: equivalente a un puntero compartido de un solo hilo con conteo de referencias
• std::sync::Arc: equivalente a un puntero compartido seguro para subprocesos con conteo de referencias atómico
• std::rc::Weak: equivalente a C++ std::weak_ptr^{[ 36 ]}

Un puntero Tse escribe como *const To *mut Ten Rust. El siguiente ejemplo muestra punteros sin formato en Rust:

fn main () { let mut num : i32 = 42 ;let r1 = & num as * const i32 ; let r2 = & mut num as * mut i32 ;unsafe { println! ( "r1 apunta a: {}" , * r1 ); println! ( "r2 apunta a: {}" , * r2 );* r2 = 100 ; println! ( "num ahora es: {}" , num ); } }