Facultad de Ingeniería

Departamento de Electrónica y Automática

Unidad V
Punteros

Cátedra:
Computación II (ELO)
Informática II (BIO)
COMPUTACIÓN II (ELO) - INFORMÁTICA II (BIO) Introducción al Lenguaje de Programación C

INDICE
5 Punteros................................................................................................................................................. 1
5.1 Introducción.................................................................................................................................... 1
5.2 Conceptos básicos .......................................................................................................................... 1
5.3 Declaración de punteros ................................................................................................................. 2
5.4 Paso de punteros a una función ...................................................................................................... 4
5.5 Punteros y arreglos unidimensionales ............................................................................................ 5
5.6 Operaciones con punteros .............................................................................................................. 7
5.6.1 Punteros de tipo “genérico”. ................................................................................................. 10
5.7 Asignación dinámica de memoria ................................................................................................ 10
5.8 Punteros y arreglos multidimensionales....................................................................................... 11
5.8.1 Arreglo de punteros............................................................................................................... 12
5.8.2 Puntero a un arreglo de punteros........................................................................................... 13
5.9 Punteros a funciones..................................................................................................................... 15
5.10 Algo más sobre declaración de punteros .................................................................................. 17
5.11 Ejercitación con punteros ......................................................................................................... 18
COMPUTACIÓN II (ELO) - INFORMÁTICA II (BIO)

Capítulo 5

5 Punteros

5.1 Introducción
Un puntero es una clase de variable cuyo contenido no es un dato directamente usable, sino
que almacena la posición de memoria (la dirección de memoria) de otro dato, tal como una
variable o un elemento de un arreglo. Los punteros son usados frecuentemente en C y tienen
gran cantidad de aplicaciones. El uso cuidadoso de los punteros provee claridad y simplicidad
al programa. Los punteros, por ejemplo, pueden usarse para pasar información entre una
función y sus puntos de llamada, y en particular proporcionan una forma de devolver varios
datos desde una función mediante los propios argumentos de la misma. Además, permiten
asignar dinámicamente la memoria necesaria para una variable o conjunto de variables,
manejar listas encadenadas y acceder a distintas posiciones dentro de una misma estructura
de datos, por ejemplo arreglos, cadenas, estructuras, etc.
Los punteros están muy relacionados con los arreglos y proporcionan una vía alternativa de
acceso a los elementos individuales de los mismos. Es más, proporcionan una forma
conveniente para representar arreglos multidimensionales.

5.2 Conceptos básicos

Dentro de la memoria de la computadora cada dato almacenado ocupa una o más celdas de
memoria contiguas. El número de celdas de memoria requeridas para almacenar un dato
depende de su tipo (es decir si el dato es char, int, float, etc). Por ejemplo, un caracter será
almacenado normalmente en un byte, un entero en dos bytes contiguos, un flotante puede
necesitar cuatro y una cantidad en doble precisión puede requerir ocho bytes contiguos.
Suponga que v es un variable que representa cierto dato. El compilador automáticamente
asignará celdas de memoria para ese dato. Se puede acceder al dato si conocemos la
localización (la dirección) de la primera celda de memoria. La dirección de memoria de la
variable v puede determinarse mediante la expresión &v, donde & es un operador monario,
llamado el operador de dirección, que proporciona la dirección del operando.
Ahora vamos a asignar la dirección de v a otra variable, pv. Así,
pv = &v;

Esta nueva variable (pv) es un puntero a la variable v. Recordar, sin embargo, que pv
representa la dirección de v y no su valor. De esta forma pv se refiere como variable puntero.
La relación entre estas dos variables esta ilustrada en la figura 1.

dirección de v valor de v

pv v
Figura 1- Relación entre v y pv.
El dato representado por v puede ser accedido por la expresión *pv, donde * es un operador
monario, llamado el operador indirección, que opera solo sobre una variable puntero. Por lo
tanto, *pv y v representan el mismo dato (el contenido de las mismas celdas de memoria).
Además, si escribimos,
1
COMPUTACIÓN II (ELO) - INFORMÁTICA II (BIO)

pv = &v;
u = *pv;
entonces u y v representan el mismo valor (se asume que u y v están declaradas como
variables del mismo tipo de dato).

Operador Descripción
& Retorna la dirección de memoria de una variable.
* Retorna el valor de la variable cuya dirección se especifica.
Los operadores monarios & y * son miembros del mismo grupo de precedencia que los otros
operadores monarios, por ejemplo -, ++, --, !, sizeof(tipo), que fueron presentados en
el Capítulo 2 . Se debe recordar que este grupo de operadores tiene mayor precedencia que el
de los operadores aritméticos y la asociatividad de los operadores monarios es de derecha a
izquierda. El operador & sólo puede actuar sobre operandos con dirección única, como
variables ordinarias o elementos de un arreglo. Por consiguiente, el operador dirección no
puede actuar sobre expresiones aritméticas, tales como 2 * (u + v).
El operador indirección * sólo puede actuar sobre operandos que sean punteros. Sin embargo,
si pv apunta a v (pv = &v), entonces una expresión como *pv puede ser intercambiable con
la correspondiente variable v. Así una referencia indirecta puede aparecer en lugar de una
variable dentro de una expresión mas complicada.
Considere el siguiente ejemplo,
#include <stdio.h>
int main( ) {
int u1, u2;
int v = 3;
int *pv; /* puntero a enteros */

u1 = 2 * (v + 5); /* expresión ordinaria */

pv = &v; /* pv apunta a v */
u2 = 2 * (*pv + 5); /*expresión alternativa */
printf("\nu1 = %d u2 = %d", u1, u2);
return 0;
}
En este programa la salida u1 y u2 son iguales ya que v y *pv representan al mismo dato.
Las variables puntero pueden apuntar a variables numéricas o de caracteres, arreglos, funciones
u otras variables puntero, y a otras estructuras de datos como veremos posteriormente. Por tanto,
a una variable puntero se le puede asignar la dirección de una variable ordinaria (por ejemplo pv
= &v). También se le puede asignar la dirección de otra variable puntero (por ejemplo pv = px),
siempre que ambas variables puntero apunten al mismo tipo de dato. Además, a una variable
puntero se le puede asignar un valor nulo (cero), como se explicará posteriormente. Por otra
parte, a variables ordinarias no se les puede asignar direcciones arbitrarias (una expresión como
&x no puede aparecer en la parte izquierda de una oración de asignación).

