C++ cap 6

Tema 6 - Arrays, cadenas y punteros.
6.1 – Arrays y cadenas  .
En C, un array unidimensional se declara como:
tipo nombre[tamaño];
En C, el primer elemento de un array es el que posee el índice 0, por lo tanto, un
array  de  20  elementos  posee  sus  elementos  numerados  de  0  a  19.  Veamos  unos
ejemplos de declaración y manejo de algunos arrays:
int x[100],i;
for(i=0;i<100;i++)
   x[i]=i;
char letras[256];
int i;
for(i=0;i<256;i++)
letras[i]=i;
int x[10],i,suma;
for(i=0;i<10;i++)
{
   printf(“Introducir un número: %d: “,i);
scanf(“%d”,&x[i]);
}
for(suma=0,i=0;i<10;i++)
suma=suma+x[i];
printf(“La suma es: “,suma);
Sin embargo, el lenguaje C no comprueba el tamaño de los arrays, por lo cual,
es  posible construir  una rutina  como la  siguiente,  la  cual  ocasionara  un incorrecto
funcionamiento del programa:
float a[10];
int i;
for(i=0;i<100;i++) /* Este bucle es incorrecto */
   a[i]=i;
Es por ello, que es misión del programador comprobar que no se produzca el
desbordamiento de los arrays.
Una  cadena,  también  llamada  string,  es  un  tipo  especial  de  array
unidimensional.  Una  cadena  es  un array  de  caracteres  (char)  que  termina  con un
carácter  especial  (el carácter  ‘\0’).  Es por ello, que la declaración de una cadena de
caracteres se realiza exactamente igual que la declaración de un array unidimensional
de caracteres:
char cadena[tamaño];El lenguaje de programación C
Como toda cadena debe terminar en el carácter ‘\0’, es por ello que si se quiere
usar  una  cadena  de  20 caracteres,  debe declararse  de  tamaño 21 (20 caracteres  +
carácter terminador).
Por lo demás, puede usarse una cadena como si fuera un array unidimensional,
pues  se  puede  referenciar  uno cualquiera  de  sus  elementos,  etc.  Para  manejar  las
cadenas,  existen  un  gran  número  de  funciones  de  biblioteca  que  proporciona  el
standard ANSI-C, para más información referirse al apendice A o a cualquier libro de
C.
La declaración de arrays de más de una dimensión se realiza de forma parecida
a la de una dimensión, la sintaxis de la declaración de un array multidimensional es:
tipo nombre[tam1][tam2]...[tamN];
Y su  indexación,  etc.,  se  realiza  de  forma  similar  al  array  unidimensional.
Veamos un ejemplo:
float matriz[2][3];
int i,j;
for(i=0;i<2;i++)
   for(j=0;j<3;j++)
{
      printf(“M[%d][%d]: “,i,j);
scanf(“%f”,&matriz[i][j]);
}
Además,  es  posible  inicializar  los  arrays  en el  momento de  declararlos.  Su
sintaxis es:
tipo nombre[tam1][tam2]...[tamN]={lista_de_valores};
Por lo cual, podemos escribir:
float vector[3]={-3.0,5.7,-7.5};
También es  posible  inicializar  arrays  sin ponerles  el  tamaño,  el  compilador
cuenta  el  número de caracteres  de inicialización y reserva  el  tamaño necesario de
forma automática. Por ejemplo:
float vector[]={-3.0,5.7,-7.5};
char cadena[]=“Esto es una cadena”;
6.2 – Punteros.
Los punteros son una de las poderosas herramientas que ofrece el lenguaje C a
los  programadores,  sin embargo,  son también una de las  más peligrosas,  el  uso de
punteros sin inicializar, etc., es una fuente frecuente de errores en los programas de C,
y además, suele producir fallos muy difíciles de localizar y depurar.El lenguaje de programación C
Un  puntero  es  una  variable  que  contiene  una  dirección  de  memoria.
Normalmente esa dirección es una posición de memoria de otra variable, por lo cual se
suele decir que el puntero “apunta” a la otra variable.
La sintaxis de la declaración de una variable puntero es:
tipo *nombre;
El  tipo  base  de  la  declaración  sirve  para  conocer  el  tipo  de  datos  al  que
pertenece la variable a la cual apunta la variable de tipo puntero. Esto es fundamental
para poder leer el valor  que almacena la zona de memoria apuntada por la variable
puntero y para poder realizar ciertas operaciones aritméticas sobre los mismos.
Algunos ejemplos de declaración de variables puntero son:
int *a;
char *p;
float *f;
Existen dos operadores especiales de los punteros, el operador  * y el operador
&.
El  operador  & es un monario que devuelve la  dirección de una variable  de
memoria. Así, si declaramos:
int *a,b;
Y hacemos:
a=&b;
La variable puntero a contendrá la dirección de memoria de la variable b.
El  operador  * es  un operador  monario que devuelve el  valor  de la  variable
situada en la dirección que sigue. Veámoslo con un ejemplo:
int *a,b,c;
Si hacemos:
b=15;
a=&b;
c=*a;
Entonces la variable  c contendrá el valor  15, pues  *a devuelve el valor de la
dirección que sigue (a la que “apunta” la variable puntero), y con anterioridad hemos
hecho que  a contenga la dirección de memoria de la variable  b usando para ello el
operador &.
Con las variables de tipo puntero es posible realizar algunas operaciones:El lenguaje de programación C
• Asignación de punteros. Es posible asignar el valor de una variable de tipo puntero
a otra variable de tipo puntero. Por ejemplo:
int *a,*b,c;
a=&c;
b=a;
Entonces b contiene el valor de a, y por ello, b también “apunta” a la variable c.
• Aritmética de punteros. Sobre las variables de tipo puntero es posible utilizar los
operadores  +,  -,  ++ y --. Estos operadores incrementan o decrementan la posición
de memoria a la que “apunta” la variable puntero. El incremento o decremento se
realiza de acuerdo al tipo base de la variable de tipo puntero, de ahí la importancia
del tipo del que se declara la variable puntero. Veamos esto con la siguiente tabla:
Operación ++ -- +9 -5
Variable Dirección actual Nueva
dirección
int *a; 3000 3002 2998 3018 2990
float *b 3000 3004 2996 3036 2980
Tabla 6.2.1: Ejemplos de aritmética de punteros en C.
Por lo tanto, si tenemos:
tipo *a;
Y hacemos:
a=a+num;
La posición a la que apunta a se incrementa en num*sizeof(tipo). Para la resta
se  decrementa  de  igual  forma  en  num*sizeof(tipo).  Los  operadores  ++ y  -- son
equivalentes a realizar num=1, y con ello quedan obviamente explicados.
• Comparaciones de punteros. Sobre las variables de tipo puntero es posible realizar
operaciones de comparación entre ellas. Veamos un ejemplo:
int *a,*b;
if (a<b)
   printf(“a apunta a una dirección más baja que b”);
