ARRAYS

- Un array es una construcción usada para almacenar un conjunto de

valores del mismo tipo bajo un único nombre de variable que se
almacenan en memoria contigua.
- La declaración de variables de tipo array (vector) en C:
tipo nombre[dimension];
tipo: El tipo de los elementos que compondrán el array
nombre: El nombre de nuestra variable array
dimension: Un número entero mayor que cero que indica el
tamaño
- El operador [ ] sirve para acceder a los elementos del array o asignarle
un valor, mediante índices.
- Los valores que toman los elementos de un array no inicializado son
indeterminados. !! CUIDADO !!
- El primer elemento tiene el índice 0 y el último n-1. C no comprueba si
nos salimos de los limites array en compilación. !! CUIDADO !!
 ARRAYS

Ejemplos:
int a[100]; /* Un vector de 100 enteros */
float vx[4][4]; /* Matriz de 4x4 reales */

/* Declaración e inicialización de arrays */

float a[3]={2.45, -1.34, 2.11};
int vx[3][3]={{3,5,1}, {2,1,2}};

/* Recorrer un array */
int a[6];
for(i=0;i<6;i++) a[i]=0;
 STRINGS (Cadena de caracteres)
- En C no existe el tipo STRING. Se utiliza en su lugar arrays de
caracteres de una dimensión (vector).
Ej: char hola[5];
- Toda cadena de caracteres debe acabar con el carácter \0 (nulo)
como último elemento del array.
Ej: hola[0] = 'h';
hola[1] = 'o';
hola[2] = 'l';
hola[3] = 'a';
hola[4] = '\0';

char hora[5]={'h’, ‘o’, ‘l’, ‘a’, ‘\0’};

char hola[5]=“hola”; /* El carácter \0 se incluye automáticamente*/
- La asignación de strings con el operador = sólo de puede hacer en
la declaración.
Ej: hola=“aaaa”; /* No permitido */
 string.h
- Librería que contiene un conjunto de funciones para manipular
cadenas de caracteres: copiar, cambiar caracteres, comparar, etc.

- Las funciones más elementales son:

strcpy ( c1, c2 ); Copia c2 en c1
strcat ( c1, c2 ); Añade c2 al final de c1
int strlen ( cadena ); Devuelve la longitud de la cadena
int strcmp ( c1, c2 ); Devuelve cero si c1 es igual a c2; <0 si
c1 es menor que c2, >0 si c1 es mayor que c2

- Para trabajar con estas funciones, al comienzo del programa hay que
escribir : #include <string.h>

- Ej 1: Programa en C que calcule la longitud de una cadena sin usar strlen().

Imprima por pantalla el resultado final.

- Ej 2: Programa en C que almacene vuestro nombre en una variable, vuestros

apellidos en otra, y que junte vuestro nombre y apellido en una sola variable
con un espacio entre medias del nombre y de los apellidos. Imprima por
pantalla el resultado final.
 Ejemplo 1

char cadena[32] = “AAABBBB";

main() {
int i

i=0;
while (cadena[i]!='\0') {
i++;
}
printf (“LONGITUD %d \n”,i);

}
 Ejemplo 2
#include <stdio.h>
#include <string.h>

char completo [80];

char nombre[32] = "Pedro";
char apellidos [32] = "Medario Arenas";

main() {

/* Construye el nombre completo */

strcpy ( completo, nombre ); /* completo <- "Pedro" */

strcat ( completo, " "); /* completo <- "Pedro " */
strcat ( completo, apellidos ); /* completo <- "Pedro Medario Arenas" */
printf ( "El nombre completo es %s\n", completo );
}
 Punteros
- Las variables tipo puntero representan direcciones de memoria
donde se van a almacenar valores. Si un puntero no apunta a
ninguna dirección lo indicamos con la constante NULL.

- Se declaran con * delante del identificador de la variable.

- Ej: int *px,y,*py; /* px,py son punteros a entero e y un entero */

- Existen 2 operadores básicos:

a) Si px es un puntero (dirección): *px es el contenido del
puntero (el valor almacenado en la dirección).

b) Si x es una variable: &x es la dirección de memoria donde

está almacenada la variable.