5.3 Declaración de punteros

Los punteros como cualquier otra variable, deben ser declarados antes de ser usados dentro
de un programa en C. Sin embargo, la interpretación de una declaración de puntero es un poco
2
COMPUTACIÓN II (ELO) - INFORMÁTICA II (BIO)

diferente a la declaración de otras variables. Cuando una variable puntero es definida, el

nombre de la variable debe ir precedida por un *. Este identifica que la variable es un puntero.
El tipo de dato que aparece en la declaración se refiere al tipo de dato al que hará referencia el
puntero.
El formato de la declaración de un puntero es el siguiente:
<tipo_apuntado> *<nbre_puntero>;

Donde nbre-puntero es el nombre de la variable puntero y tipo-apuntado se refiere al tipo de

dato apuntado por el puntero.
Por ejemplo,
int *px;
float *pv;
Esta declaración limita el tipo de los datos a los que puede apuntar el puntero. Por ejemplo en el
caso anterior:
int *px;
Significa que px solo debe apuntar a datos de tipo entero o convertible a ese tipo.
Es posible hacer las siguientes asignaciones:
*px=0; /* asigna cero a la dirección donde apunta px */
*px+=1; /* incrementa en uno el contenido apuntado por px */
px=py; /* asigna la dirección de py a px */
Las siguientes asignaciones no son equivalentes:
(*px)++; /* Incrementa en uno el contenido apuntado por px */
*px++; /* Incrementa en uno el puntero y toma el valor apuntado por px */

El siguiente ejemplo muestra la declaración de variables punteros y su asignación:

int main( ) {
int ivar,*iptr;

iptr=&ivar; /* la dirección de ivar es asignada a iptr */

ivar=122;
printf("Dirección de ivar : %p\n",&ivar);
printf("Contenido de ivar : %d\n",ivar);
printf("Contenido de iptr : %p\n",iptr);
printf("Valor apuntado por iptr: %d\n",*iptr);
return 0;
}
Tras la ejecución de este programa los resultados serán:
Dirección de ivar: 166E
Contenido de ivar: 122
Contenido de iptr: 166E
Valor apuntado por iptr: 122
La función main declara dos variables ivar e iptr. La primera es una variable entera, mientras
que la segunda es un puntero a un dato de tipo entero. Dentro de la función printf, en la cadena
de control aparece el caracter de formato %p que se utiliza para exteriorizar el contenido de
variables puntero.

3
COMPUTACIÓN II (ELO) - INFORMÁTICA II (BIO)

Dentro de la declaración de variable, una variable puntero puede ser inicializada asignándole la
dirección de otra variable. Tener en cuenta que la variable cuya dirección se asigna al puntero
debe estar previamente declarada en el programa. Por ejemplo, un programa contiene las
siguientes declaraciones,
float u, v;
float *pv = &v;
Las variables u y v son declaradas como variables de punto flotante y pv es declarada como
una variable puntero que apunta a cantidades de punto flotante y se le asigna la dirección de la
variable v.

5.4 Paso de punteros a una función

Debido a que el lenguaje C pasa los argumentos por valor, no existe forma directa de que una
función llamada altere una variable de la función llamadora. ¿Como hacer si hubiera que
modificar realmente el contenido de los argumentos pasados?
Por ejemplo la función intercambio(), la cual tiene como objetivo intercambiar el contenido de
dos variables enteras. En un primer intento podemos escribir la siguiente función:
void intercambio(int x, int y) {
int temp;
temp=x;
x=y;
y=temp;
}
Esta función no cumple con los requerimientos de modificación de las variables pasadas como
parámetros actuales. Pues los parámetros formales x e y reciben el valor y por ello no alteran las
variables pasadas por la función llamadora.
Tratando de corregir los errores anteriores escribimos la siguiente versión de la función
intercambio( ).
void intercambio(int *px, int *py) {
int temp;
temp=*x;
*px=*py;
*py=temp;
}
Se puede apreciar ahora que los parámetros pasados son direcciones de variables enteras, de
esta forma utilizando punteros a ellas se logra el objetivo, es decir alterar los valores de las
variables pasadas por la función llamadora.
En este caso se debe invocar la función intercambio() de la siguiente manera,
intercambio(&x, &y);
Un ejemplo que ya hemos visto es la función de biblioteca scanf, que requiere que sus
argumentos vayan precedidos por &. Así la función scanf requiere que sea especificada la
dirección de los elementos que vayan a ser introducidos en la memoria de la computadora. El
operador & (ampersand) proporciona entonces un medio eficaz para acceder a las direcciones
de variables ordinarias univaluadas.

4
COMPUTACIÓN II (ELO) - INFORMÁTICA II (BIO)

5.5 Punteros y arreglos unidimensionales

