|
PUNTEROS Y ARRAYS
El nombre de un array , para el compilador C , es
un PUNTERO inicializado con la dirección del primer elemento del array . Sin embargo hay
una importante diferencia entre ambos.
Veamos algunas operaciones permitidas entre punteros
:
ASIGNACION
float var , conjunto[] = { 8.0 , 7.0 , 6.0 , 5.0
, 4.0 );
float *punt ;
punt = conjunto ; /* equivalente a hacer : punt =
&conjunto [0] */
var1 = *punt ;
*punt = 25.1 ;
Es perfectamente válido asignar a un puntero el
valor de otro , el resultado de ésta operación es cargar en el puntero punt la
dirección del elemento [0] del array conjunto , y posteriormente en la variable var el
valor del mismo (8.0) y para luego cambiar el valor de dicho primer elemento a 25.1 .
Veamos cual es la diferencia entre un puntero y el
denominador de un array : el primero es una VARIABLE , es decir que puedo asignarlo ,
incrementarlo etc , en cambio el segundo es una CONSTANTE, que apunta siempre al primer
elemento del array con que fué declarado , por lo que su contenido no puede ser variado.
El siguiente ejemplo nos muestra un tipo de error
bastante frecuente:
ASIGNACION ERRONEA
int conjunto[3] , lista[] = { 5 , 6 , 7 ) ;
int *apuntador ;
apuntador = lista ; /* correcto */
conjunto = apuntador; /* ERROR ( se requiere en
Lvalue no constante ) */
lista = conjunto ; /* ERROR ( idem ) */
apuntador = &conjunto /* ERROR no se puede
aplicar el operador & (dirección) a
una constante */
INCREMENTO O DECREMENTO DE UN PUNTERO
int *pint , arreglo_int[5] ;
double *pdw , arreglo_dou[6] ;
pint = arreglo_int ; /* pint apunta a
arreglo_int[0] */
pdw = arreglo_dw ; /* pdw apunta a arreglo_dou[0]
*/
pint += 1 ; /* pint apunta a arreglo_int[1] */
pdw += 1 ; /* pdw apunta a arreglo_dw[1] */
pint++ ; /* pint apunta a arreglo_int[2] */
pdw++ ; /* pdw apunta a arreglo_dw[2] */
Para el compilador , éstas sentencias se leen
como : incremente el contenido del puntero ( dirección del primer elemento del array ) en
un número igual a la cantidad de bytes que tiene la variable con que fué declarado . Es
decir que el contenido de pint es incrementado en dos bytes (un int tiene 2 bytes )
mientras que pdou es incrementado 8 bytes ( por ser un puntero a double ) , el resultado
entonces es el mismo para ambos , ya que luego de la operación quedan apuntando al
elemento siguiente del array , arreglo_int[1] y arreglo_dw[1] .
Vemos que de ésta manera será muy facil
"barrer" arrays , independientemente del tamaño de variables que lo compongan ,
permitiendo por otro lado que el programa sea transportable a distintos hardwares sin
preocuparnos de la diferente cantidad de bytes que pueden asignar los mismos , a un dado
tipo de variable .
De manera similar las dos instrucciones siguientes ,
vuelven a a incrementarse los punteros , apuntando ahora a los elementos siguientes de los
arrays.
Todo lo dicho se puede aplicar de igual
manera al operador de decremento(--) .
|
