Guia de Practicas de Programacion I - Sesion 24 - 2012

Laboratorio de Programación I Página 131

Mgter. Ángel Montesinos Murillo, Mgter. Manuel Zúñiga Carnero Sesión N° 24

UNIVERSIDAD CATÓLICA DE SANTA MARÍA PROGRAMA PROFESIONAL DE INGENIERÍA DE SISTEMAS

SESIÓN N° 24:

Estructuras en C/C++

I

OBJETIVOS

Comprender los conceptos de variables tipo struct y su implementación dentro de programas.

Aplicar variables tipo struct en la solución de problemas de gestión de datos. Valorar las ventajas y capacidades que proporcionan las variables tipo struct.

II

TEMAS A TRATAR

Introducción. Operaciones complejas en registros y archivos directos Resumen.

III

MARCO TEORICO

1. INTRODUCCIÓN

Lenguaje C proporciona formas diferentes de creación de tipos de datos propios. Uno de ellos es la agrupación de variables bajo un mismo nombre, Otra es permitir que la misma parte de memoria sea definida como dos o más tipos diferentes de variables y también crear una lista de constantes entera con nombre.

Existen circunstancias en que son especialmente importantes y útiles las estructuras, cuando se trata de almacenar y recuperar registros de datos en medios externos (disco por ejemplo). En estos casos, las estructuras son especialmente idóneas para escribir y recuperar toda la información contenida en ellas en una sola operación de lectura/escritura.

Las estructuras son tipos nuevos definidos por el usuario (nuevos en el sentido de que no están predefinidos en el lenguaje), se engloban dentro de la categoría general de tipos derivados. Representan conjuntos de miembros que pueden ser a su vez de tipo básico o derivado con ciertas; además también pueden ser miembros los campos de bits.

En otros lenguajes se les denomina registros (records); sus componentes se denominan "miembros", aunque en ocasiones también se suelen llamar "campos".

2. ESTRUCTURAS

Una estructura es una colección de variables que se referencia bajo un único nombre, proporcionando un medio eficaz de mantener junta una información relacionada. Las



variables que componen la estructura se llaman miembros de la estructura y está relacionado lógicamente con los otros. Otra característica es el ahorro de memoria y evitar declarar variables que técnicamente realizan las mismas funciones.

struct nombre{

var1; var2; varN;

}; . .

. . struct nombre etiqueta1,etiquetaN;

Los miembros individuales de la estructura se referencian utilizando la etiqueta de la estructura el operador punto(.) y la variable a la que se hace referencia. Los miembros de la estructura deben ser inicializados fuera de ella, si se hace en el interior da error de compilación.

etiqueta.variable;

Ejemplo:

#include <stdio.h> void main (void) {

int opcion=0; struct ficha{ char nombre[40];

char apellido[50]; unsigned edad; }emplead,usuario;

do { clrscr();

gotoxy(2,4);printf("1.empleados");

gotoxy(2,5);printf("2.usuarios"); gotoxy(2,6);printf("0.visualizar");

gotoxy(2,7);scanf("%d",&opcion); if (opcion==0) break;

if(opcion==1) { gotoxy(2,10);printf("Nombre: ");

gets(emplead.nombre); gotoxy(2,11);printf("Apellido: "); gets(emplead.apellido);

gotoxy(2,12);printf("Edad: "); scanf("%d",&emplead.edad); }

else { gotoxy(2,10);printf("Nombre: ");

gets(usuario.nombre); gotoxy(2,11);printf("Apellido: ");

gets(usuario.apellido);

gotoxy(2,12);printf("Edad: "); scanf("%d",&usuario.edad); }

}while(opcion!=0); gotoxy(2,18); printf("%s %s\n",emplead.nombre,emplead.apellido);

gotoxy(2,19);printf("%u años",emplead.edad); gotoxy(30,18); printf("%s %s\n",usuario.nombre,usuario.apellido);

gotoxy(30,19);printf("%u años",usuario.edad); getch();

struct nombre{

var1;

var2;

varN;

}etiqueta1,etiquetaN;



}

Un miembro de la estructura no puede ser la estructura que se declara porque daría lugar a una declaración circular (lo definido está dentro de su definición). Ejemplo:

