Universidad del Cauca

Facultad de Ciencias Naturales, Exactas y de la Educación

Programa de Ingeniería Física

Fecha: 31 Octubre 2016

Personas Encargadas de la Relatoría: Dayana Fernanda Rúales Martínez

Lugar: Salón 308

Participantes: Dayana Fernanda Rúales Martínez

Breve descripción de la actividad:

Se inició la clase hablando sobre el proyecto Final de programación estructurada, se organizaron los
grupos de trabajo y se habló sobre la entrega de requerimientos para el programa a entregar y se
acordó llevar un cronograma por grupo.
Se habló sobre los tipos de datos abstractos y se socializó la respectiva consulta del tema.

Consulta:
Estructuras. (Tipos de datos abstractos)
Las estructuras, conocidas generalmente con el nombre de registros,
representan
un tipo de datos estructurado. Se utilizan tanto para resolver problemas que
involucran tipos de datos estructurados, heterogéneos, como para almacenar
información en archivos —como veremos en el siguiente capítulo. Las
estructuras
tienen varios componentes, cada uno de los cuales puede constituir a su vez
un
tipo de datos simple o estructurado. Sin embargo, los componentes del nivel
más
bajo de un tipo estructurado, siempre son tipos de datos simples.
Formalmente
definimos a una estructura de la siguiente manera:

“Una estructura es una colección de elementos finita y

heterogénea.”
Finita porque se puede determinar el número de componentes y heterogénea
porque
todos los elementos pueden ser de tipos de datos diferentes. Cada
componente
de la estructura se denomina campo y se identifica con un nombre único. Los
campos de una estructura pueden ser de tipos de datos diferentes como ya
hemos
mencionado, simples o estructurados; por lo tanto, también podrían ser
nuevamente
una estructura. Para hacer referencia a un campo de una estructura siempre
debemos
utilizar tanto el nombre de la variable tipo estructura como el nombre del
campo. En la figura 8.1 se muestra la representación gráfica de una estructura

EJEMPLO
Consideremos que por cada alumno de una universidad debemos almacenar
la siguiente
Información:
• Matrícula del alumno (entero).
• Nombre del alumno (cadena de caracteres).
• Carrera del alumno (cadena de caracteres).
• Promedio del alumno (real).
• Dirección del alumno (cadena de caracteres).
La estructura de datos adecuada para almacenar esta información es la
estructura.
Cabe aclarar que no es posible utilizar un arreglo para resolver este problema,
Porque sus componentes deben ser del mismo tipo de datos. En la figura 8.2
se muestra la representación gráfica de este ejemplo.
El primer campo de la estructura es Matrícula; el segundo, Nombre; el tercero,
Carrera, y así sucesivamente. Si queremos acceder entonces al primer campo de
la estructura debemos escribir variable-de-tipo-estructura-Alumno.Matrícula.
Si en cambio queremos hacer referencia al domicilio del alumno escribimos
variable-de-tipo-estructura-Alumno.Domicilio.

