1. INTRODUCCION A LOS PUNTEROS
Los punteros en el Lenguaje C , son variables que " apuntan " , es
decir que poseen la dirección de las ubicaciones en memoria de otras
variables, y por medio de ellos tendremos un poderoso método de acceso
a todas ellas .
Quizás este punto es el más conflictivo del lenguaje , ya que
muchos programadores en otros idiomas , y novatos en C , lo ven como un método
extraño ó al menos desacostrumbrado , lo que les produce un cierto
rechazo . Sin embargo , y en la medida que uno se va familiarizando con ellos
, se convierten en la herramienta más cómoda y directa para el
manejo de variables complejas , argumentos , parámetros , etc , y se
empieza a preguntar como es que hizo para programar hasta aquí , sin
ellos . La respuesta es que no lo ha hecho , ya que los hemos usado en forma
encubierta , sin decir lo que eran . ( Perdón por el pequeño engaño
).
Veamos primero , como se declara un puntero :
tipo de variable apuntada *nombre_del_puntero ; int *pint ; double *pfloat ; char *letra , *codigo , *caracter ;
En estas declaraciones sólo decimos al compilador que reserve una
posición de memoria para albergar la dirección de una variable
, del tipo indicado , la cual será referenciada con el nombre que hayamos
dado al puntero .
Obviamente , un puntero debe ser inicializado antes de usarse , y una de las
eventuales formas de hacerlo es la siguiente:
int var1 ; /* declaro ( y creo en memoria ) una variable entera ) */ int *pint ; /* " " " " " un puntero que contendrá la dirección de una variable entera */ pint = &var1 ; /* escribo en la dirección de memoria donde está el puntero la dirección de la variable entera */
Como habiamos anticipado en capítulos anteriores " &nombre_de_una_variable " implica la dirección de la misma . Si se pregunta porque no se usaron otros símbolos en vez de & y * , que se confunden con la Y lógica de bits y el producto , ..... consuelese pensando que yo también me hice siempre esa pregunta . De cualquier manera es siempre obvio , en el contexto del programa el uso de los mismos .
Esquematicamente , lo que hemos hecho se puede simbolizar de la siguiente manera : donde dentro del recuadro está el contenido de cada variable .
Pint xxxxxx valor contenido por var1 Dirección de var1 yyyyyy (posición de memoria xxxxxx (posición de memoria ocupada por el puntero ) ocupada por la variable)
En realidad , como veremos más adelante , en la declaración
del puntero , está implicita otra información : cual es el tamaño
(en bytes) de la variable apuntada.
El símbolo & , ó dirección , puede aplicarse a variables
, funciones , etc , pero nó a constantes ó expresiones , ya que
éstas no tienen una posición de memoria asignada.
La operación inversa a la asignación de un puntero , de referenciación
del mismo , se puede utilizar para hallar el valor contenido por la variable
apuntada . Así por ejemplo serán expresiones equivalentes :
y = var1 ; y = *pint ; printf("%d" , var1 ) ; printf("%d" , *pint) ;
En estos casos , la expresión " *nombre_del_puntero " , implica " contenido de la variable apuntada por el mismo " . Veamos un corto ejemplo de ello :
#include <stdio.h> main() { char var1 ; /*una variable del tipo caracter */ char *pchar; /* un puntero a una variable del tipo caracter */ pc = &var1 ; /*asignamos al puntero la direccion de la variable */ for (var1 = 'a'; var1 <<= 'z'; var1++) printf("%c", *pchar) ; /* imprimimos el valor de la variable apuntada */ return 0 ; }
Vemos acá , que en el FOR se incrementa el valor de la variable ,
y luego para imprimirla usamos la dereferenciación de su puntero.
El programa imprimirá las letras del abecedario de la misma manera que
lo habría hecho si la sentencia del printf() huiera sido, printf("%c"
, var1 ) .
Hay un error , que se comete con bastante frecuencia , y es cargar en la dirección
apuntada por un puntero a un tipo dado de variable , el contenido de otro tipo
de las mismas , por ejemplo :
double d = 10.0 ; int i = 7 , *pint ; pint = &i ; *pint = 10 ; /* correcto,equivale a asignar a i el valor 10 */ ; *pint = d ; /* ERROR se pretende cargar en una variable entera un valor double */ pint = &d ; /* INCORRECTO se pretende apuntar a una variable double con un puntero declarado como apuntador a int */ pint = 4358 ; /* ?????? */
El primer error , la asignación de un double , produce la pérdida
de información dada por la conversión automática de tipo
de variable , ya vista anteriormente , el segundo produce un llamado de atención
rotulado como " asignación sospechosa de un pointer " . Resumiendo
, las variables ó constantes cargadas por dereferenciación de
un puntero , deben coincidir en tipo con la declaración de aquel .
La asignación de una constante a un pointer , y no a la variable apuntada
por él , es un serio error , ya que debe ser el compilador , el encargado
de poner en él el valor de la dirección , aquel así lo
declara dando un mensaje de " conversión de puntero no transportable
" . Si bien lo compila , ejecutar un programa que ha tenido esta advertencia
es similar a jugar a la ruleta rusa , puede "colgarse" la máquina
ó lo que es peor destruirse involuntariamente información contenida
en un disco , etc.
Hay un sólo caso en el que esta asignación de una constante a
un puntero es permitida , muchas funciones para indicar que no pueden realizar
una acción ó que se ha producido un error de algun tipo , devuelven
un puntero llamado "Null Pointer" , lo que significa que no apunta
a ningun lado válido , dicho puntero ha sido cargado con la dirección
NULL ( por lo general en valor 0 ) , así la asignación : pint
= NULL ; es válida y permite luego operaciones relacionales del tipo
if( pint ) ..... ó if( print != NULL ) para convalidar la validez del
resultado devuelto por una función .
Una advertencia : si bien volveremos más adelante sobre este tema , debemos
desde ahora tener en cuenta que los punteros no son enteros , como parecería
a primera vista , ya que el número que representa a una posición
de memoria , sí lo es . Debido al corto alcance de este tipo de variable
, algunos compiladores pueden , para apuntar a una variable muy lejana , usar
cualquier otro tipo , con mayor alcance que el antedicho .
2. PUNTEROS Y ARRAYS
Hay una relación muy cercana entre los punteros y los arrays . Yá
vimos previamente que el designador ( ó nombre de un array ) era equivalente
a la dirección del elemento [0] del mismo . La explicación de
ésto es ahora sencilla : 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 , que haremos
notar más abajo.
Veamos algunas operaciones permitidas entre punteros :
ASIGNACION
float var1 , conjunto[] = { 9.0 , 8.0 , 7.0 , 6.0 , 5.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 var1 el
valor del mismo (9.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 . Si lo piensa un poco , es lógico , ya que "conjunto"
implica la dirección del elemento conjunto [0] , por lo que , si yo cambiara
su valor , apuntaría a otro lado dejando de ser , "conjunto"
. Desde este punto de vista , el siguiente ejemplo nos muestra un tipo de error
bastante frecuente:
ASIGNACION ERRONEA
int conjunto[5] , lista[] = { 5 , 6 , 7 , 8 , 0 ) ; 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 */
Veamos ahora las distintas modalidades del incremento de un puntero :
INCREMENTO O DECREMENTO DE UN PUNTERO
int *pint , arreglo_int[5] ; double *pdou , arreglo_dou[6] ; pint = arreglo_int ; /* pint apunta a arreglo_int[0] */ pdou = arreglo_dou ; /* pdou apunta a arreglo_dou[0] */ pint += 1 ; /* pint apunta a arreglo_int[1] */ pdou += 1 ; /* pdou apunta a arreglo_dou[1] */ pint++ ; /* pint apunta a arreglo_int[2] */ pdou++ ; /* pdou apunta a arreglo_dou[2] */
Hemos declarado y asignado dos punteros , uno a int y otro a double , con
las direcciones de dos arrays de esas caracteristicas . Ambos estarán
ahora apuntando a los elementos [0] de los arrays . En las dos instrucciones
siguientes incrementamos en uno dichos punteros . ¿ adonde apuntaran
ahora ?.
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_dou[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 es aplicable , en identica manera , al operador de decremento
-- .
ARITMETICA DE DEREFERENCIA
Debido a que los operadores * y ++ ó -- tienen la misma precedencia y
se evaluan de derecha a izquierda , y los paréntesis tienen mayor precedencia
que ambos , muchas operaciones que los utilizan en conjunto a todos estos operadores
, pueden parecer poco claras y dar origen a un sinnúmero de errores ,
(revise un poco la TABLA 13 del capítulo 3 ) analicémoslas detalladamente
, partiendo de :
int *p , a[] = { 0 , 10 , 20 , 30 , 40 , 50 , 60 , 70 , 80 , 90 } ; int var ; p = a ;
A partir de aquí , el puntero está apuntando a a[0] . Veamos las distintas variantes que puede tener la siguiente instrucción:
*p = 27 ;
La más sencilla de las opciones , simplemente asignamos al elemento apuntado por p ( a[0] ) un valor constante . Veamos la inversa de ella:
var = *p ;
var sería asignada al valor 0 (contenido de a[0]) , y p seguiría apuntando al mismo elemento. Que hubiera pasado, si en vez de ello se hubiera escrito:
var = *( p + 1 ) ;
acá podríamos traducir el sentido de la operación como
: cargue var con el contenido del elemento siguiente al apuntado por p ( a[1]
) . Lo interesante de remarcar acá es que p , en sí mismo , NO
VARIA Y LUEGO DE ESTA SENTENCIA SEGUIRA APUNTANDO A a[0] . De la misma forma
: var = *( p + 3 ) asignará 30 a var , sin modificar el contenido de
p .
En cambio la expresión :
var = *( p++ ) ;
podemos leerla como : asigne a var el valor de lo apuntado por p y LUEGO incremente éste para que apunte al proximo elemento . Así en var quedaría 0 ( valor de a[0] ) y p apuntaría finalmente a a[1] . Si en vez de ésto hubieramos preincrementado a p tendríamos :
var = *( ++p ) ;
la que puede leerse como : apunte con p al próximo elemento y asigne
a var con el valor de éste . En este caso var sería igualada a
10 ( a[1] ) y p quedaría apuntando al mismo .
En las dos operaciones anteriores los paréntesis son superfluos ya que
al analizarse los operadores de derecha a izquierda , daría lo mismo
escribir :
var = *p++ ; /* sintácticamente igual a var = *(p++) */ var = *++p ; /* " " " var = *(++p) */
3. ARITMETICA DE PUNTEROS
La aritmética más frecuentemente usada con punteros son las sencillas
operaciones de asignación , incremento ó decremento y dereferenciación
. Todo otro tipo de aritmética con ellos está prohibida ó
es de uso peligroso ó poco transportable . Por ejemplo no está
permitido , sumar , restar , dividir , multiplicar , etc , dos apuntadores entre
sí . Lo cual si lo pensamos un poco es bastante lógico , ya que
de nada me serviría sumar dos direcciones de memoria , por ejemplo .
Otras operaciones estan permitidas , como la comparación de dos punteros
, por ejemplo ( punt1 == punt2 ) ó ( punt1 < punt2 ) sin embargo este
tipo de operaciones son potencialmente peligrosas , ya que con algunos modelos
de pointers pueden funcionar correctamente y con otros no .
4. PUNTEROS Y VARIABLES DINAMICAS
Recordemos lo expresado en capítulo 5 , sobre el ámbito ó
existencia de las variables , la menos duradera de ellas era la del tipo local
a una función , ya que nacía y moría con ésta .
Sin embargo , esto es algo relativo , en cuanto a la función main() ,
ya que sus variables locales ocuparán memoria durante toda la ejecución
del programa.
Supongamos un caso típico , debemos recibir una serie de datos de entrada
, digamos del tipo double , y debemos procesar según un determinado algoritmo
a aquellos que aparecen una ó más veces con el mismo valor .
Si no estamos seguros de cuantos datos van a ingresar a nuestro programa , pondremos
alguna limitación , suficientemente grande a los efectos de la precisión
requerida por el problema , digamos 5000 valores como máximo , debemos
definir entonces un array de doubles capaz de albergar a cinco mil de ellos
, por lo que el mismo ocupará del orden de los 40 k de memoria .
Si definimos este array en main() , ese espacio de memoria permanecerá
ocupado hasta el fín del programa , aunque luego de aplicarle el algoritmo
de cálculo ya no lo necesitemos más , comprometiendo seriamente
nuestra disponibilidad de memoria para albergar a otras variables . Una solución
posible sería definirlo en una función llamada por main() que
se ocupara de llenar el array con los datos , procesarlos y finalmente devolviera
algún tipo de resultado , borrando con su retorno a la masiva variable
de la memoria .
Sin embargo en C existe una forma más racional de utilizar nuestros recursos
de memoria de manera conservadora . Los programas ejecutables creados con estos
compiladores dividen la memoria disponible en varios segmentos , uno para el
código ( en lenguaje máquina ) , otro para albergar las variables
globales , otro para el stack ( a travez del cual se pasan argumentos y donde
residen las variables locales ) y finalmente un último segmento llamado
memoria de apilamiento ó amontonamiento ( Heap ) .
El Heap es la zona destinada a albergar a las variables dinámicas , es
decir aquellas que crecen ( en el sentido de ocupación de memoria ) y
decrecen a lo largo del programa , pudiendose crear y desaparecer (desalojando
la memoria que ocupaban) en cualquier momento de la ejecución .
Veamos cual sería la metodología para crearlas ; supongamos primero
que queremos ubicar un único dato en el Heap , definimos primero un puntero
al tipo de la variable deseada :
double *p ;
notemos que ésta declaración no crea lugar para la variable , sino que asigna un lugar en la memoria para que posteriormente se guarde ahí la dirección de aquella Para reservar una cantidad dada de bytes en el Heap , se efectua una llamada a alguna de las funciones de Librería , dedicadas al manejo del mismo . La más tradicional es malloc() ( su nombre deriva de memory allocation ) , a esta función se le dá como argumento la cantidad de bytes que se quiere reservar , y nos devuelve un pointer apuntando a la primer posición de la "pila" reservada . En caso que la función falle en su cometido ( el Heap está lleno ) devolvera un puntero inicializado con NULL .
p = malloc(8) ;
acá hemos pedido 8 bytes ( los necesarios para albergar un double
) y hemos asignado a p el retorno de la función , es decir la dirección
en el Heap de la memoria reservada.
Como es algo engorroso recordar el tamaño de cada tipo variable , agravado
por el hecho de que , si reservamos memoria de esta forma , el programa no se
ejecutará correctamente , si es compilado con otro compilador que asigne
una cantidad distinta de bytes a dicha variable , es más usual utilizar
sizeof , para indicar la cantidad de bytes requerida :
p = malloc( sizeof(double) ) ;
En caso de haber hecho previamente un uso intensivo del Heap , se debería averiguar si la reserva de lugar fué exitosa:
if( p == NULL ) rutina_de_error() ;
si no lo fué estas sentencias me derivan a la ejecución de una rutina de error que tomará cuenta de este caso . Por supuesto podría combinar ambas operaciones en una sola ,
if( ( p = malloc( sizeof(double) ) ) == NULL ) { printf("no hay mas lugar en el Heap ..... Socorro !!" ) ; exit(1) ; }
se ha reemplazado aquí la rutina de error , por un mensaje y la terminación
del programa , por medio de exit() retornando un código de error .
Si ahora quisiera guardar en el Heap el resultado de alguna operación
, sería tan directo como,
*p = a * ( b + 37 ) ;
y para recuperarlo , y asignarselo a otra variable bastaría con escribir :
var = *p ;
5. PUNTEROS A STRINGS
No hay gran diferencia entre el trato de punteros a arrays , y a strings , ya
que estos dos últimos son entidades de la misma clase . Sin embargo analicemos
algunas particularidades . Así como inicializamos un string con un grupo
de caracteres terminados en '\0' , podemos asignar al mismo un puntero :
p = "Esto es un string constante " ;
esta operación no implica haber copiado el texto , sino sólo que a p se le ha asignado la dirección de memoria donde reside la "E" del texto . A partir de ello podemos manejar a p como lo hemos hecho hasta ahora . Veamos un ejemplo
#include <stdio.h> #define TEXTO1 "¿ Hola , como " #define TEXTO2 "le va a Ud. ? " main() { char palabra[20] , *p ; int i ; p = TEXTO1 ; for( i = 0 ; ( palabra[i] = *p++ ) != '\0' ; i++ ) ; p = TEXTO2 ; printf("%s" , palabra ) ; printf("%s" , p ) ; return 0 ; }
Definimos primero dos strings constantes TEXTO1 y TEXTO2 , luego asignamos al
puntero p la dirección del primero , y seguidamente en el FOR copiamos
el contenido de éste en el array palabra , observe que dicha operación
termina cuando el contenido de lo apuntado por p es el terminador del string
, luego asignamos a p la dirección de TEXTO2 y finalmente imprimimos
ambos strings , obteniendo una salida del tipo : " ¿ Hola , como
le va a UD. ? " ( espero que bien ) .
Reconozcamos que esto se podría haber escrito más compacto, si
hubieramos recordado que palabra tambien es un puntero y NULL es cero , así
podemos poner en vez del FOR
while( *palabra++ = *p++ ) ;
Vemos que aquí se ha agregado muy poco a lo ya sabido , sin embargo hay un tipo de error muy frecuente , que podemos analizar , fíjese en el EJEMPLO siguiente , ¿ ve algun problema ? .
( CON ERRORES )
#include <stdio.h> char *p , palabra[20] ; printf("Escriba su nombre : ") ; scanf("%s" , p ) ; palabra = "¿ Como le va " ; printf("%s%s" , palabra , p ) ; }
Pues hay dos errores , a falta de uno , el primero ya fue analizado antes
, la expresión scanf("%s" , p ) es correcta pero , el error
implícito es no haber inicializado al puntero p , el cual sólo
fué definido , pero aun no apunta a ningun lado válido . El segundo
error está dado por la expresión : palabra = " ¿ Como
le va " ; ( también visto anteriormente ) ya que el nombre del array
es una constante y no puede ser asignado a otro valor .
¿Como lo escribiríamos para que funcione correctamente ?
(CORRECTO)
#include <stdio.h> #include <stdlib.h> #include <string.h> char *p , palabra[20] ; p = (char *)malloc(sizeof(char)128) ; printf("Escriba su nombre : ") ; scanf("%s" , p ) ; strcpy(palabra , "¿ Como le va " ) ; printf("%s%s" , palabra , p ) ; }
Observe que antes de scanf() se ha inicializado a p, mediante el retorno
de malloc() y a al array palabra se le copiado el string mediante la función
vista anteriormente strcpy().
Debemos aclarar también que, la secuencia de control %s en el printf()
impone enviar a la pantalla un string, estando éste apuntado por el argumento
siguiente al control, éste puede ser tanto el nombre de un array, como
un puntero, ya que ambos explicitan direcciones.
Una forma alternativa de resolverlo , sería:
( CORRECTO )
#include <stdio.h> main() { char p[20] , *palabra ; printf("Escriba su nombre : ") ; scanf("%s" , p ) ; palabra = "¿ Como le va " ; printf("%s%s" , palabra , p ) ; }
Obsérvese , que es idéntico al primero , con la salvedad que se ha invertido las declaraciones de las variables , ahora el puntero es palabra y el array es p . Ambas soluciones son equivalentes y dependerá del resto del programa , cual es la mejor elección .
6. ARRAYS DE PUNTEROS
Es una práctica muy habitual , sobre todo cuando se tiene que tratar
con strings de distinta longitud , generar array cuyos elementos son punteros
, que albergarán las direcciones de dichos strings.
Si imaginamos a un puntero como una flecha , un array de ellos equivaldría
a un carcaj indio lleno de aquellas .
Asi como:
char *flecha;
definía a un puntero a un caracter , la definición
char *carcaj[5];
implica un array de 5 punteros a caracteres .
INICIALIZACION DE ARRAYS DE PUNTEROS
Los arrays de punteros pueden ser inicializados de la misma forma que un array
común , es decir dando los valores de sus elementos , durante su definición
, por ejemplo si quisieramos tener un array donde el subíndice de los
elementos coincidiera con el nombre de los días de la semana , podríamos
escribir :
char *dias[] = { "número de día no válido" , "lunes" , "martes" , "miercoles" , "jueves" , "viernes" , "sabado" , "por fín es domingo" }
Igual que antes, no es necesario en este caso indicar la cantidad de elementos , ya que el compilador los calcula por la cantidad de términos dados en la inicialización. Asi el elemento dias[0] será un puntero con la dirección del primer string, dias[1], la del segundo, etc.
7. PUNTEROS A ESTRUCTURAS
Los punteros pueden también servir para el manejo de estructuras , y
su alojamiento dinámico , pero tienen además la propiedad de poder
direccionar a los miembros de las mismas utilizando un operador particular ,
el -> , (escrito con los símbolos "menos" seguido por "mayor"
) .
Supongamos crear una estructura y luego asignar valores a sus miembros , por
los métodos ya descriptos anteriormente :
struct conjunto { int a ; double b ; char c[5] ; } stconj ; stconj.a = 10 ; stconj.b = 1.15 ; stconj.c[0] = 'A' ;
La forma de realizar lo mismo , mediante el uso de un puntero, sería la siguiente :
struct conjunto { int a ; double b ; char c[5] ; } *ptrconj ; ptrconj = (struct conjunto *)malloc( sizeof( struct conjunto )) ; ptrconj->a = 10 ; ptrconj->b = 1.15 ; ptrconj->c[0] = 'A' ;
En este caso vemos que antes de inicializar un elemento de la estructura
es necesario alojarla en la memoria mediante malloc(), observe atentamente la
instrucción: primero se indica que el puntero que devuelve la función
sea del tipo de apuntador a conjunto (ésto es sólo formal), y
luego con sizeof se le da como argumento las dimensiones en bytes de la estructura.
Acá se puede notar la ventaja del uso del typedef , para ahorrar tediosas
repeticiones de texto, y mejorar la legilibilidad de los listados; podríamos
escribir:
typedef struct { int a ; double b ; char c[5] ; } conj ; conj *ptrconj ; ptrconj = ( conj *)malloc( sizeof( conj )) ;
Es muy importante acá , repasar la TABLA 13 del final del capítulo
3 , donde se indican las precedencias de los operadores , a fín de evitar
comportamientos no deseados , cuando se usan simultaneamente varios de ellos
.
Ya que c es un array podemos escribir :
x = *ptrconj -> c ;
la duda acá es, si nos referimos al contenido apuntado por ptrconj
ó por c.
Vemos en la tabla que, el operador -> es de mayor precedencia que la de *
(dereferenciación), por lo que, el resultado de la expresión es
asignar el valor apuntado por c, es decir el contenido de c[0] .
De la misma forma:
*ptrconj -> c++ ; incrementa el puntero c , haciendolo tener la direccion de c[1] y luego extrae el valor de éste . ++ptrconj -> c ; incrementa el valor de c[0] .
En caso de duda , es conveniente el uso a discreción de paréntesis , para saltar por sobre las , a veces complicadas , reglas que impone la precedencia así , si queremos por ejemplo el valor de c[3] , la forma más clara de escribir es:
*( ptrconj -> ( c + 4 ) ) ; (Recuerde que c[3] es el CUARTO elemento del array ).
8. PUNTEROS Y FUNCIONES
La relación entre los punteros y las funciones , puede verse en tres
casos distintos , podemos pasarle a una función un puntero como argumento
(por supuesto si su parámetro es un puntero del mismo tipo ) , pueden
devolver un puntero de cualquier tipo , como ya hemos visto con malloc() y calloc()
, y es posible también apuntar a la dirección de la función
, en otras palabras , al código en vez de a un dato.
PUNTEROS COMO PARAMETROS DE FUNCIONES .
Supongamos que hemos declarado una estructura , se puede pasar a una función
como argumento , de la manera que ya vimos anteriormente:
struct conjunto { int a ; double b ; char c[5] ; } datos ; void una_funcion( struct conjunto datos );
Hicimos notar, en su momento, que en este caso la estructura se copiaba en
el stack y así era pasada a la función, con el peligro que esto
implicaba, si ella era muy masiva, de agotarlo.
Otra forma equivalente es utilizar un puntero a la estructura :
struct conjunto { int a ; double b ; char c[5] ; } *pdatos ; void una_funcion( struct conjunto *pdatos ) ;
Con lo que sólo ocupo lugar en el stack para pasarle la dirección
de la misma. Luego en la función, como todos los miembros de la estructuras
son accesibles por medio del puntero, tengo pleno control de la misma.
Un ejemplo de funciones ya usadas que poseen como parámetros a punteros
son:
scanf(puntero_a_string_de_control , punteros_a_variables) printf(puntero_a_string_de_control , variables )
En ambas vemos que los strings de control son , como no podría ser de otro modo , punteros , es decir que los podríamos definir fuera de la función y luego pasarselos a ellas :
p_control = "valor : %d " ; printf( p_control , var ) ;
PUNTEROS COMO RESULTADO DE UNA FUNCION
Las funciones que retornan punteros son por lo general aquellas que modifican
un argumento , que les ha sido pasado por dirección ( por medio de un
puntero ) , devolviendo un puntero a dicho argumento modificado , ó las
que reservan lugar en el Heap para las variables dinámicas , retornando
un puntero a dicho bloque de memoria .
Así podremos declarar funciónes del tipo de:
char *funcion1( char * var1 ) ; double *funcion2(int i , double j , char *k ) ; struct item *funcion3( struct stock *puntst ) ;
El retorno de las mismas puede inicializar punteros del mismo tipo al devuelto , ó distinto , por medio del uso del casting . Algunas funciones , tales como malloc() y calloc() definen su retorno como punteros a void :
void *malloc( int tamano ) ;
de esta forma al invocarlas , debemos indicar el tipo de puntero de deseamos
p = (double *)malloc( 64 ) ;