struct mystr { mystr s }; // Ilegal

Si es posible que uno de los miembros sea un puntero a la estructura que se está declarando como en el ejemplo:

struct mystr { mystr *ps } // Ok: Correcto

También es posible que los miembros de una estructura sean a su vez estructuras previamente definidas, dando lugar a estructuras anidadas. Ejemplo:

struct Punto{ int x; int y; };

struct Cuadro{ struct Punto p1;

struct Punto p2; } c1;

Se declara Cuadro como un tipo struct con dos miembros, cada uno de los cuales es un tipo struct Punto.

Es importante tener en cuenta que, en este punto, solo está permitido señalar tipo y nombre de los miembros, sin que se pueda efectuar ninguna asignación; ni aún en el caso de que se trate de una constante. Por ejemplo, las definiciones que siguen serían ilegales, pues todas implican una asignación en la definición del segundo miembro:

struct Str {int x; int y = 2; }; struct Str {int x; const int y = 3; };

struct Str {int x; char c = 'X'; }; struct Str {int x; char * st = "Hola"; }; struct Str {int x; "Hola"; };

struct Str {int x; int a[2] = {3, 4};};

3. INICIALIZACIÓN DE ESTRUCTURAS

Las estructuras pueden inicializarse al igual que las matrices incluso en el mismo punto de su declaración, con una lista de iniciadores entre llaves { } separados por comas, uno para cada miembro de la estructura. Ejemplo:

struct Cliente { int i;

char str[20]; double d; } s = { 33, "Pepe Lopez", 3.14 };

Aquí se declara una estructura Cliente compuesta por un entero, un array de 20 caracteres y un doble; inicia una estructura s como perteneciente al tipo Cliente con valores concretos en cada campo.

En estructuras o uniones con duración automática, el inicializador debe ser alguno de los siguientes:



Una lista de inicializadores constantes (también se permiten expresiones con sizeof).

Ejemplo:

struct punto {int x; int y;} p1 = {1, 2};

Una sola expresión con una estructura de tipo compatible. En este caso, el valor

inicial del objeto es el de la expresión. Ejemplo:

struct punto p2 = p1;

En este caso (suponiendo los valores anteriores) sería: p2.x == 1 y p2.y == 2

Los miembros complejos de listas de iniciadores, como matrices, pueden inicializarse con expresiones adecuadas incluidas en bloques de llaves anidados. Ejemplo:

struct Pesadas { int tiket;

int pesos[5];

} s = { 150, {10, 45, 0, 78, 20}};

Si la lista de inicializadores contenidos entre las llaves { } es menor que los miembros de la estructura, el resto de los miembros es inicializado implícitamente siguiendo las mismas reglas que los objetos con duración estática.

4. ESPACIO DE ALMACENAMIENTO

A continuación se expone un ejemplo de estructura con una composición de miembros variada. En el comentario de cada línea se indica el espacio de almacenamiento necesario (en bytes) según las especificaciones declaradas para el compilador utilizado:

struct general {

int x; // L2. 4 bytes char ch; // L3. 1 byte double db; // L4. 8 bytes

char * sg; // L5. 4 bytes char nom[30]; // L6. 30 bytes char * dir[]; // L7. 4 bytes

} str; // L8. printf("M1:%3.0d\n", sizeof(str.x)); // L9. M1: 4 printf("M2:%3.0d\n", sizeof(str.ch)); // L10. M2: 1

printf("M3:%3.0d\n", sizeof(str.db)); // L11. M3: 8 printf("M4:%3.0d\n", sizeof(str.sg)); // L12. M4: 4 printf("M5:%3.0d\n", sizeof(str.nom)); // L13. M5: 30

printf("M6:%3.0d\n", sizeof(str.dir[0])); // L14. M6: 4 printf("Total:%3.0d\n", sizeof(str)); // L15. Total: 56

Las líneas 2, 3 y 4 no requieren comentario; L5 define un puntero a carácter, ocupará 4 bytes en un compilador de 32 bits. L6 define una matriz de 30 caracteres, por lo que se reserva espacio para otros tantos; finalmente, L7 define un puntero a matriz de caracteres; este miembro ocupa un espacio de 4 bytes en la estructura, aunque la matriz a la que apunta (exterior a la propia estructura) sea de tamaño indefinido.