Declaración de estructuras
Observemos a continuación diferentes formas de declarar estructuras con la
explicación
Correspondiente.
EJEMPLO:
En el siguiente programa podemos observar la forma en que se declara la estructura
del ejemplo 8.1, así como también diferentes formas en que los campos reciben
valores.
#include <stdio.h>
#include <string.h>
/* Estructuras-1.
El programa muestra la manera en que se declara una estructura, así como la
➥forma en que se tiene acceso a los campos de las variables de tipo estructura
➥tanto para asignación de valores como para lectura y escritura. */
struct alumno /* Declaración de la estructura. */
{
int matricula;
char nombre[20];
char carrera[20]; /* Campos de la estructura. */
float promedio;
char direccion[20];
}; /* Observa que la declaración de una estructura termina con punto y
➥coma. */
void main(void)
{
/* Observa que las variables de tipo estructura se declaran como cualquier otra
➥variable. a1, a2 y a3 son variables de tipo estructura alumno. */
➥struct alumno a1 = {120, ”María”, ”Contabilidad”, 8.9, ”Querétaro”}, a2, a3;
/* Los campos de a1 reciben valores directamente. */
char nom[20], car[20], dir[20];
int mat;
float pro;
/* Los campos de a2 reciben valores por medio de una lectura. */
printf(”\nIngrese la matrícula del alumno 2: ”);
scanf(”%d”, &a2.matricula);
fflush(stdin);
printf(”Ingrese el nombre del alumno 2:”);
gets(a2.nombre);
printf(”Ingrese la carrera del alumno 2: ”);
gets(a2.carrera);
printf(”Ingrese el promedio del alumno 2: ”);
scanf(”%f”, &a2.promedio);
fflush(stdin);
printf(”Ingrese la dirección del alumno 2: ”);
gets(a2.direccion);
/* Los campos de a3 reciben valores por medio de asignaciones. */
printf(”\nIngrese la matrícula del alumno 3: ”);
scanf(”%d”, &mat);
a3.matricula = mat;
fflush(stdin);
printf(”Ingrese el nombre del alumno 3: ”);
gets(nom);

strcpy(a3.nombre, nom);
printf(”Ingrese la carrera del alumno 3: ”);
gets(car);
strcpy(a3.carrera, car);
printf(”Ingrese el promedio del alumno 3: ”);
scanf(”%f”, &pro);
a3.promedio = pro;
fflush(stdin);
printf(”Ingrese la dirección del alumno 3: ”);
gets(dir);
strcpy(a3.direccion, dir);
/* Observe la forma en que se imprimen los campos de a1 y a2. */
printf(”\nDatos del alumno 1\n”);
printf(”%d\n”, a1.matricula);
puts(a1.nombre);
puts(a1.carrera);
printf(”%.2f\n”, a1.promedio);
puts(a1.direccion);
printf(”\nDatos del alumno 2\n”);
printf(”%d\n”, a2.matricula);
puts(a2.nombre);
puts(a2.carrera);
printf(”%.2f\n”, a2.promedio);
puts(a2.direccion);
/* Observa otra forma de escribir los campos de la variable de tipo estructura
a3. */
printf(”\nDatos del alumno 3\n”);
printf(”%d \t %s \t %s \t %.2f \t %s”, a3.matricula, a3.nombre, a3.carrera,
a3.promedio, a3.direccion);
}

EJEMPLO
En el siguiente programa podemos observar diferentes formas en que los campos
de las variables declaradas como apuntadores de una estructura reciben valores,
así como también el acceso a los campos de estas variables.

Programa
#include <string.h>
/* Estructuras-2.
El programa muestra la manera en que se declara una estructura, así como la
➥forma en que se tiene acceso a los campos de los apuntadores de tipo estructura
➥tanto para lectura como para escritura. Se utiliza además una función que
➥recibe como parámetro un apuntador de tipo estructura. */
struct alumno /* Declaración de la estructura. */
{
int matricula;
char nombre[20];
char carrera[20]; /* Campos de la estructura alumno. */
float promedio;
char direccion[20];
};
void Lectura(struct alumno *); /* Prototipo de función. */
void main(void)
{
struct alumno a0 = {120, ”María”, ”Contabilidad”, 8.9, ”Querétaro”};
struct alumno *a3, *a4, *a5, a6;
/* Observa que las variables *a3, *a4 y *a5 se declaran como apuntadores de
➥tipo estructura alumno. a6 es una variable de tipo estructura alumno. */
a3 = &a0; /* En este caso al apuntador de tipo estructura alumno a3
➥se le asigna la dirección de la variable de tipo estructura alumno, a0. */
a4 = new (struct alumno);
/* Nota que al apuntador a4 es necesario asignarle una dirección de memoria.
➥Para tener acceso a los campos de un apuntador de tipo estructura, utiliza uno
➥de los dos formatos siguientes:
apuntador->campo
o bien
(*apuntador).campo
En la lectura de los campos de la variable a4 se utilizan como ejemplo ambos
➥formatos. */
printf(”\nIngrese la matrícula del alumno 4: ”);
scanf(”%d”, &(*a4).matricula);
fflush(stdin);
printf(”Ingrese el nombre del alumno 4: ”);
gets(a4->nombre);
printf(”Ingrese la carrera del alumno 4: ”);
gets((*a4).carrera);
printf(”Ingrese promedio del alumno 4: ”);
scanf(”%f”, &a4->promedio);
fflush(stdin);
printf(”Ingrese la dirección del alumno 4: ”);
gets(a4->direccion);
a5 = new (struct alumno);
Lectura(a5); /* En este caso se pasa el apuntador de tipo estructura alumno
a5 a la función Lectura. */
Lectura(&a6); /* En este caso se pasa la variable de tipo estructura alumno a6,
➥a la función Lectura. Observa que en este caso debemos utilizar el operador de
➥dirección para preceder a la variable. */
printf(”\nDatos del alumno 3\n”);
/* Observa la forma de escribir los campos de los apuntadores de tipo
➥estructura. */

printf(”%d\t%s\t%s\t%.2f\t%s”, a3->matricula, a3->nombre, a3->carrera,

➥a3->promedio, a3->direccion);
printf(”\nDatos del alumno 4\n”);
printf(”%d\t%s\t%s\t%.2f\t%s”, a4->matricula, a4->nombre, a4->carrera,
➥a4->promedio, a4->direccion);
printf(”\nDatos del alumno 5\n”);
printf(”%d\t%s\t%s\t%f\t%s”, a5->matricula, a5->nombre, a5->carrera,
➥a5->promedio, a5->direccion);
printf(”\nDatos del alumno 6\n”);
/* Observa la forma de escribir los campos de la variable tipo estructura. */
printf(”%d\t%s\t%s\t%.2f\t%s”, a6.matricula, a6.nombre, a6.carrera,
➥a6.promedio, a6.direccion);
}
void Lectura(struct alumno *a)
/* Esta función permite leer los campos de un apuntador de tipo estructura
➥alumno. */
{
printf(”\nIngrese la matrícula del alumno: ”);
scanf(”%d”, &(*a).matricula);
fflush(stdin);
printf(”Ingrese el nombre del alumno: ”);
gets(a->nombre);
fflush(stdin);
printf(”Ingrese la carrera del alumno: ”);
gets((*a).carrera);
printf(”Ingrese el promedio del alumno: ”);
scanf(”%f”, &a->promedio);
fflush(stdin);
printf(”Ingrese la dirección del alumno: ”);
gets(a->direccion);
}

