Apuntadores

Compilación de códigos inseguros

El uso de punteros hace el código más proclive a fallos en tanto que se salta muchas de las medidas incluidas en el acceso normal a objetos, por lo que es necesario incluir ciertas medidas de seguridad que eviten la introducción accidental de esta inseguridad

La primera medida tomada consiste en que explícitamente hay que indicar al compilador que deseamos compilar código inseguro. Para ello, al compilador de línea de comandos hemos de pasarle la opción /unsafe, como se muestra el ejemplo:

csc códigoInseguro.cs /unsafe

Si no se indica la opción unsafe, cuando el compilador detecte algún fuente con código inseguro producirá un mensaje de error como el siguiente:

códigoInseguro(5,23): error CS0277: unsafe code may only appear if 
compiling with /unsafe

En caso de que la compilación se vaya a realizar a través de Visual Studio.NET, la forma de indicar que se desea compilar código inseguro es activando la casilla View/Property Pages/Configuration Properties/Build/Allow unsafe code blocks

Marcado de códigos inseguros

Aparte de forzarse a indicar explícitamente que se desea compilar código inseguro, C# también obliga a que todo uso de código inseguro que se haga en un fichero fuente tenga que ser explícitamente indicado como tal. A las zonas de código donde se usa código inseguro se les denomina contextos inseguros, y C# ofrece varios mecanismos para marcar este tipo de contextos.

Una primera posibilidad consiste en preceder un bloque de instrucciones de la palabra reservada unsafe siguiendo la siguiente sintaxis:

unsafe<instrucciones>

En el código incluido en podrán definirse variables de tipos puntero y podrá hacerse uso de las mismas. Por ejemplo:

public void f()
{
	unsafe
	{
	int *x;
	}
}

Otra forma de definir contextos inseguros consiste en añadir el modificador unsafe a la definición de un miembro, caso en que dentro de su definición se podrá hacer uso de punteros. Así es posible definir campos de tipo puntero, métodos con parámetros de tipos puntero, etc.

Definición de punteros

Para definir una variable puntero de un determinado tipo se sigue una sintaxis parecida a la usada para definir variables normales sólo que al nombre del tipo se le postpone un símbolo de asterisco (*) O sea, un puntero se define así:

<tipo> * <nombrepuntero>;

Por ejemplo, una variable puntero llamada a que pueda almacenar referencias a posiciones de memoria donde se almacenen objetos de tipo int se declara así:

int * a;

En caso de quererse declarar una tabla de punteros, entonces el asterisco hay que incluirlo tras el nombre del tipo pero antes de los corchetes. Por ejemplo, una tabla de nombre t que pueda almacenar punteros a objetos de tipo int se declara así:

int*[]  t;

Hay un tipo especial de puntero que es capaz de almacenar referencias a objetos de cualquier tipo. éstos punteros se declaran indicando void como . Por ejemplo:

void * punteroACualquierCosa;

Hay que tener en cuenta que en realidad lo que indica el tipo que se dé a un puntero es cuál es el tipo de objetos que se ha de considerar que se almacenan en la dirección de memoria almacenada por el puntero. Si se le da el valor void lo que se está diciendo es que no se desea que se considere que el puntero apunta a ningún tipo específico de objeto. Es decir, no se está dando información sobre el tipo apuntado.

Obtención de dirección de memoria. Operador &

Para almacenar una referencia a un objeto en un puntero se puede aplicar al objeto el operador prefijo &, que lo que hace es devolver la dirección que en memoria ocupa el objeto sobre el que se aplica. Un ejemplo de su uso para inicializar un puntero es:

int x =10;
int * px = &x;

Este operador no es aplicable a expresiones constantes, pues éstas no se almacenan en ninguna dirección de memoria específica sino que se incrustan en las instrucciones. Por ello, no es válido hacer directamente:

int px = &10;  // Error 10 no es una variable con dirección propia

Un puntero no almacena directamente un objeto sino que suele almacenar la dirección de memoria de un objeto (o sea, apunta a un objeto) Para obtener a partir de un puntero el objeto al que apunta hay que aplicarle al mismo el operador prefijo *, que devuelve el objeto apuntado. Por ejemplo, el siguiente código imprime en pantalla un 10:

int x = 10;
int * px= &x;
Console.WriteLine(*px);

Acceso a miembro de contenido de puntero. Operador ->

Si un puntero apunta a un objeto estructura que tiene un método F() sería posible llamarlo a través del puntero con:

(*objeto).F();

Sin embargo, como llamar a objetos apuntados por punteros es algo bastante habitual, para facilitar la sintaxis con la que hacer esto se ha incluido en C# el operador ->, con el que la instrucción anterior se escribiría así:

objeto->f();

Es decir, del mismo modo que el operador . permite acceder a los miembros de un objeto referenciado por una variable normal, -> permite acceder a los miembros de un objeto referenciado por un puntero. En general, un acceso de la forma O -> M es equivalente a hacer (*O).M. Por tanto, al igual que es incorrecto aplicar * sobre punteros de tipo void *, también lo es aplicar ->.