Existe una estrecha relación entre los punteros y los arrays.  Consideremos el
siguiente fragmento de código:
char str[80],*p;
p=str;
Este fragmento de código pone en la variable puntero p la dirección del primer
elemento del array str. Entonces, es posible acceder al valor de la quinta posición del
array mediante str[4] y *(p+4) (recuérdese que los índices de los arrays empiezan en
0). Esta estrecha relación entre los arrays y los punteros queda más evidente si se tieneEl lenguaje de programación C
en cuenta que el nombre del array sin índice es la dirección de comienzo del array, y, si
además,  se  tiene  en  cuenta  que  un  puntero  puede  indexarse  como  un  array
unidimensional, por lo cual, en el ejemplo anterior, podríamos referenciar ese elemento
como p[4].
Es  posible  obtener  la  dirección  de  un elemento  cualquiera  del  array  de  la
siguiente forma:
int str[80],*p;
p=&str[4];
Entonces, el puntero p contiene la dirección del quinto elemento del array str.
Hasta ahora hemos declarado variables puntero aisladas. Es posible, como con
cualquier otro tipo de datos, definir un array de variables puntero. La declaración para
un array de punteros int de tamaño 10 es:
int *a[10];
Para  asignar  una  dirección  de  una  variable  entera,  llamada  var,  al  tercer
elemento del array de punteros, se escribe:
x[2]=&var;
Y para encontrar el valor de var:
*x[2];
Dado,  además,  que un puntero es también una variable,  es posible definir un
puntero a un puntero. Supongamos que tenemos lo siguiente:
int a,*b,**c;
b=&a;
c=&b;
Y entonces,  **c tiene el  valor  de la variable  a,  pues  c es un puntero a una
variable que ya es de tipo puntero.
Este concepto de puntero a puntero podría extenderse a puntero a puntero a
puntero, etc., pero no nos ocuparemos de ello. Además, existe el concepto de puntero a
una función, al cual nos referiremos en el tema dedicado a las funciones.