Contenidos 1
• Arrays
Programación I • Cadenas de caracteres
Arrays, cadenas de caracteres y estructuras • Estructuras
• Enumeraciones
Iván Cantador
Escuela Politécnica Superior
Universidad Autónoma de Madrid
Programación I
Escuela Politécnica Superior
Universidad Autónoma de Madrid
Arrays (I) 2
Arrays (II) 3
• El primer elemento de un array a de N elementos es a[0],
• Un array (tabla, vector) es una colección ordenada de el segundo es a[1], ..., el último es a[N-1]
datos de un mismo tipo • Ejemplo: array de 10 elementos
• Declaración de variable
<tipo_dato> <nombre>[tamanio];
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9]
int a[3]; // Un array de 3 int
float b[4], c[5];
En C:
• Inicialización (en la declaración): int a[10];
int a[3] = {1, 2, 3}; a[0] = 2; // Guardamos un 2 en la primera posicion
float b[] = {1, 2, 3, 4}; /* Se puede omitir el tamanio */
a[9] = 4; // Guardamos un 4 en la ultima posicion
float b[5] = {1, 2, 3}; /* Se inicializan los 3 primeros
valores */ a[10] = 8; // ERROR! Se ha excedido la longitud del array
scanf("%d", &a[5]); // Leemos por teclado la posición 6
Programación I Programación I
Escuela Politécnica Superior Escuela Politécnica Superior
Universidad Autónoma de Madrid Universidad Autónoma de Madrid
Arrays (III) 4
Arrays (IV) 5
• Arrays multidimensionales (matrices)
int m1[2][3]; // Declaracion SIN inicializacion
int m2[][3] = {{1, 2, 3}, {4, 5, 6}}; // Declaracion CON inicializacion
int i, j;
• La asignación entre arrays NO está definida en C // Inicializacion de todas las celdas a 0 mediante un bucle
for (i=0; i<2; i++) {
• Solución: recorrer los elementos de los arrays mediante un bucle for (j=0; j<3; j++) {
m1[i][j] = 0;
int a[] = {1, 2, 3}; // Declaracion CON inicializacion }
int b[3]; // Declaracion SIN inicializacion }
// Asignacion de valores a celdas (0,0) y (1,2)
int i;
m1[0][0] = 1;
m1[1][2] = 2;
// b = a; es incorrecto
// Para hacerlo se usara un bucle // Impresion por pantala de todas las celdas mediante un bucle
for ( i=0; i<3; i++ ) { for (i=0; i<2; i++) {
for (j=0; j<3; j++) {
b[i] = a[i];
printf("%d, ", m1[i][j]);
} }
printf("\n");
}
Programación I Programación I
Escuela Politécnica Superior Escuela Politécnica Superior
Universidad Autónoma de Madrid Universidad Autónoma de Madrid
Contenidos 6
Cadenas de caracteres (I) 7
• Cadenas de caracteres (strings)
• En C una cadena de caracteres es un array de char, donde
• Arrays el último carácter es el carácter de fin de cadena ‘\0’
• Cadenas de caracteres // Las siguientes 3 declaraciones son equivalentes
char s1[] = "Hola";
• Estructuras char s2[] = {'H', 'o', 'l', 'a', '\0'};
char *s3 = "Hola";
• Enumeraciones
// Modificamos el segundo caracter de la cadena s1
printf("El valor de s1 es: %s.\n", s1); // Hola
s1[1] = 'A';
printf("El valor de s1 es: %s.\n", s1); // HAla
Programación I Programación I
Escuela Politécnica Superior Escuela Politécnica Superior
Universidad Autónoma de Madrid Universidad Autónoma de Madrid
Cadenas de caracteres (II) 8
Cadenas de caracteres (III) 9
• Algunas funciones básicas sobre cadenas (string.h)
• int strlen(char *s)
• Lectura por teclado de cadenas • devuelve la longitud de s (SIN contar el ‘\0’ del final de s)
• Lectura de una cadena por teclado con scanf, usando %s • char *strcpy(char *s1, char *s2)
(la s viene de string) NO hay que poner & • copia s2 en s1
• devuelve s1 (modificada)
char cadena[256]; • char *strcat(char *s1, char *s2)
printf("Introduce tu nombre: "); • concatena s2 al final de s1
scanf("%s", cadena); // Atencion! No se pone &cadena • devuelve s1 (modificada)
printf("Hola %s!\n", cadena); • int strcmp(char *s1, char *s2)
• devuelve un número < 0 si s1 < s2
• devuelve un número > 0 si s1 > s2
• devuelve 0 si s1 = s2
La comparación de cadenas es carácter a carácter, con sus códigos ASCII
Programación I Programación I
Escuela Politécnica Superior Escuela Politécnica Superior
Universidad Autónoma de Madrid Universidad Autónoma de Madrid
Cadenas de caracteres (IV) 10
Contenidos 11
• Algunas funciones básicas sobre cadenas (string.h)
char cadena1[256] = "hola";
char cadena2[256] = "mundo!";
char cadena3[256];
• Arrays
printf("La longitud de cadena1 es %d\n", strlen(cadena1)); // 4
• Cadenas de caracteres
strcpy(cadena3, cadena1); // cadena3 vale "hola"
• Estructuras
strcat(cadena3, cadena2); // cadena3 vale "holamundo!"
• Enumeraciones
printf("%d\n", strcmp(cadena1, cadena1)); // Imprime 0
printf("%d\n", strcmp(cadena1, cadena2)); // Imprime numero < 0
printf("%d\n", strcmp(cadena2, cadena1)); // Imprime numero > 0
Programación I Programación I
Escuela Politécnica Superior Escuela Politécnica Superior
Universidad Autónoma de Madrid Universidad Autónoma de Madrid
Estructuras (I) 12
Estructuras (II) 13
• Una estructura (struct) es una colección de datos de • Una estructura (struct) es una colección de datos de
(tal vez) diferentes tipos a los datos se les suelen (tal vez) diferentes tipos a los datos se les suelen
llamar atributos o campos llamar atributos o campos
• Declaración struct • Declaración de variable • Declaración con typedef • Declaración de variable
struct { struct <nombreEstructura> <variable>; typedef struct { <nombreEstructura> <variable>;
<atributo1>; <atributo1>;
<atributo2>; <atributo2>;
... ...
<atributoN>; <atributoN>;
} <nombreEstructura>; } <nombreEstructura>;
Ejemplo: Ejemplo: Ejemplo: Ejemplo:
#define MAX_TAM 256 void main() { #define MAX_TAM 256 void main() {
struct { ... typedef struct { ...
char titulo[MAX_TAM]; struct Libro l; char titulo[MAX_TAM]; Libro l;
char autor[MAX_TAM]; ... char autor[MAX_TAM]; ...
int anio; } int anio; }
} Libro; } Libro;
Programación I Programación I
Escuela Politécnica Superior Escuela Politécnica Superior
Universidad Autónoma de Madrid Universidad Autónoma de Madrid
Estructuras (III) 14
Estructuras (IV) 15
• El tamaño (en Bytes) de una estructura es la suma de los • Acceso a los campos de una estructura: se realiza de la
tamaños de sus atributos forma nombreVariable.nombreCampo
#include <stdio.h>
#define MAX_TAM 256 #include <string.h>
`
typedef struct { #define MAX_TAM 256
char titulo[MAX_TAM]; typedef struct {
char autor[MAX_TAM]; char titulo[MAX_TAM];
int anio; char autor[MAX_TAM];
} Libro; int anio;
} Libro;
// sizeof(Libro) = 2 * 256 * sizeof(char) + sizeof(int)
void main() {
// Definicion de una variable de tipo Libro
Libro l;
Libro
titulo ... 256 * sizeof(char) ...
// Acceso a los campos de la variable
strcpy(l.titulo, "El Señor de los Anillos");
autor ... 256 * sizeof(char) ... strcpy(l.autor, "J.R.R. Tolkien");
l.anio = 1958;
anio sizeof(int) printf("%s escrito por %s en %d\n", l.titulo, l.autor, l.anio);
}
Programación I Programación I
Escuela Politécnica Superior Escuela Politécnica Superior
Universidad Autónoma de Madrid Universidad Autónoma de Madrid
Estructuras (V) 16
Estructuras (VI) 17
• Estructuras anidadas – declaración • Estructuras anidadas – espacio en memoria
#include <stdio.h>
#include <string.h> #define MAX_TAM 256
typedef struct {
#define MAX_TAM 256 char nombre[MAX_TAM];
typedef struct { char apellidos[2*MAX_TAM];
char nombre[MAX_TAM];
} Autor;
char apellidos[2*MAX_TAM];
} Autor;
typedef struct {
typedef struct { char titulo[MAX_TAM];
char titulo[MAX_TAM]; Autor autor;
Autor autor; // La estructura Autor debe estar declarada antes/arriba int anio;
int anio; } Libro;
} Libro;
void main() { Libro
Libro l;
titulo ... 256 * sizeof(char) ...
strcpy(l.titulo, "El Señor de los Anillos");
strcpy(l.autor.nombre, "J.R.R."); autor.nombre ... 256 * sizeof(char) ...
strcpy(l.autor.apellidos, "Tolkien"); Autor
l.anio = 1958; autor.apellidos ... 2 * 256 * sizeof(char) ...
printf("%s escrito por %s %s en %d\n", l.titulo, l.autor.nombre,
l.autor.apellidos, l.anio); anio sizeof(int)
}
Programación I Programación I
Escuela Politécnica Superior Escuela Politécnica Superior
Universidad Autónoma de Madrid Universidad Autónoma de Madrid
Estructuras (VII) 18
Estructuras (VIII) 19
• Arrays de estructuras
#include <stdio.h>
#include <string.h> • Ejercicio. Modificar la estructura Libro (y si es necesario
#define MAX_TAM 256 definir nuevas estructuras) para:
typedef struct {
char titulo[MAX_TAM]; • almacenar información (p.e. nombre y descripción) sobre una
char autor[MAX_TAM];
int anio;
lista de géneros literarios fija
} Libro; • asociar a cada libro uno o más de los géneros literarios
void main() {
Libro libros[2];
almacenados
strcpy(libros[0].titulo, "Don Quijote de la Mancha"); #define MAX_CAD 256
strcpy(libros[0].autor, "Miguel de Cervantes Saavedra"); typedef struct {
libros[0].anio = 1605; char titulo[MAX_CAD];
strcpy(libros[1].titulo, "Hamlet"); char autor[MAX_CAD];
strcpy(libros[1].autor, "William Shakespeare");
libros[1].anio = 1601;
int anio;
printf("Libro: %s de %s.\n", libros[0].titulo, libros[0].autor);
} Libro;
printf("Libro: %s de %s.\n", libros[1].titulo, libros[1].autor);
}
Programación I Programación I
Escuela Politécnica Superior Escuela Politécnica Superior
Universidad Autónoma de Madrid Universidad Autónoma de Madrid
Estructuras (IX) 20
Contenidos 21
#include <stdio.h> void main() {
#include <string.h> Libro l;
int i;
#define MAX_CAD 256
#define MAX_TXT 2048 // Guardamos los datos del libro
#define MAX_GEN 8 strcpy(l.titulo, "El Señor de los Anillos");
strcpy(l.autor, "J.R.R. Tolkien");
typedef struct { l.anio = 1958;
char nombre[MAX_CAD];
char descripcion[MAX_TXT];
} Genero;
strcpy(l.generos[0].titulo, "novela");
l.numGeneros = 1;
• Arrays
strcpy(l.generos[1].titulo, "fantasía");
typedef struct { l.numGeneros++; • Cadenas de caracteres
char titulo[MAX_CAD]; strcpy(l.generos[2].titulo, "ficción");
char autor[MAX_CAD];
int anio;
l.numGeneros++; • Estructuras
Genero generos[MAX_GEN];
int numGeneros;
// Sacamos por pantalla los datos del libro
printf("Título: %s\n", l.titulo); • Enumeraciones
} Libro; printf("Autor: %s\n", l.autor);
printf("Año: %d\n", l.anio);
printf("Géneros:\n");
for ( i=0; i<l.numGeneros; i++ ) {
printf("\t%s\n", l.generos[i].nombre);
}
}
Programación I Programación I
Escuela Politécnica Superior Escuela Politécnica Superior
Universidad Autónoma de Madrid Universidad Autónoma de Madrid
Enumeraciones (I) 22
Enumeraciones (II) 23
• Un enum (enumeración) es un tipo de dato que permite • Un enum (enumeración) es un tipo de dato que permite
agrupar valores constantes identificados con nombres agrupar valores constantes identificados con nombres
dados dados
• Declaración • Ejemplo (sin typedef)
enum {<nombre_1>, <nombre_2>, ...} <nombre_enum>; #include <stdio.h>
enum {<nombre_1>=<valor_1>, <nombre_2>=<valor_2>, ...} <nombre_enum>;
enum {verde, amarillo, rojo} Colores;
Si no se indican los valores de las constantes, estos por
void main() {
defecto son 0, 1, 2, … enum Colores semaforo;
• Se suele utilizar typedef para definir tipos de datos enum
semaforo = verde; // equivale a semaforo = 0
typedef enum {<nombre_1>, <nombre_2>, ...} <nombre_enum>; semaforo = amarillo; // equivale a semaforo = 1
semaforo = rojo; // equivale a semaforo = 2
typedef enum {<nombre_1>=<valor_1>, <nombre_2>=<valor_2>, ...} <nombre_enum>;
printf("Color del semaforo: %d\n", semaforo);
}
Programación I Programación I
Escuela Politécnica Superior Escuela Politécnica Superior
Universidad Autónoma de Madrid Universidad Autónoma de Madrid
Enumeraciones (III) 24
Enumeraciones (IV) 25
• Un enum (enumeración) es un tipo de dato que permite
agrupar valores constantes identificados con nombres • Un enum (enumeración) es un tipo de dato que permite
dados agrupar valores constantes identificados con nombres
dados
• Ejemplo (con typedef)
• Ejemplo
#include <stdio.h>
#include <stdio.h>
typedef enum {verde, amarillo, rojo} Colores;
typedef enum {verde=5, amarillo=3, rojo=8} Colores;
void main() {
Colores semaforo; void main() {
Colores semaforo;
semaforo = verde; // equivale a semaforo = 0
semaforo = amarillo; // equivale a semaforo = 1 semaforo = verde; // equivale a semaforo = 5
semaforo = rojo; // equivale a semaforo = 2
printf("Color del semaforo: %d\n", semaforo);
printf("Color del semaforo: %d\n", semaforo); }
}
Programación I Programación I
Escuela Politécnica Superior Escuela Politécnica Superior
Universidad Autónoma de Madrid Universidad Autónoma de Madrid
Enumeraciones (V) 26
• Un enum (enumeración) es un tipo de dato que permite
agrupar valores constantes identificados con nombres
dados
• Ejemplos “clásicos”
typedef enum {ERROR=-1, OK=0} status;
typedef enum {FALSE=0, TRUE=1} boolean;
void main() {
status estadoEjecucion;
boolean finEjecucion;
estadoEjecucion = OK;
finEjecucion = FALSE;
}
Programación I
Escuela Politécnica Superior
Universidad Autónoma de Madrid