En C existe una estrecha relación entre punteros y arreglos. Las operaciones que se realizan
con uno de ellos se pueden también hacer con el otro.
El lenguaje C tiene una característica muy particular y que consiste en que el nombre de un
arreglo es realmente un puntero al primer elemento de ese arreglo. Por ello, si x es el
nombre de un arreglo unidimensional, entonces la dirección del primer elemento del arreglo
puede expresarse tanto como &x[0] o simplemente como x. Además la dirección del segundo
elemento del arreglo se puede escribir como &x[1] o como (x + 1), y así sucesivamente.
En general, la dirección del elemento (i + 1) del arreglo se puede expresar o bien como
&x[i] o como (x + i). Por lo tanto, se tienen dos modos diferentes de escribir la dirección
de cualquier elemento de un arreglo: se puede escribir el elemento real precedido del operador
&, o se puede escribir una expresión en la cual el índice se añade al nombre del arreglo.
Debe entenderse que se esta tratando con un tipo especial e inusual de expresión. En la
expresión (x + i), por ejemplo, x representa una dirección e i representa una cantidad
entera. Además x es el nombre de un arreglo cuyos elementos pueden ser caracteres, enteros,
etc. Por lo tanto, no se está simplemente sumando valores numéricos. Mas bien se esta
especificando una dirección que está un cierto número de posiciones mas allá de la dirección
del primer elemento. En términos simples, se está especificando una ubicación que está i
elementos del arreglo detrás del primero. Cuando el índice i se utiliza de esta manera, recibe el
nombre de desplazamiento. Puesto que &x[i] y (x + i) representan la dirección del i-
ésimo elemento del arreglo x, sería razonable que x[i] y *(x + i) representen el
contenido de esa dirección, o sea el valor del i-ésimo elemento del arreglo x, y esto es cierto.
Los dos términos son intercambiables. Cada término puede utilizarse en cualquier aplicación
particular. La elección depende únicamente de las preferencias del programador.
El siguiente ejemplo ilustra la relación entre los elementos de un arreglo y sus direcciones,
#include <stdio.h>
int main(){
int x[10] = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19}, i;
for (i = 0; i <= 9; ++i) {
printf ("\nx[%d]= %d\t*(x + %d)= %d\t&x[%d]= %p\tx + %d=
%p",i,x[i],i,*(x + i),i,&x[i],i,x + i);
}
return 0;
}
Ejecutando el programa resulta la siguiente salida,
x[0]= 10 *(x + 0)= 10 &x[0]= 0194 x + 0= 0194
x[1]= 11 *(x + 1)= 11 &x[1]= 0196 x + 1= 0196
x[2]= 12 *(x + 2)= 12 &x[2]= 0198 x + 2= 0198
x[3]= 13 *(x + 3)= 13 &x[3]= 019A x + 3= 019A
x[4]= 14 *(x + 4)= 14 &x[4]= 019C x + 4= 019C
x[5]= 15 *(x + 5)= 15 &x[5]= 019E x + 5= 019E
x[6]= 16 *(x + 6)= 16 &x[6]= 01A0 x + 6= 01A0
x[7]= 17 *(x + 7)= 17 &x[7]= 01A2 x + 7= 01A2
x[8]= 18 *(x + 8)= 18 &x[8]= 01A4 x + 8= 01A4
x[9]= 19 *(x + 9)= 19 &x[9]= 01A6 x + 9= 01A6
Cuando asignamos un valor a un elemento de un arreglo, como x[i], la parte izquierda de la
asignación puede escribirse como x[i] o como *(x + i). De esta manera, un valor puede
5
COMPUTACIÓN II (ELO) - INFORMÁTICA II (BIO)

asignarse directamente a un elemento del arreglo o al área de memoria cuya dirección es la del
elemento del arreglo. Por otra parte, a veces es necesario asignar una dirección a un
identificador. En tales situaciones una variable puntero puede aparecer en la parte izquierda de
la asignación, sin embargo no es posible asignar una dirección arbitraria a un nombre de
arreglo o a un elemento del mismo. Por lo tanto, expresiones como x, (x + i) y &x[i] no
pueden aparecer en la parte izquierda de una asignación. Además, la dirección de un arreglo
no puede alterarse arbitrariamente, por lo que expresiones como ++x no están permitidas. En
general, la dirección de un arreglo declarado estáticamente como en el capítulo anterior es una
constante fijada por el compilador (el linker en realidad) y por ende, resulta imposible
cambiar su valor.
Para ejemplificar algunos de los aspectos enunciados consideremos el siguiente esqueleto de
programa,
#include <stdio.h>
int main( ) {
int linea[80];
int *pl;
...
/*asignar valores */
linea[2] = linea[1];
linea[2] = *(linea + 1);
*(linea + 2) = linea[1];
*(linea + 2) = *(linea + 1);
/* asignar direcciones */
pl = linea;
pl = &linea[0];
pl = &linea[1];
pl = linea + 1;
...
}
Cada una de las primeras cuatro oraciones de asignación le asigna el valor del segundo
elemento del arreglo (linea[1]) al tercer elemento del arreglo (linea[2]), por lo tanto las
cuatro son oraciones equivalentes. Cada una de las cuatro últimas estructuras asigna
direcciones. Las dos primeras asignan la dirección del primer elemento del arreglo al puntero
pl. Las dos últimas asignan la dirección del segundo elemento del arreglo al puntero pl.
Hemos establecido que un nombre de arreglo es en realidad un puntero al primer elemento dentro
del arreglo. Por lo tanto, debe ser posible definir un arreglo como una variable puntero en lugar de
definirlo como un arreglo convencional. Sintácticamente, las dos definiciones son equivalentes.
Sin embargo, la definición convencional de un arreglo produce la reserva de un bloque fijo
de memoria al principio de la ejecución de un programa, mientras que esto no ocurre si el
arreglo se representa en términos de una variable puntero. Como resultado del uso de una
variable puntero para representar un arreglo se torna necesario algún tipo de asignación inicial de
memoria, antes que los elementos del arreglo puedan ser utilizados. Generalmente, tales tipos de
reserva de memoria se realizan usando una función de la biblioteca <stdlib.h> llamada malloc
(por Memory ALLOCation), pero el método exacto varia de una aplicación a otra. Si el arreglo ha
sido definido como una variable puntero, no se le pueden asignar valores iniciales numéricos. Por
tanto, será necesaria una definición convencional si se quiere inicializar los valores de los
elementos de un arreglo.