Las líneas 9 a 14 son simplemente una confirmación de que las suposiciones teóricas son correctas, como efectivamente se comprueba. La línea 15 es una comprobación del tamaño total de la estructura, con el sorprendente resultado que se indica.

La razón de la discrepancia hay que buscarla en el hecho de que, por razones de eficiencia (por ejemplo de velocidad de acceso a memoria), el compilador, que asigna espacio de memoria en múltiplos de un cierto número determinado de bits (8 en este caso), intenta no utilizar fracciones de palabra, con lo que realiza determinados redondeos o alineaciones internas. En este caso, la suma teórica: 51 x 8 = 408 bits habría supuesto el uso de 12.75 palabras de 32 bits, por lo que el compilador redondea a 14 palabras; 56 x 8 = 448 bits, 14 palabras. Hay que recordar que, aunque existan 5 bytes perdidos (no



utilizados), el almacenamiento ocupado por la estructura str sigue siendo contiguo y el acceso a sus miembros totalmente transparente para el programador; del mismo modo, si más tarde se declara una matriz de estructuras de tipo general y se utilizan punteros, el compilador tiene automáticamente en cuenta el verdadero tamaño ocupado por cada elemento, a fin de efectuar correctamente los desplazamientos pertinentes.

Como puede verse, en términos de tamaño de la estructura, las estrategias representadas por la líneas 6 y 7 varían grandemente; la adopción de una u otra depende del contexto de cada caso. Téngase en cuenta por ejemplo, que si se guardase en disco el contenido de la estructura, una recuperación posterior garantizaría el contenido original para el elemento str.nom, sin embargo, los punteros str.sg y str.dir quizás podrían apuntar a zonas de memoria totalmente erróneas.

5. OPERACIONES PERMITIDAS CON ESTRUCTURAS

La únicas operaciones con estructuras que se permiten en C++ son las que se indican:

A. ASIGNARLAS O RECIBIR ASIGNACIÓN COMO ENTIDAD

ÚNICA.

En estos casos, origen y destino de la asignación tiene que ser del mismo tipo, aunque si no lo son, todavía es posible la asignación miembro a miembro. Ejemplo:

struct A {

int i,j; } a, a1; struct B {

int i,j; } b; a = a1; //OK: mismo tipo, se realiza asignación miembro a miembro

a = b; // ILEGAL: tipos diferentes a.i = b.i; a.j = b.j; // Ok: asignación por miembros uno a uno

Observe que la asignación anterior se refiere a instancias de estructuras, no a las clases en sí. Es decir:

struct StrA { ... };

stuct StrB = StrA; // Error!!

La asignación anterior no está permitida. Sin embargo, puesto que se trata de clases puede construirse una estructura que contenga exactamente los mismos elementos que otra anterior derivándola por herencia:

struct StrB : StrA {};

Sin embargo, recordemos que en este caso ambas estructuras son tipos distintos, por lo que más tarde no pueden efectuarse asignaciones del tipo:

StrA Sa; StrB Sb = Sa; // Error. Tipos distintos!!

B. OBTENER SU DIRECCIÓN

Ejemplo:

struct StrA sa;



struct StrA* sptr;

sptr = &sa;

C. ACCESO A MIEMBROS

Se dispone de dos operadores para referenciar a los miembros de estructuras y uniones (operadores de selección):

Selector directo: Una expresión del tipo sT.obj representa el objeto obj de la

estructura sT. ( la expresión es un Lvalue siempre que sT no lo sea y obj no sea una

matriz).

Selector indirecto: Una expresión del tipo stPt -> obj representa el objeto obj de la

estructura sT siempre que stPt sea un puntero a dicha estructura (la expresión es un

Lvalue siempre que obj no sea una matriz). Esta expresión es equivalente, y

preferible a (*stPt).obj.

El uso de uno u otro es indiferente, depende de que se tenga un identificador de la

estructura, en cuyo caso puede usarse el selector directo (expresión sT.obj ), o un