Creación de sinónimos o alias

La instrucción typedef permite al usuario definir alias o sinónimos, es decir, nuevos
tipos de datos equivalentes a los ya existentes. El objetivo de esta instrucción
consiste en utilizar nombres más apropiados y más cortos para los tipos de datos,
puesto que evitamos escribir la palabra struct en la declaración de las variables.
La instrucción typedef se puede utilizar tanto con tipos de datos simples como
con estructurados. Con los tipos de datos simples su uso no resulta muy práctico,
más bien es redundante. Por ejemplo, si tenemos que declarar cinco variables de
tipo entero, C1, C2, C3, C4 y C5, para un problema en particular, lo hacemos
de esta forma:

Estructuras anidadas
Las estructuras representan un tipo de datos estructurado, que tiene por lo
tanto
varios componentes. Cada uno de estos componentes puede a su vez ser un
tipo
de datos simple o estructurado. Las estructuras anidadas se presentan cuando
en la declaración de una estructura, por lo menos uno de sus componentes es
una
estructura. Observemos el siguiente ejemplo.
EJEMPLO
Consideremos que en una empresa requieren almacenar la siguiente
información
de cada empleado:
• Nombre del empleado (cadena de caracteres).
• Departamento de la empresa (cadena de caracteres).
• Sueldo (real).
• Domicilio
• Calle (cadena de caracteres).
• Número (entero).
• Código Postal (entero).
• Localidad (cadena de caracteres).
A continuación se observa la representación gráfica de esta estructura:
31/10/2016

PROGRAMA PRINCIPAL

1) pedir complejo A

2) pedir complejo B

3) sumar A+B y guardar en C

4) restar A+B y guardar en D

5) multiplicar A*B y guardar en D

6) división A/B y guardar en E

7) mostrar C

8) mostrar D

9) mostrar E

10) mostrar F

11) ¿quieres continuar?

11.1) si SI ir a 1 SINO fin

SUBRUTINAS

Llenar complejo

0) declarar un complejo X

1) pedir parte real

2) guardo en el X. real //campo.real=x.real

3) pedir parte imaginaria

4) guardo en el X imaginario // campo.imaginario=x.imaginario

5) devolver el x resultante

Sumar complejos

1) Recibir A, B