6
COMPUTACIÓN II (ELO) - INFORMÁTICA II (BIO)

Para ilustrar este uso de punteros, considérese de nuevo el problema de ordenar una lista de
enteros que fue descrito en el capitulo de arreglos.
#include <stdio.h>
int main( ) {
int i, n, *x;
void reordenar(int n, int *x);
/* Leer el valor para n */
printf ("\nCuantos números serán introducidos? ");
scanf ("%d", &n);
printf("\n");
/* reserva de memoria */
x = (int *)malloc(n * sizeof(int));
/* leer la tabla de números */
for (i = 0; i < n; ++i) {
printf("\ni= %d x = ", i + 1);
scanf ("%d", x + i);
}
/* reordenar todos los elementos del arreglo */
reordenar (n, x);
/* mostrar la tabla reordenada */
printf ("\n\n La Tabla de números reordenada es: ");
for (i = 0; i < n; ++i) {
printf ("i = %d x = %d\n", i + 1, *(x + i));
}
free(x); /*se libera la memoria solicitada */
return 0;
}
void reordenar (int n, int *x) {
int i, elem, temp;
for (elem = 0; elem < n - 1; ++elem) {
/* buscar el menor del resto de los elementos */
for (i = elem + 1; i < n; ++i) {
if (*(x + i) < *(x + elem)) {
/* intercambiar los elementos */
temp = *(x + elem);
*(x + elem) = *(x + i);
*(x + i) = temp;
}
}
}
}

5.6 Operaciones con punteros

En la sección anterior se ha visto que se puede sumar un valor entero al nombre de un arreglo
para acceder a un elemento individual del mismo. El valor entero es interpretado como el índice
del arreglo. Esto funciona ya que todos los elementos del arreglo son del mismo tipo y por lo
tanto cada elemento ocupa el mismo número de celdas de memoria. El número de celdas que
separan a dos elementos del arreglo dependerán del tipo de datos del arreglo, pero de esto se

7
COMPUTACIÓN II (ELO) - INFORMÁTICA II (BIO)

encarga automáticamente el compilador y por tanto no concierne al programador directamente.

Este concepto puede extenderse a variables puntero. En particular, un valor entero puede
sumarse o restarse a una variable puntero, pero el resultado de la operación debe interpretarse
con cuidado. Supongamos por ejemplo, que px es una variable puntero que representa la
dirección de una variable x. Podemos escribir expresiones como ++px, --px, (px + 3), (px
+ i) y (px - i), donde i es una variable entera. Cada expresión representará una
dirección localizada a cierta distancia de la posición original representada por px. La distancia
exacta será el producto de la cantidad entera por el número de bytes que ocupa cada elemento
al cual apunta px. Por ejemplo, si px apunta a un entero, entonces la expresión (px + 3)
resultará en una dirección de igual a 3 * sizeof(int) bytes más allá del entero
apuntado por px.
px

px+3

Considere el siguiente programa en C para ilustrar lo antes mencionado,

#include <stdio.h>
int main( ) {
int *px; /* Puntero a un entero */
int i = 1;
float f = 0.3;
double d = 0.005;
char c = 'A';
px = &i; /* asigna la dirección de i al puntero px */
printf ("Valores: i=%d f=%f d=%f c=%c\n\n", i, f, d, c);
printf ("Direcciones: &i=%X &f=%X &d=%X &c=%X\n\n", &i, &f, &d, &c);
printf ("Valores de punteros: px=%X px+1=%X px+2=%X px+3=%X\n", px,
px+1,px+2,px+3);
return 0;
}
Este programa muestra los valores y las direcciones asociados con cuatro tipos diferentes de
variables. El programa también hace uso de una variable puntero, px, que representa la
dirección de i. También se muestran los valores de px, px+1, px+2, px+3 para que puedan ser
comparados con las direcciones de las diferentes variables. La ejecución del programa podría
producir la siguiente salida,
Valores: i=1 f=0.300000 d=0.005000 c='A'
Direcciones: &i=117E &f=1180 &d=1186 &c=118E
Valores de
punteros:
px=117E px+1=1180 px+2=1182 px+3=1184

Una variable puntero puede restarse de otra siempre que ambas variables apunten a elementos
del mismo arreglo. El valor resultante indica el número de elementos del tamaño del tipo de dato
especificado para el arreglo, que separan a los correspondientes elementos del arreglo.
En el siguiente programa, si se asume que los int tienen un tamaño de dos bytes, y dadas las
dos variables puntero apuntan al primero y al último elemento de un arreglo de enteros.

8
COMPUTACIÓN II (ELO) - INFORMÁTICA II (BIO)

#include <stdio.h>
int main( ) {
int *px, *py; /* punteros a enteros */
int a[6] = { 1, 2, 3, 4, 5, 6};
px = &a[0];
py = &a[5];
printf ("px=%X py=%X", px, py);
printf ("\n\npy - px = %X", py - px);
return 0;
}
Ejecutando el programa se produce la siguiente salida,
px= 52 py= 5C
py - px = 5

La primera linea indica que la dirección de a[0] es 52 y la dirección de a[5] es 5C. La

