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_matriz [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_matriz [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<10;i++)a[i]=b[i];
Recordar que en a[10] no existe el elemento a[10] sino
4
hasta a[9].
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<8;j++) a[j]=7-j;
„ Entonces la representación de la memoria será:
7
Matrices (8)
#include <stdio.h>
int main(){
int muestra[10],t;
for(t=0;t<10;t++)
muestra[t]=t*t;
for(t=0;t<10;t++)
printf(“muestra[%d]=%d”,t,muestra
[t]);
return 0;
}
8
Matrices (9)
#include<stdio.h>
int main(){
int i, max=0;
int list[100];
for(i=0;i<100;i++)list[i]=rand();
for(i=0;i<100;i++)
if(max<list[i])max=list[i];
printf(“max=%d”,max);
return 0;
}
9
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<stdio.h>
int main(){
int fila,col,matriz[3][4];
for(fila=0;fila<3;fila++)
for(col=0;col<4;col++)
matriz[fila][col]=fila*col;
return 0;
}
12
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
a
‘\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.
14
Cadenas (2)
#include<stdio.h>
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<stdio.h>
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
strcpy()
strcat()
strlen()
strcmp()
Prototipo
char *strcpy(char *s1,const char *s2);
char *strcat(char *s1,const char *s2);
int strlen(const char *s1);
int strcmp(const char *s1,const char *s2);
Acción
Copia s2 en s1.
Concatena s2 en s1.
Compara s2 con s1
Retorna
s1
s1
Longitud de s1
0 si son iguales
>0 si s1>s2
<0 si s1<s2
18
Cadenas (6)
#include <string.h>
#include <stdio.h>
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 <stdio.h>
void main(){
struct datos persona;
struct datos{
char nombre[30];
printf(“\n Ingrese número de empleado:”);
char direccion[30];
scanf(“%d”,&persona.n_empleado);
int n_empleado,edad;
printf(“\n Ingrese nombre:”);
float sueldo;
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 <stdio.h>
void main(){
struct datos{
struct datos persona[10];
char nombre[30];
for (int i=0;i<10;i++){
char direccion[30];
printf(“\n Ingrese número de empleado:”);
int n_empleado,edad;
scanf(“%d”,&persona[i].n_empleado);
float sueldo;
printf(“\n Ingrese nombre:”);
}
scanf(“%s”,persona[i].nombre);
printf(“\n Ingrese edad:”);
scanf(“%d”,&persona[i].edad);
printf(“\n Ingrese dirección:”);
scanf(“%s”,persona[i].direccion);
printf(“\n Ingrese sueldo:”);
scanf(“%f”,&persona[i].sueldo);
}
}
27
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;
….
tipo_dato_n campo_n;
}variable_1;
int funcion(tipo_dato_i VARIABLE);
….
funcion(variable_1.campo_i);
28
Estructuras (10)
#include <stdio.h>
float funcion(float *a,int t){
struct datos{
*a=(float) (t*1.015);
char nombre[30];
return *a;
char direccion[30];
}
int n_empleado,edad;
void main(){
float sueldo;
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)
void mostrar(struct datos A){
#include <stdio.h>
struct datos{
char nombre[30];
char direccion[30];
int n_empleado,edad;
float sueldo;
}
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)
void modificar(struct datos *A){;
printf(“\n Ingrese número de empleado:”);
#include <stdio.h>
scanf(“%d”,&A->n_empleado);
struct datos{
printf(“\n Ingrese nombre:”);
char nombre[30];
scanf(“%s”,A->nombre);
char direccion[30];
printf(“\n Ingrese edad:”);
int n_empleado,edad;
scanf(“%d”,&A->edad);
float sueldo;
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