puntero, en cuyo caso puede usarse el indirecto (expresión: stPt->obj ). Ejemplo:

struct Str { // declara estructura Str

int i; char a; } s, *sptr = &s; // declara s tipo Str; sptr puntero a s

... s.i = 3; // asigna 3 al miembro i de s sptr -> a = 'B'; // asigna 'B' al miembro a s

6. RESUMEN

Los archivos de acceso aleatorio al ser más versátiles, permiten acceder a cualquier parte del archivo en cualquier momento, como si fueran arrays en memoria. Las operaciones de lectura y/o escritura pueden hacerse en cualquier punto del archivo de forma directa con las funciones asociadas a este tipo de archivos.

Los archivos de acceso directo tiene como los de acceso secuencial las mismas operaciones complejas, pero la diferencia es la capacidad que poseen estos archivos de saltar al registro respectivo para hacer sus operaciones, esto hace que el tipo de gestión sea mucho más rápido a la hora de hacer el procesamiento, para ello posee un mecanismo que nos permite apuntar al registro deseado.

IV

(La práctica tiene una duración de 2 horas) ACTIVIDADES

1. Encender el equipo de cómputo, si existe algún desperfecto o faltante en el equipo comunicarlo inmediatamente.

2. Al aparecer la solicitud de contraseña hacer clic en el botón Cancelar o ingresar el nombre de cuenta(login) y contraseña(password) que especifique el Docente. Esperar que aparezca el mensaje de Inicio de sesión.

3. Crear una carpeta que se llame Programación I y dentro de ella una que se llame Práctica Nº 24 dentro de la carpeta Mis Documentos.

4. Ejecute el Visual Studio 2010, crear un nuevo proyecto CRL, para esto elegir en la pestaña Archivo y aquí elegir la opción más adecuada.

5. Nombrar los archivos como se indica en el archivo Actividades N° 24 que se adjunta y asegurarse de almacenarlos en la carpeta Práctica Nº 24 al momento de crearlos.

6. Realizar las acciones indicadas en el archivo adjunto.



7. Al finalizar la práctica de be guardar todos sus archivos, ya sea en su memoria USB o por correo electrónico y luego eliminar los archivos del equipo y vaciar la papelera de reciclaje.

V

EJERCICIOS

1. Crear una aplicación que nos permita gestionar toda la información que se puede almacenar sobre un alumno en la universidad en una variable tipo Struct, con las consistencias de ingreso de datos del caso.

2. Modifique el programa anterior agregando una funcionalidad que nos permita ver la cantidad de memoria utilizada por cada dato miembro y la estructura en su conjunto.

3. Agregar al programa más variables tipo Struct para almacenar los datos de más alumnos.

VI

CUESTIONARIO

1. ¿Qué es una variable tipo struct?. 2. ¿Qué son los datos miembros de la variable tipo struct?. 3. ¿Cómo accedemos a los datos miembro de la variable tipo stuct?. 4. ¿Qué tipos de datos miembro puede tener una variable tipo Struct?. 5. ¿Cuántas formas de acceder a los datos miembro existen?. 6. ¿Cuál es el equivalente de las variables tipo struct en otros lenguajes de programación?. 7. ¿Cómo se declara una variable tipo struct?. 8. ¿Qué operaciones se pueden realizar sobre una variable tipo struct?. 9. ¿Se puede declarar una función como dato miembro dentro de una variable tipo struct?. 10. ¿Se puede conseguir encapsulamiento con una variable tipo Struct?. 11. ¿Cómo almacenaríamos una referencia a una función en una variable tipo struct?.

VII

BIBLIOGRAFIA Y REFERENCIAS

Deitel, Paul J., Deitel, Harvey M., "Cómo Programar en C++", 6ta Edición, Ed. Pearson Educación, México 2009.

Ceballos Sierra, Francisco J., "Curso de Programación C++. Programación Orientada a Objetos"; MADRID, RA-MA, 1991.

Kernighan, Brian W., Ritchie, Dennis M., "El Lenguaje de Programación C", 2da Edición, Ed. Prentice Hispanoamérica S. A., México 1991.

Documents

Guia de Practicas de Programacion I - Sesion 24 - 2012