2) Declarar complejo C

3) C.real<-A.real+B.real

4) C.imaginario<-A.imaginario + B.imaginario

5) devolver C
DIAGRAMA DE FLUJO

INICIO

Complejo A, B, C, D, E, F;

Int op;

A<- llenar_ complejo ()

B<-llenar_complejo()

C<-sumar_(A,B)
DESEA CONTINUAR

OP

OP==1

FIN
Llenar_complejo()

Complejo x;

Float a,b;

a,b

x.real<-a

x.real<-b

Devolver x

Fin llegar
complejo
 Sumar_C(A,B)

Complejo C

C.real<-A.real+B.real

C.imaginario<-A.imaginario+B.imaginario

Devolver(C)

Fin sumar_C
#include<conio.h>
#include<stdio.h>
struct complejo
{
float real,imag;
};
complejo llenar_complejo();
complejo sumar_c(complejo,complejo)
.
.
.
void mostrar_c (complejo);

void main()
{
complejo a,c,d,e,f;
int op;
do{
a=llenar_complejo();
b=llenar_complejo();
c=sumar_c(a,b);
d=resta_c(a,b);
.
.
mostrar_c(a);
mostrar_c€;
printf(“%d”,&op);
}
while (op==1);
}
Observaciones sobre la actividad:
Se recomienda iniciar a trabajar con archivos con formatos .txt.
Compromisos:

Entregar el cronograma (Las fechas del cronograma se llevan a disposición y criterio del grupo de
trabajo).
Entregables para proyecto final:

1. Análisis de requerimientos
2. Diseño de bloques
3. Matriz de variables
4. Algoritmos
5. Lenguaje C
31/10/2016

ANALISIS DEL PROBLEMA

Hacer un programa que me lea un complejo y haga operaciones básicas

REQUERIMIENTOS

- Formato r+i
- 6 complejos
- Cada operación será una subrutina o subprograma (desde llenar el complejo hasta
imprimir)
- Opción para continuar

DISEÑO E BLOQUES

Llenar_C
Complejo A

Llenar_C
Complejo B

A COMPLEJO C

B Sumar complejo

A COMPLEJO D
Restar
B
 A
Multiplicar
B E

A
Dividir
B F

COMPLEJO
Mostrar

MATRIZ DE VARIABLES

NOMBRE TIPO MODULO NEC I/S EST

A COMPLEJO LLENAR SI s/IIII p.u
SUMA SI pasar
RESTA SI corre
MULTIPLICACION SI parg
DIVISION SI metro
MOSTRAR SI
B COMPLEJO LLENAR SI ““ a.real
SUMA SI b.real
RESTA SI =creal
MULTIPLICACION SI (creal<-
DIVISION SI a.real+b.real
MOSTRAR SI Printf();
C COMPLEJO SUMAR X S
MOSTRAR V

PROGRAMA PRINCIPAL

1) pedir complejo A

2) pedir complejo B

3) sumar A+B y guardar en C

4) restar A+B y guardar en D

5) multiplicar A*B y guardar en D

6) división A/B y guardar en E

7) mostrar C

8) mostrar D

9) mostrar E

10) mostrar F

11) ¿quieres continuar?

11.1) si SI ir a 1 SINO fin

SUBRUTINAS

Llenar complejo

0) declarar un complejo X

1) pedir parte real

2) guardo en el X. real //campo.real=x.real

3) pedir parte imaginaria

4) guardo en el X imaginario // campo.imaginario=x.imaginario

5) devolver el x resultante

Sumar complejos

1) Recibir A, B

2) Declarar complejo C

3) C.real<-A.real+B.real

4) C.imaginario<-A.imaginario + B.imaginario

5) devolver C
DIAGRAMA DE FLUJO

INICIO

Complejo A, B, C, D, E, F;

Int op;

A<- llenar_ complejo ()

B<-llenar_complejo()

C<-sumar_(A,B)
DESEA CONTINUAR

OP

OP==1

FIN
Llenar_complejo()

Complejo x;

Float a,b;

a,b

x.real<-a

x.real<-b

Devolver x

Fin llegar
complejo
 Sumar_C(A,B)

Complejo C

C.real<-A.real+B.real

C.imaginario<-A.imaginario+B.imaginario

Devolver(C)

Fin sumar_C