matrices, estructuras

Matrices (1)
• Las matrices son una colección de variables del
mismo tipo que se referencias utilizando un nombre
común. Consta de posiciones de memoria contiguas.
Puede tener una o varias dimensiones.
• Para acceder a un elemento en particular de una
matriz se usa un índice.
tipo nombre_mat riz [tamaño];
• La declaración int a[10]; declara una matriz llamada
a, de 10 elementos de tipo entero.
1

Matrices (2)
2

Matrices (3)
• Todas las matrices usan cero como índice para el
primer elemento.
• El lenguaje C no realiza comprobación del contornos
de las matrices. En el caso de que sobrepase el final
durante una operación de asignación, entonces se
asignarán valores a otras variables o a un trozo de
código, lo que probablemente provoque un fallo del
programa.
• C permite matrices con más de una dimensión.
tipo
nombre_mat riz
[tam1][tam2]...[tamN];
3

Matrices (4)
• Para inicializar los elementos de una matriz a algún
valor, debe hacerse uno a uno.
• Para copiar el contenido de una matriz a otra debe
copiarse cada elemento uno a uno. No se puede
asignar una matriz a otra. Lo siguiente es ilegal:
int a[10], b[10];
//hacer algo
a=b;//error ilegal
En vez, se debe hacer asignaciones por cada elemento:
int i;
for(i=0;i

Matrices (5)
• int numeros[]={1,3,34,54};
• char alfabeto[5]={‘A’,’B’,’C’,’D’,’E’};
• char nombres[][40]={“pedro”, “pablo”, “luis”,
“carmen”, “belen”, “laura”};
• coordenadas[2][2]=
{
{0,0},{1,1}
};
5

Matrices (6)
• Si una matriz es declarado en la función principal
“main()” tendra las dimensiones incluidas.
• Si no se desea tamaño fijo se pueden utilizar
punteros.
• Cuando se pasa una matriz a una función, esta
última no necesita saber el tamaño.
• En C, una matriz se asocia a localizaciones de
memoria contiguas. La dirección más baja
corresponde al primer elemento, y la más alta al
último elemento.
6

Matrices (7)
int a[8];
int j;
for(j=0;j

Matrices (8)
#include
int main(){
int muestra[10],t;
for(t=0;t

Matrices (9)
#include
int main(){
int i, max=0;
int list[100];
for(i=0;i

Matrices (10)
• La forma general de declaración de una
matriz unidimensional es:
tipo nombre_de_variable[tamaño];
• La cantidad de memoria en bytes viene
dada por:
bytes_totales = sizeof(tipo)*tamaño;
10

Matrices (11)
• Un arreglo bidimensional es una lista de arreglos unidimensional
• Para declarar un arreglo bidimensional de enteros
• int matriz[3][4];
11

Matrices (12)
#include
int main(){
int fila,col,matriz[3][4];
for(fila=0;fila

Matrices (13)
• El almacenamiento de los elementos de
una matriz se determina en tiempo de
compilación
• La memoria usada se requiere mientras el
arreglo exista.
• La siguiente formula determina el numero
de bytes que necesita ser asignada:
Bytes=fila*col*numero_bytes_tipo;
13

Cadenas (1)
• El uso más común para un arreglo unidimensional es
guardar una matriz de caracteres
• Un string esta definido como una matriz de caracteres
terminado por un símbolo null (‘\0’)
h
o
l
‘\0’
• Para que una matriz contenga un string de 10 caracteres,
char str[11]. La posición 11 se tiene que reservar para el
final de la cadena, indicado con un nulo ‘\0’.
• Para asignar la entrada estándar a una cadena se puede
usar la función scanf con la opción %s, de igual forma para
mostrarlo en la salida estándar.
a
14

Cadenas (2)
#include
int main(){
char str[80];
printf(“escribir string”);
scanf(“%s”,str); //no lleva &
return 0;
}
Problema: se detiene cuando lee un espacio
en blanco
15

Cadenas (3)
#include
int main(){
char str[80];
printf(“escribir string”);
}
gets(str);//considera espacio blanco
return 0;
16

Cadenas (4)
• Declaración:
Se declaran como matrices unidimensionales.
Debe contener 1 carácter más que la cadena
más larga que pueda contener.
char cadena[6];
0 1 2 3 4 5
\0
Puede contener hasta
5 caracteres
Caracter que marca el fin del string
17

Cadenas (5)
Biblioteca: string.h
• strcpy() : copia caracteres de un string a otro
• strcat() : concatenación de string
• strlen() : largo del string
• strcmp(): comparación de string
Función Prototipo Acción Retorna
strcpy() char *strcpy(char *s1,const char *s2); Copia s2 en s1. s1
strcat() char *strcat(char *s1,const char *s2); Concatena s2 en s1. s1
strlen() int strlen(const char *s1);
Longitud de s1
strcmp() int strcmp(const char *s1,const char *s2); Compara s2 con s1 0 si son iguales
>0 si s1>s2

Cadenas (6)
#include
#include
int main(void){
char c1[80],c2[80];
printf("\n Ingrese una cadena de caracteres:");
scanf("%s",c1);
printf("\n Ingrese una cadena de caracteres:");
scanf("%s",c2);
printf("\n Longitudes: %d %d ",strlen(c1),strlen(c2));
if(!strcmp(c1,c2)) printf("\nLas cadenas son iguales");
strcat(c1,c2);
printf("\n %s",c1);
}
return 0;
19

Estructuras (1)
• Una estructura es una colección de variables
que se denomina bajo un único nombre,
proporcionando un medio eficaz de mantener
junta la información relacionada.
• Una declaración de estructura forma una
plantilla que puede utilizarse para crear
variables de estructuras.
• Las variables que componen la estructura se
llaman elementos de la estructura o campo.
20

Estructuras (2)
• La palabra clave struct indica al compilador
que se está declarando una estructura.
struct nombre_estructura{
};
tipo_dato_1 campo_1;
tipo_dato_2 campo_2;
….
tipo_dato_n campo_n;
21

Estructuras (3)
• Una vez declarada la estructura se debe
declarar variables con esta estructura:
struct nombre_estructura variable_1,variable_2,….;
• Cuando se declara una estructura, se está
definiendo, esencialmente un tipo complejo de
variable compuesto por los elementos de la
estructura.
22

Estructuras (4)
struct nombre_estructura{
tipo_dato_1 campo_1;
tipo_dato_2 campo_2;
….
tipo_dato_n campo_n;
}variable_1,variable_2,...;
23

Estructuras (5)
• A los elementos individuales de una estructura
se hace referencia utilizando el operador ‘.’:
variable_1.campo_i;
24

Estructuras (6)
#include
struct datos{
char nombre[30];
char direccion[30];
int n_empleado,edad;
float sueldo;
}
void main(){
struct datos persona;
printf(“\n Ingrese número de empleado:”);
scanf(“%d”,&persona.n_empleado);
printf(“\n Ingrese nombre:”);
scanf(“%s”,persona.nombre);
printf(“\n Ingrese edad:”);
scanf(“%d”,&persona.edad);
printf(“\n Ingrese dirección:”);
scanf(“%s”,persona.direccion);
printf(“\n Ingrese sueldo:”);
scanf(“%f”,&persona.sueldo);
}
25

Estructuras (7)
• Para declarar un arreglo de estructuras, se debe
definir primero la estructura y luego declarar un
variable arreglo de dicho tipo.
struct nombre_estructura variable[Tamaño];
26

Estructuras (8)
#include
struct datos{
char nombre[30];
char direccion[30];
int n_empleado,edad;
float sueldo;
}
void main(){
struct datos persona[10];
for (int i=0;i

Estructuras (9)
• Se puede pasar un elemento o la estructura
completa a una función.
Paso de un elemento:
struct nombre_estructura{
tipo_dato_1 campo_1;
tipo_dato_2 campo_2;
….
}variable_1;
tipo_dato_n campo_n;
int funcion(tipo_dato_i VARIABLE);
….
funcion(variable_1.campo_i);
28

Estructuras (10)
#include
struct datos{
char nombre[30];
char direccion[30];
int n_empleado,edad;
float sueldo;
}
float funcion(float *a,int t){
*a=(float) (t*1.015);
return *a;
}
void main(){
float f;
struct datos persona[10];
f=funcion(&persona.sueldo,10);
}
29

Estructuras (11)
Paso de una estructura completa por valor:
struct nombre_estructura{
tipo_dato_1 campo_1;
tipo_dato_2 campo_2;
….
tipo_dato_n campo_n;
}variable_1;
int funcion(struct nombre_estructura VARIABLE);
….
funcion(variable_1);
30

Estructuras (12)
#include
struct datos{
char nombre[30];
char direccion[30];
int n_empleado,edad;
float sueldo;
}
void mostrar(struct datos A){
printf(“\n Número de empleado: %d”, A.n_empleado);
printf(“\n nombre: %s”, A.nombre);
printf(“\n edad: %d”, A.edad);
printf(“\n dirección: %s”, A.direccion);
printf(“\n sueldo: %f”, A.sueldo);
}
}
void main(){
struct datos persona;
...
mostrar(persona);
…
}
31

Estructuras (13)
Paso de una estructura completa por referencia:
struct nombre_estructura{
tipo_dato_1 campo_1;
tipo_dato_2 campo_2;
….
tipo_dato_n campo_n;
};
int funcion(struct nombre_estructura *VARIABLE){
. . .
VARIABLE->campo_1;
. . .
};
. . .
funcion(&variable_1);
32

Estructuras (14)
#include
struct datos{
char nombre[30];
char direccion[30];
int n_empleado,edad;
float sueldo;
}
void modificar(struct datos *A){;
printf(“\n Ingrese número de empleado:”);
scanf(“%d”,&A->n_empleado);
printf(“\n Ingrese nombre:”);
scanf(“%s”,A->nombre);
printf(“\n Ingrese edad:”);
scanf(“%d”,&A->edad);
printf(“\n Ingrese dirección:”);
scanf(“%s”,A->direccion);
printf(“\n Ingrese sueldo:”);
scanf(“%f”,&A->sueldo);
}
void main(){
struct datos persona;
modificar(&persona);
}
33