diferencia entre estos dos números hexadecimales es 10 en decimal (A en hexadecimal), sin
embargo el programa reporta 5, que es la cantidad de int entre x[0] y x[5].
Si se quisiera conocer la cantidad de bytes que existen efectivamente entre ambos elementos,
solo habría que multiplicar py-px por el sizeof(int).
Las variables puntero pueden compararse siempre que estas apunten a un mismo tipo de dato.
Tales comparaciones pueden ser útiles cuando ambas variables apunten a elementos de un
mismo arreglo. Las comparaciones pueden probar la igualdad o desigualdad. Además, una
variable puntero puede comparase con cero (normalmente expresado como la constante
simbólica NULL).
Suponga que px y py son variables puntero que apuntan a elementos de un mismo arreglo.
Algunas expresiones relacionando esas variables se muestran a continuación. Todas son
sintácticamente correctas.
(px < py)
(px >= py)
(px == py)
(px != py)
(px == NULL)
Estas expresiones pueden usarse de la misma manera que cualquier otra expresión lógica.
if(px < py)
printf("px < py");
else
printf("px >= py);
Finalmente, debe quedar claro que las operaciones discutidas previamente sólo pueden
realizarse con punteros. Estas operaciones están resumidas a continuación:
1. A una variable puntero se le puede asignar la dirección de una variable ordinaria. (Por
ejemplo: pv = &v).
2. A una variable puntero se le puede asignar el valor de otra variable puntero, (Por ejemplo
(px = py)), siempre que ambos apunten al mismo tipo de dato.
3. A una variable puntero se le puede asignar un valor nulo (cero). (Por ej.: pv = NULL).
4. Un entero puede sumarse o restarse a una variable puntero (Por ej.: ++px, pv+3).

9
COMPUTACIÓN II (ELO) - INFORMÁTICA II (BIO)

5. Una variable puntero puede ser restada de otra con tal que ambas apunten al mismo tipo de
datos.
6. Dos variables puntero pueden compararse siempre y cuando apunten a datos del mismo
tipo.
No se permiten otras operaciones aritméticas con punteros. Así una variable puntero no puede
ser multiplicada por una constante, dos punteros no pueden sumarse, etc.

5.6.1 Punteros de tipo “genérico”.

En ciertas oportunidades resulta necesario disponer de punteros cuya aritmética opere en base
a valores enteros y no proporcionales al tamaño del tipo de dato apuntado. Por ejemplo, si se
tiene:
int x[10];
int *px = x;
donde el valor de x es 0x1234, la operación (px + 1) no resultará en 0x1235 sino en
0x1234 + 1 * sizeof(int), que será 0x1236 si el tamaño del int es de 2 bytes, y esta
operación es consistente con lo ya visto.
La pregunta es entonces: como lograr que si se suma un valor k a un puntero este se
incremente efectivamente en k unidades y nó en k * sizeof(tipo)?
Para permitir este tipo de operatoria sin depender del tamaño de algún tipo de dato específico
se recurre a un tipo de punteros que son aquellos que tienen la capacidad de apuntar a todos
los tipos de datos y a ninguno de ellos en particular. El tipo de dato apuntado está dado por la
palabra void, y por ende, estos punteros se declaran así:
void *p;
Un puntero “a void” admite la dirección de memoria de cualquier tipo de dato, pero su
aritmética es independiente del tamaño de tales tipos. El siguiente ejemplo intenta mostrar
estos conceptos:
…
int a[ ] = { 1, 2, 3, 4, 5 };
int *pa = a;
void *vpa = a;
…

Dado que pa es un puntero a int, cualquier operación aritmética que se realice sobre él tendrá
necesariamente en cuenta el tamaño del tipo int, y si el valor de a fuera 0x1234 y el tamaño
del tipo int fuera de 2 bytes, el resultado de la operación (pa + 3) resultaría en 0x123A,
mientras que la operación (vpa + 3) resultaría en 0x1237 dado que vpa apunta al tipo
void.
Debe quedar claro que los desplazamientos que se realicen con un (void *) sobre un
conjunto de datos que pertenezcan a algún tipo de dato definido pierde todo rasgo de
coherencia y posibilidad de utilización directa, pero resulta extremadamente útil para recorrer la
memoria byte a byte sin importar el tipo de los datos recorridos.

5.7 Asignación dinámica de memoria

En la mayoría de los algoritmos que un programador debe realizar, normalmente no se dispone
de la cantidad de datos con las cuales debe trabajar. Esto trae aparejado el problema de
10
COMPUTACIÓN II (ELO) - INFORMÁTICA II (BIO)

dimensionar las estructuras de datos (por ejemplo arreglos) adecuadamente, lo que no es

sencillo de realizar. Por ejemplo un programador puede dimensionar un arreglo para que
contenga 100 elementos de tipo entero y durante la ejecución del programa el usuario podría
trabajar únicamente con 10 desperdiciando 90 valiosos lugares de memoria. Por el contrario
también podría suceder que el usuario quisiera trabajar con 300 datos en cuyo caso no le sería
posible pues el programa admite como máximo 100. Nos preguntamos entonces si no existirá
algún mecanismo que me permita asignar memoria en el momento de la ejecución del
programa y no en el momento de la compilación como sucede con los arreglos?. La respuesta
es que si existe un mecanismo de este tipo que se denomina asignación dinámica de memoria,
pues permite reservar memoria en tiempo de ejecución.
El lenguaje de programación C dispone de una biblioteca de funciones para este fin, el nombre
de tal biblioteca es <stdlib.h>. Existen varias funciones dentro de esta biblioteca para el fin
específico mencionado, podemos citar a 2 de ellas, la función malloc() y la función free().
La función malloc está declarada de la siguiente manera:
(void *) malloc(int cantidad_bytes)

Esta función lo que hace es solicitarle al sistema operativo un cierto bloque de memoria de
longitud cantidad_bytes. El bloque de memoria debe venir expresado en bytes y no en datos.
El sistema operativo responde a nuestro programa entregando la dirección del primer byte del
bloque de memoria asignada o en su defecto la constante NULL para indicar que lo solicitado
es imposible de ser asignado. Supongamos el siguiente ejemplo aclaratorio:
...
int *pv;
int n=100;
/* Pedido de memoria */
if((pv = (int *)malloc(100 * sizeof(int)))==NULL) {
printf(“No hay memoria disponible\n”);
exit(1);
}
...
free(pv); /* Liberar memoria*/
En este ejemplo se solicita memoria para 100 datos de tipo entero y a través de la estructura if
se verifica si el sistema operativo accedió al pedido o no. En la estructura se puede ver que la
función malloc retorna un puntero (pv) al cual se le realiza un cast de tipo para indicar que el
bloque de memoria solicitado es para datos de tipo entero.
La oración final del ejemplo anterior, utiliza la función free() para devolverle al sistema
operativo la memoria solicitada. Esta acción de devolución debe realizarse cuando los datos en
la memoria ya no sean de interés para nuestro programa.

5.8 Punteros y arreglos multidimensionales

Como un arreglo unidimensional puede representarse en términos de punteros, el nombre del
arreglo y un desplazamiento (índice), es razonable esperar que los arreglos multidimensionales
puedan representarse con una notación equivalente de punteros. En efecto este es el caso y se
tienen las siguientes posibilidades:

11
COMPUTACIÓN II (ELO) - INFORMÁTICA II (BIO)

5.8.1 Arreglo de punteros

Un arreglo multidimensional puede ser expresado como un arreglo de punteros y en estos
casos el nuevo arreglo será de una dimensión menor que el arreglo multidimensional. Cada
puntero indicará el principio de un arreglo de dimensión n-1.
En general un arreglo bidimensional puede ser definido como un arreglo unidimensional de
punteros escribiendo:
<tipo-dato> *nombre_puntero[expresion1];

En lugar de la definición convencional,

<tipo-dato> nombre_arreglo[expresión 1][expresión 2];

Y en este caso, cada puntero del arreglo dará origen a una de las filas del arreglo
bidimensional. Similarmente un arreglo n-dimensional puede definirse como un arreglo de
punteros de dimensión (n-1) escribiendo,
<tipo-dato> *nombre_puntero[expresion1][expresion2]...[expresión(n-1)];

en lugar de,
<tipo-dato> nombre_arreglo[expresion1][expresion2]...[expresión n];

Se debe notar que el nombre del arreglo precedido por asterisco no está encerrado entre
paréntesis en este tipo de declaración. Así la regla de precedencia de derecha a izquierda
asocia primero el par de corchetes con el arreglo, definiéndolo como tal. El asterisco que lo
precede establece que el arreglo contendrá punteros que apuntan al tipo de dato especificado.
Como ejemplo consideremos otra versión del programa que suma matrices.
#include <stdio.h>
#include <stdlib.h>
#define MFIL 30
/* prototipos de función */
void leematriz(int *a[MFIL], int nfil, int ncols);
void sumamatriz(int *a[MFIL], int *b[MFIL], int *c[MFIL], int nfil, int ncols);
void escribematriz(int *c[MFIL], int nfil, int ncols);
/* cada arreglo bidimensional se representa como un arreglo de punteros, donde
cada puntero indica una fila del arreglo bidimensional original */
int main( ) {
int fila, nfilas, ncols;
/* definición de punteros */
int *a[MFIL], *b[MFIL], *c[MFIL];

printf("Cuantas filas?");
scanf("%d",&nfilas);
printf("Cuántas columnas?");
scanf("%d", &ncols);
/*reserva espacio de memoria*/
for(fila =0; fila < nfilas; ++fila) {
a[fila] = (int *)malloc(ncols * sizeof(int));
b[fila] = (int *)malloc(ncols * sizeof(int));
c[fila] = (int *)malloc(ncols * sizeof(int));
}
printf("Primera Matriz:\n");
leematriz(a, nfilas, ncols);
12
COMPUTACIÓN II (ELO) - INFORMÁTICA II (BIO)

printf("Segunda Matriz:\n");
leematriz(b, nfilas, ncols);
sumamatriz(a, b, c, nfilas, ncols);
printf("Matriz Suma:\n");
escribematriz(c, nfilas, ncols);
return 0;
}
/* Lee matriz*/
void leematriz(int *a[], int m, int n) {
int fila, col;
for (fila = 0; fila < m; ++fila) {
printf ("Introducir datos para la fila %2d\n", fila + 1);
for (col = 0; col < n; ++col) {
printf (" x[%d][%d]= ",fila + 1, col + 1);
scanf ("%d", (a[fila]+col));
}
}
}
/* Suma Matrices */
void sumamatriz(int *a[], int *b[], int *c[], int m, int n) {
int fila, col;
for (fila = 0; fila < m; ++fila)
for (col = 0; col < n; ++col)
*(c[fila]+col) = *(a[fila]+col) + *(b[fila]+col);
}
/* Escribe el resultado */
void escribematriz(int *c[], int m, int n) {
int fila, col;
for (fila = 0; fila < m; ++fila) {
for (col = 0; col < n; ++col)
printf ("c[%d][%d]= %4d",fila + 1, col + 1,*(c[fila]+col));
printf("\n");
}
}

5.8.2 Puntero a un arreglo de punteros

Un arreglo multidimensional puede ser expresado como un arreglo de punteros tal como se vió,
pero este arreglo de punteros puede crearse en forma dinámica en lugar de hacerlo de forma
estática como el caso anterior. Si bien cambiarán las declaraciones y la forma de asignación
dinámica de memoria, este caso solo es una versión “sofisticada” del proceso anterior.
En general un arreglo bidimensional puede ser definido como un puntero a un arreglo dinámico
de punteros escribiendo:
<tipo-dato> **nombre_puntero;

En lugar de la definición convencional,

<tipo-dato> nombre_arreglo[expresión 1][expresión 2];

Ahora se creará dinámicamente un arreglo de punteros haciendo:

nombre_puntero=(<tipo_dato>**)malloc( num_filas * sizeof(<tipo_dato> *) )
13
COMPUTACIÓN II (ELO) - INFORMÁTICA II (BIO)

A partir de este momento, el proceso es casi análogo al ya descripto y puede verse en el

siguiente ejemplo, que es igual al anterior solo que ahora se utiliza la nueva técnica en la
sección remarcada:
#include <stdio.h>
#include <stdlib.h>
#define MFIL 30
/* prototipos de función */
void leematriz(int **a, int nfilas, int ncols);
void sumamatriz(int **a, int **b, int **c, int nfilas, int ncols);
void escribematriz(int **c, int nfilas, int ncols);
/* cada arreglo bidimensional se representa como un puntero a un arreglo de
punteros, donde cada puntero del arreglo indica una fila del arreglo
bidimensional original */
int main( ) {
int fila, nfilas, ncols;
/* definición de punteros */
int **a, **b, **c;

printf("Cuantas filas?");
scanf("%d",&nfilas);
printf("\nCuántas columnas?");
scanf("%d", &ncols);
/* reserva espacio de memoria para cada arreglo de punteros */
a = (int **)malloc( nfilas * sizeof( int *) );
b = (int **)malloc( nfilas * sizeof( int *) );
c = (int **)malloc( nfilas * sizeof( int *) );
/* reserva espacio de memoria para cada fila igual que antes */
for (fila =0; fila < nfilas; ++fila) {
a[fila] = (int *) malloc (ncols * sizeof(int));
b[fila] = (int *) malloc (ncols * sizeof(int));
c[fila] = (int *) malloc (ncols * sizeof(int));
}
printf("Primera Matriz:\n");
leematriz(a, nfilas, ncols);
printf("Segunda Matriz:\n");
leematriz(b, nfilas, ncols);
sumamatriz(a, b, c, nfilas, ncols);
printf("Matriz Suma:\n");
escribematriz(c, nfilas, ncols);
/* Liberar memoria: Primero las filas */
for(fila =0; fila < nfilas; ++fila) {
free( a[fila] );
free( b[fila] );
free( c[fila] );
}
/* y luego los arreglos de punteros */
free( a );
free( b );
free( c );

14
COMPUTACIÓN II (ELO) - INFORMÁTICA II (BIO)

return 0;
}
/* Lee matriz*/
void leematriz(int **a, int m, int n) {
int fila, col;
for (fila = 0; fila < m; ++fila) {
printf ("Introducir datos para la fila %2d\n", fila + 1);
for (col = 0; col < n; ++col) {
printf ("x[%d][%d]=", fila + 1, col + 1);
scanf ("%d", (a[fila]+col));
}
}
}
/* Suma Matrices */
void sumamatriz(int **a, int **b, int **c, int m, int n) {
int fila, col;
for (fila = 0; fila < m; ++fila) {
for (col = 0; col < n; ++col) {
*(c[fila]+col) = *(a[fila]+col) + *(b[fila]+col);
}
}
}
/* Escribe el resultado */
void escribematriz(int **c, int m, int n) {
int fila, col;
for (fila = 0; fila < m; ++fila) {
for (col = 0; col < n; ++col) {
printf ("c[%d][%d]=%4d", fila + 1, col + 1, *(c[fila]+col));
}
printf("\n");
}
}

5.9 Punteros a funciones

Cuando se declara (y/o define) una función en C, el nombre de la función se transforma en
un puntero al inicio de su código ejecutable, de manera similar a lo que sucede con el
nombre de un arreglo. Este puntero, si bien no apunta a un área de datos tipificados como son
los elementos de un arreglo, no se diferencian mucho de esto ya que apuntan a una zona de
memoria donde reside el código ejecutable de la función declarada o definida.
Sin embargo, también es posible declarar variables de tipo punteros a funciones, las que en su
forma mas general tienen la siguiente sintaxis:
<tipo-dato> (*nombre-variable)([lista-de-argumentos]);

En estas variables es posible almacenar la dirección de memoria donde comienza el código

ejecutable de una función, siempre y cuando el tipo de retorno y los argumentos de esta
función coincidan con los declarados para las variables, como muestra el siguiente ejemplo:
int func1( int a, int b ) {
/* cuerpo de la función */

15
COMPUTACIÓN II (ELO) - INFORMÁTICA II (BIO)

}
…
int (*ptr)( int, int ) = func1;
y ahora es posible invocar a la función por medio del puntero!
resultado = ptr( 10, 20 );
Análogamente, es también posible enviar punteros a funciones como parámetros de otras
funciones, tal como muestra la función proceso() en el ejemplo a continuación, donde existen
cuatro funciones: main, proceso, suma, y multiplica, y cada una de ellas retorna un entero.
#include <stdio.h>
#include <stdlib.h>

int proceso( int (*p)( int a, int b ) );

int suma(int a, int b);
int multiplica(int a, int b);

int main( ) {
int i, j;
i = proceso( suma ); /* se envía suma; retorna un valor para i */
printf( "Suma=%d\n", i);

j = proceso( multiplica ); /* se envía multiplica; retorna para j */

printf( "Producto=%d\n", j);
return 0;
}
int proceso( int (*pf)(int pa, int pb) ) {
int a = 10, b = 20, c;
c = pf( a, b ); /* Se ejecuta la funcion enviada SIN SABER CUAL ES */
return c;
}
int suma( int a, int b ) {
return a + b;
}
int multiplica(int x, int y) {
return x * y;
}

Notar que main llama a la función proceso dos veces. En la primera pasa suma a proceso,
mientras que en la segunda pasa multiplica. Cada llamada retorna un valor entero. Estos
valores son asignados a las variables enteras i y j, respectivamente. Examinemos la definición
de proceso. Esta función tiene un parámetro formal, pf, declarado como un puntero a función.
La función a la que apunta pf devuelve un valor entero. Dentro de proceso se llama a la función
a la que apunta pf. Se pasan dos cantidades enteras (a y b) como argumentos a la función. La
función devuelve un entero que es asignado a la variable c. El resto de las definiciones de
variables son normales (suma y multiplica). Estas son las funciones pasadas desde main
hasta proceso. Los valores resultantes se obtienen de los argumentos y cada función procesa
sus argumentos de entrada de modo diferente.

16
COMPUTACIÓN II (ELO) - INFORMÁTICA II (BIO)

5.10 Algo más sobre declaración de punteros

Las declaraciones de punteros pueden volverse complicadas y es necesario un cierto cuidado
en su interpretación. Esto es especialmente cierto con declaraciones que involucren funciones
o arreglos. Una dificultad es el uso dual de los paréntesis. Los paréntesis se usan para indicar
funciones y anidaciones dentro de declaraciones más complejas. Así la declaración:
int *p(int a);

Indica una función que acepta un argumento entero y devuelve un puntero a entero. Por otra
parte, la declaración:
int (*p)(int a);

Indica un puntero a función que acepta un argumento entero y retorna un entero. En esta última
declaración, los primeros paréntesis se usan para anidar y los segundos para indicar una
función. La interpretación de declaraciones mas complejas puede hacerse molesta. Por
ejemplo, considerar la siguiente declaración,
int *(*p)(int (*a)[ ]);

En esta declaración, (*p)(...) indica un puntero a función. Por esto, int (*p)(...) indica
un puntero a función que retorna un entero. Dentro de los dos últimos paréntesis (la
especificación de los argumentos de la función), (*a)[] indica un puntero a un arreglo. Como
resultado, int (*a)[] representa un puntero a un arreglo de enteros. Uniendo las piezas,
(*p)(int (*a)[]) representa un puntero a una función cuyo argumento es un puntero a un
arreglo de enteros. Finalmente la declaración completa,
int *(*p)(int (*a)[]);

Representa un puntero a una función que acepta un puntero a un arreglo de enteros como
argumentos y devuelve un puntero a entero, aunque una función puede devolver punteros a
cualquier tipo de datos.
/* Función que retorna un puntero al primer carácter en s que es igual a c */
char *match( char c, char *s ) {
int cont = 0;

while(c != s[cont] && s[cont] != 0) {

cont ++;
}
return (s[cont])?(&s[cont]):NULL;
}

int main( ) {
char s[80], *p, ch;

printf("Introduzca una cadena y un caracter:\n");

gets( s );
ch = getchar();
p = match( ch, s );
if( p ) {
printf("%p\n", p);
}
else {
printf("No se ha encontrado la ocurrencia de %c\n", ch );
}
return 0;
}

17
COMPUTACIÓN II (ELO) - INFORMÁTICA II (BIO)

5.11 Ejercitación con punteros

PROBLEMA 1:
Multiplicación de Matrices utilizando Punteros.
/* Producto de matrices con punteros */
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#define MAX 30

void leem(int *a[MAX], int m, int n);

void prod(int *a[MAX], int *b[MAX], int *c[MAX], int m, int n, int p);
void escrib(int *a[MAX], int m, int p);

int main( ) {
int m, n, p, i, l;
int *a[MAX], *b[MAX], *c[MAX];
clrscr();
printf(”\nlngrese nro filas a, columnas a, y columnas b”);
scanf("%d %d %d”, &m, &n, &p);
for ( i=0; i<m; i++) {
a[i] = (int *) malloc (n * sizeof (int));
c[i] = (int *) malloc (p * sizeof (int));
}
for (i=0; i<n; i+ +) {
b[i] = (int *)malloc(p * sizeof (int));
}
leem(a,m,n);
leem(b,n,p);
prod(a,b,c,m,n,p);
escrib(c,m,p);
return 0;
}
void leem(int *a[[MAX], int m, int n) {
int fil, col;
printf(”Matriz:\n”);
for(fil=0; fil<m; fil++) {
for(col=0; col<n; col++) {
printf(”Elemento [&d][%d] = “, fil+ 1, col+ 1);
scanf(”%d”, a[fil] + col);
/* Lo siguiente tambien funciona
scanf(” %d”, &a [fil][col] ); */
}
printf(”\n”);
}
}
void prod(int *a[MAX], int *b[MAX], int *c[MAX], int m, int n, int p) {
int fil, col, i;
for(fil = 0; fil<m; fil++) {
18
COMPUTACIÓN II (ELO) - INFORMÁTICA II (BIO)

for(col=0; col<p; col++) {

*(c[fil] + col) = 0;
for(i=0; i<n; i++) {
*(c[fil] + col) + = *(a[fil] + i) * *(b[i] + col);
}
}
}
}
void escrib(int *c[MAX], int m, int p) {
int fil, col;
for(fil = 0; fil < m; fil ++) {
for(col=0; col<p; col++) {
printf(”c[%d][%d]=%d\t”, fil + 1, col + 1, *(c[fil] + col));
}
printf(”\n”);
}
}

19