- Se pueden declarar punteros genéricos (sin ningún tipo) usando el

tipo void y cambiarlo posteriormente con un “casting”. Sólo tiene
sentido con punteros y no otras variables. Ej: void *px; Usado en
memoria dinámica.
 CASTING

- Casting: mecanismo usado para cambiar de tipo expresiones y

variables.

int a;
float b;
char c;

b=65.0;

a=(int)b; /* a vale 65 */

c=(char)a; /* c vale 65 (Código ASCII de ‘A’) */

 Punteros. Ejemplos
{ int *puntero;
int variable;
puntero = &variable;
*puntero = 33; /* mismo efecto que variable=33 */
}

{
int* puntero1;
int* puntero2;
int var;

puntero1 = &var;
puntero2 = &var;
*puntero1 = 50; /* mismo efecto que var=50 */
var = *puntero2 + 13; /* var=50+13 */
}
CUIDADO !!!: Si me modifica el contenido de un puntero no
inicializado, estaremos modificando cualquier posición de memoria.
 Aritmética de Punteros

- Es posible realizar operaciones aritméticas sobre las variables de

tipo puntero para conseguir que apunten a una posición diferente.

- Ej: int* ptr; La expresión ptr+k es un puntero que apunta a la

dirección de ptr sumándole k veces el espacio ocupado por un
elemento del tipo al que apunta (en este caso un int).

- Ej:

int vector [100]; /* un vector de enteros */

int *ptr; /* un puntero a enteros */
...
ptr = &vector[0]; /* ptr apunta al principio del vector */
*ptr = 33; /* igual que vector[0] = 33 */
*(ptr+1) = 44; /* igual que vector[1] = 44 */
*(ptr+2) = 90; /* igual que vector[2] = 90 */
 Arrays y Punteros

- El nombre de una variable array tiene el valor de la dirección de

su primer elemento. Por lo tanto, su valor puede usarse como un
puntero.

¿Qué valores se cambian del array ?

Arrays y Punteros
 Arrays y Punteros
-Si ptr es un puntero, la expresión ptr[k] es equivalente a *(ptr+k)
con lo que se puede trabajar con un puntero como si se tratara de un
vector:

Ejemplo:

int* ptr;
int vector [100];

ptr = &vector[10];
for ( i=0; i<=10; i++ ) ptr[i] = 1; /* equivalente a *(ptr+i) = 1 */

- ptr = vector; es equivalente a ptr = &vector[0];

- Se pueden utilizar indirecciones múltiples, es decir, punteros que

apuntan a punteros : Ej double ** pointer; pointer[0][0]=3.141592;
(Previamente hay que hacer que pointer apunte a una dirección
correcta, por ejemplo reservando memoria dinámica)
Dobles Punteros (indirecciones múltiples)
 Funciones
- Permiten agrupar una serie de operaciones de tal manera que se
puedan utilizar más tarde sin tener que preocuparnos por cómo
están implementadas, simplemente sabiendo lo que harán.

- Para utilizar funciones en un programa es necesario declararlas

previamente al igual que las variables

- Declaración (cabecera o prototipo):

tipo_devuelto nombre_funcion (parametros);

- Definición:
tipo_devuelto nombre_funcion (parametros) { sentencias; }

- Se especifica el número de parámetros y el tipo de cada uno de

ellos como en la declaración de variables

- En el cuerpo debe aparecer lo que devuelve : return expresión;

- Ej: int suma ( int a, int b ) {

return a+b; }
 Funciones
- Para llamar a una función, se escribe su nombre y entre paréntesis
los valores que se deseen dar a los argumentos:
funcion ( expr1, expr2, ... );
- Ej: x = suma ( 1, 5 );

- Si no devuelve nada (no hace falta return) o no tiene argumentos se

utiliza void. void funcion ( arg1, arg2, ... )

Ej: int fecha (void) { ... }

dato = fecha();

- El paso de parámetros es siempre por valor. No hay paso por

referencia. Cuando se llama a una función en C, se pasa el valor de
la variable y no la propia variable.

- No se puede modificar las variables con las que hemos llamado la

función. Si se puede pasar la dirección de la variable a modificar
(punteros)
 Funciones
int reiniciar(int *a, int b) {
Ejemplo de paso de
*a=0; b=0; referencias por valor

int x=2,y=2;
reiniciar(&x,y);
/* x valdrá 0 e y 2 */

- Esta permitido hacer llamadas recursivas

- Ej:

float factorial (int n) {

if (n<=1) return 1.0;
else return n*factorial(n-1);

}
Funciones
 Entrada/Salida BÁSICA
- Siempre hay que incluir la librería de entrada/salida:
#include <stdio.h>
- printf : Sirve para escribir por la salida estándar texto formateado.
Entrada/Salida BÁSICA
Entrada/Salida BÁSICA
 Entrada/Salida BÁSICA
Formato avanzados: [0][-][ancho][.prec]

[0]: Rellenar con ceros

[-]: Justificar a la izquierda
[ancho] Número mínimo de caracteres que se utilizaran para visualizar el dato (el
espacio sobrante se rellena con espacios o con ceros
[.prec] Número máximo de dígitos/caracteres que se mostrarán. Las cadenas de
caracteres se truncan y los reales se redondean utilizando [prec] decimales

Formato Significado
%5d Entero decimal alineado a la derecha, ocupando cinco
espacios
%04u Entero sin signo ocupando cuatro espacios, y rellenando de
ceros a la izquierda si hace falta
%.2f Número real (doble precisión) con dos y sólo dos decimales
%5.3d Entero ocupando cinco espacios; aparecen tres cifras como
mínimo (se rellena de ceros)

printf ("\n[%-5d]", 47); visualiza [47°°°] printf ("\n[%05d]", 47); visualiza [00047]

printf ("\n[%5d]", 47); visualiza [°°°47] printf ("\n[%7.2f]", 12.342); visualiza [°°12.34]
 Entrada/Salida BÁSICA
- scanf : Lee texto por el flujo stdin y lo almacena según las
especificaciones de ``formato''
 Entrada/Salida BÁSICA

char str[82];
scanf(“%s”,str); /* Lee hasta un blanco o fin de línea. Máx 81 char!!.*/
 Entrada/Salida BÁSICA

Si el formato no nos interesa podemos utilizas:

gets(cadena): Lee una línea hasta retorno de carro \n o final de

fichero EOF.

puts(cadena): Escribe una lína de texto añadiendole un retorno de

carro

#include <stdio.h>
int main ()
{
char line[256]; /* ¿Suficientemente grande? */
while ( gets(line) != NULL) {
puts(line);
printf("\n"); /* Linea en blanco */
}
return 0;
}
 Entrada/Salida de Caracteres
getchar(): Devuelve el carácter leído desde el teclado

putchar(): Muestra un carácter por el dispositivo de salida estándar

#include <ctype.h> /* Definición de toupper */

#include <stdio.h> /* getchar, putchar, EOF */

int main ()
{

int ch;

while ((ch = getchar()) != EOF)

putchar(toupper(ch));

return 0;
}

Pasa a mayúsculas los caracteres escritor por teclado hasta fin de fichero
(Ctrl-D al leer desde el teclado)
 Entrada/Salida FICHEROS
- La biblioteca STDIO contiene funciones para trabajar con ficheros
#include <stdio.h>

- El manejo de los ficheros se hace a través de una estructura de tipo

FILE (stdio) que se denomina descriptor de fichero.

- Al abrir un fichero se nos devuelve un puntero a esa estructura y

posteriormente habrá que cerrarlo.

- Ej:
FILE *fd; /* variable para apuntar al descriptor de fichero */
...
/* abre el fichero en modo lectura */
fd = fopen ( "pepe.txt", "r" );

... trabaja con el fichero

... fclose (fd); /* cierra el fichero */

 Entrada/Salida FICHEROS
FILE * fopen(const char *nombre_fichero, const char *modo);

Abre el fichero de nombre ``nombre_fichero'', lo asocia con un flujo

de datos y devuelve un puntero al mismo. Si falla la llamada,
devuelve un puntero nulo.

Algunos de los caracteres iniciales de ``modo'' son:

“r'', para abrir un fichero de texto existente para su lectura
“w'', para crear un fichero de texto o abrir y truncar uno existente,
para su escritura
“a'', para crear un fichero de texto o abrir uno existente, para su
escritura. El indicador de posición se coloca al final del fichero
antes de cada escritura

int fclose(FILE *flujo);

Cierra el fichero asociado con ``flujo''. Devuelve 0 en caso de éxito

y EOF (end of file) en caso contrario.
 Entrada/Salida FICHEROS
- Leer cadenas de caracteres se puede emplear fgets
char *fgets(char *s, int n, FILE *flujo);

- s : El vector de caracteres donde se almacenará la linea.

- n: Número máximo de caracteres a leer.
- flujo: Descriptor de fichero

- Lee hasta n -1 caracteres o carácter de nueva linea, o fin de fichero

.
- Añade automaticamente el carácter nulo \0 de fin de cadena

- Para escribir cadenas de caracteres en un fichero:

int fputs(const char *s, FILE *flujo);

- También se puede escribir con fprintf

fprintf ( fd, formato, arg1, arg2, ... );

- Escribe un texto con formato en un fichero. La sintaxis es idéntica a

printf, salvo que el primer argumento es un descriptor de fichero.
 Entrada/Salida FICHEROS
- Para detectar el final de un fichero:
z = feof ( fd );

- Devuelve un 1 si se ha llegado al final del fichero. Un cero en caso

contrario.

- Los ficheros de donde se lee o escribe información con las rutinas

de STDIO se llaman flujos o streams.

- Los llamados flujos estándares son estos:

stdin: entrada estándar (normalmente el teclado)
stdout: salida estándar (normalmente la pantalla)
stderr: error estándar (normalmente la pantalla)
- Ej:
fgets ( cadena, 80, stdin );
fprintf (stderr,"Se ha producido un error" );
 Entrada/Salida FICHEROS

- Para lecturas con formato fscanf

Supongamos que queremos leer una línea del fichero notas.txt que
contiene un listado de notas de alumnos con el siguiente formato:

Nombre Apellido1 Apellido2 notaParcial1 NotaParcial2

Escribir el fragmento de código que realizará esta lectura

FILE *fich;
char nombre[10], apellido1[10], apellido2[10];
float nota1,nota2;
fich = fopen( "notas.txt", "r" );
fscanf( fich, "%s %s %s %f %f\n", nombre, apellido1, apellido2, &nota1,
&nota2 );
 FUNCIÓN PRINCIPAL: MAIN

- El es punto de entrada de cualquier programa y por lo tanto debe ser

única.
- Todo programa en C debe tener la función main
ARGUMENTOS DE MAIN
ARGUMENTOS DE MAIN
 ARGUMENTOS DE MAIN

char *getenv(const char *name); /*Obtener valores de las variables de

entorno (stdlib) */
 double strtod(const char *numPtr, char **finalPtr);

- Convierte la porción inicial de la cadena apuntada por numPtr a una

representación de long int . FinalPtr si no es NULL apunta al siguiente
carácter del utilizado en la conversión. Si no se puede realizar la
conversión finalPtr apunta a numPtr

#include <stdio.h>
#include <stdlib.h>

int llamada_strtod (char *s) {

char *endp;
double d;
d = strtod(s, &endp);
printf ("s: %s; d: %f; endp: %s \n", s, d, endp);
if (s != endp && *endp == '\0')
printf("Es un float de valor %g\n", d);
else
return 1;
return 0;
}
 ./strtod_ejemplo
Introduzca el numero:
456
Numero introducido: 456
s: 456; d: 456.000000; endp:
int main (void)
Es un float de valor 456
{
char palabra[80];
./strtod_ejemplo
printf("Introduzca el numero:\n");
Introduzca el numero:
scanf ("%s", palabra);
456.87
printf("Numero introducido:
Numero introducido: 456.87
%s\n", palabra);
s: 456.87; d: 456.870000; endp:
Es un float de valor 456.87
return (llamada_strtod (palabra));
}
./strtod_ejemplo
Introduzca el numero:
456ythr
Numero introducido: 456ythr
s: 456ythr; d: 456.000000; endp: ythr