Módulo 7 - Fundamentos de Programación en C, C++ PDF

MP 11 Fundamentos Programacin
UF 02 Diseo Modular
MP 11 UF 02 Mdulo 7 Fundamentos Programacin. Pgina 1
MDULO 7 FUNDAMENTOS PROGRAMACIN EN C, C++.

OBJETIVOS.
En este mdulo veremos una miscelnea de aspectos ms avanzados en C/C++.
Aprenderemos a trabajar con estructuras de datos definidas por el usuario. Tambin haremos una
descripcin de las uniones, otro mecanismo de almacenamiento de datos similar a las estructuras
pero muy diferente en su uso. Veremos cmo crear nuevos tipos de dato, como crear funciones
con un nmero variable de argumentos y cmo podemos asignar memoria dinmicamente.
Concretamente, los aspectos que tratar este mdulo son:
Concepto de estructura.
Definicin de estructura.
Inicializacin de variables estructuras.
Referencia a una estructura.
Asignacin de estructuras.
Vectores de estructuras.
Paso de estructuras a funciones.
Punteros a estructuras.
Variables de tipo enumerado.
Uniones.
La palabra clave typedef.
Funciones con un nombre de argumentos variable.
Los argumentos de la funcin main().
Memoria dinmica: las funciones de C: malloc(), free().
Los operadores de asignacin dinmica de C++: new y delete.
Otras funciones: calloc(), realloc().

1. RESUMEN TERICO.
1.1. CONCEPTO DE ESTRUCTURA.
En C/C++ una estructura es una coleccin de variables de diferentes tipos bsicos
referenciados bajo el mismo nombre. Por ejemplo, un trabajador de una empresa puede estar
clasificado por su nombre, los apellidos, la edad... El concepto de estructura es muy importante ya
que es el antecedente directo del concepto de clase en la Programacin Orientada a Objetos.
Las estructuras tambin son denominadas registros o, en ingls "records". De hecho, las
estructuras son en muchos aspectos, similares a los registros de las bases de datos. Siguiendo esta
analoga, a las variables componentes de las estructuras se las suele denominar campos o "fields".
1.2. DEFINICIN DE UNA ESTRUCTURA.
Para definir una estructura se utiliza la siguiente sintaxis:
struct[<nombre de la estructura>]
{
[<tipo> <nombre de variable>[,<nombre de variable>,]];
.
}
[<variable de estructura>[,<variable de estructura>,];
Siempre se comienza con la palabra reservada struct seguida de un nombre identificador
para referirse a la estructura. Este identificador es optativo y en algunos casos no es necesario.
A continuacin, y entre llaves, se define la estructura propiamente dicha. Esta consta de
una coleccin de variables con sus tipos correspondientes.
Despus de la coleccin de variables o campos, se puede declarar las variables de
estructura. Esta declaracin se puede hacer tambin separada de la definicin de la estructura.
Veremos todo esto en un ejemplo:
struct Trabajador{
char Nombre[50];
char Apellido1[30];
char Apellido2[30];
int Edad;
}
ingeniero, administrativo, auxiliar;
De esta forma se ha definido la estructura trabajador y se han declarado tres variables de
este tipo. Para cada una de las variables se reserva 50+30+30+4=114 octetos.
Este proceso se puede seguir tambin por separado, en dos fases:
//Fase de definicin de la estructura.
struct Trabajador{
char Nombre[50];
char Apellido1[30];
char Apellido2[30];
int Edad;
}:
. . . . .
. . . . .
. . . . .
//Fase de declaracin de variables de estructura.
[struct] Trabajador ingeniero, administrativo, auxiliar;

En la fase de definicin de la estructura no se reserva memoria para ninguna variable, slo
se hace un patrn o molde para poder declarar ms tarde variables con esta estructura.
Posteriormente, para declarar una variable con esta estructura se escribe el nombre de la
estructura seguido del nombre de la o las variables.
En el estndar ASCII C no es necesario poner delante del identificador de la estructura la
palabra struct. Esta palabra puede omitirse en C++, y de esta forma, se identifica el nombre de la
estructura como un verdadero tipo de variable.
Si se omite el nombre de la estructura en su definicin se dice que se ha creado una
estructura annima y no se puede, posteriormente a la definicin de la estructura, declarar
ninguna variable con esta estructura de forma directa.
Si una estructura tiene identificador, esta puede pasar como argumento a una funcin de la
misma forma que cualquier otro tipo de variable.
Es una prctica habitual definir las estructuras globales; es decir, fuera de cualquier funcin,
incluida la funcin main(). De esta forma, todas las funciones podrn declarar variables con esta
estructura.
En los campos de una estructura pueden ser otras estructuras. Por ejemplo, es correcta
esta definicin:
struct Fecha
{
int Dia;
int Mes;
int Ao;
};

struct Persona
{
char Nombre[50];
char Apellido1[30];
char Apellido2[30];
int Edad;
Fecha nacimiento;
};
1.3. INICIALIZACIN DE VARIABLES DE ESTRUCTURAS.
Para poner un valor inicial a las variables de tipo estructura se hace de la misma forma que
con los vectores. Los diferentes valores de los campos son declarados uno tras otro, separados
por comas y cerrados por llaves.
Por ejemplo: Trabajador Ingeniero={"Juan", "Lpez", "Puig", 35};
1.4. REFERENCIA A UNA ESTRUCTURA.
Las variables de estructura se pueden referenciar completas o bien se puede acceder
individualmente a los elementos del interior. En este ltimo caso se utiliza el operador punto(.).
Este operador es el de mxima prioridad, exceptuando los parntesis y corchetes.
Por ejemplo, para hacer referencia al campo nombre de la variable Ingeniero se utiliza la
expresin: ingeniero.nombre.

1.5. ASIGNACIN DE ESTRUCTURAS.
La asignacin de estructuras est permitida siempre que se haga entre variables del mismo
tipo de estructura. Por ejemplo, si definimos dos variables del tipo Trabajador con la sentencia:
Trabajador Ingeniero1={"Juan", "Lpez", "Puig", 35}, Ingeniero2;
una asignacin como: Ingeniero2=Ingeniero1; equivale a:
Ingeniero2.Nombre=Ingeniero1.Nombre;
Ingeniero2.Apellido1=Ingeniero1.Apellido1;
Ingeniero2.Apellido2=Ingeniero1.Apellido2;
Ingeniero2.Edad=Ingeniero1.Edad;
1.6. VECTORES DE ESTRUCTURAS.
El uso simultneo de vectores y estructuras proporciona una poderosa herramienta para el
almacenamiento y manipulacin de datos.
Por ejemplo, si la empresa dispone de 10 ingenieros, podemos declarar una variable
indexada como: Trabajador Ingeniero[10];
En este caso, para referirnos al nombre del ingeniero 0 escribiremos: Ingeniero[0].Nombre
1.7. PASO DE ESTRUCTURAS A FUNCIONES.
Cuando se pasa una variable de estructura a una funcin, esta se pasa por valor; es decir, se
pasa una copia de la informacin de la variable que esta funcin puede modificar sin modificar la
variable original. En la practica 2 hay un ejemplo de cmo se pasa una estructura entera por valor
a una funcin.
1.8. PUNTEROS EN ESTRUCTURAS.
De la misma forma que se puede declarar una variable puntero que apunte a una variable
de tipo bsico, tambin es posible declarar un puntero que apunte a una variable de estructura.
Para declarar una variable puntero en una estructura se sigue la sintaxis normal de poner un *
delante del nombre de la estructura. Por ejemplo: Trabajador *Persona;
Para encontrar la direccin de una variable de estructura se escribe el operador & delante
del nombre de la variable de estructura. En el ejemplo anterior podemos asignar el puntero
persona a una variable de estructura de la siguiente forma: Persona = &Ingeniero;
Para referirnos al campo Nombre de la variable apuntada por Persona se podra escribir:
(*Persona).Nombre (el parntesis es necesario debido a la mayor prioridad del operador punto).
Este es un sistema correcto pero casi en desuso. El segundo mtodo y el ms utilizado para
referirnos a un miembro de una variable de estructura apuntada por un puntero de estructura es
con ayuda del operador (->). En el cdigo escrito a continuacin, las dos ltimas lneas hacen
exactamente lo mismo, escriben el Nombre de la variable Ingeniero donde apunta el puntero P:
Trabajador *P;
char Cadena[110];

P=&Ingeniero;

printf("%s\n", (*p).Nombre);
printf("%s\n", p->Nombre);

1.9. VARIABLES DE TIPO NUMERADO.
Una enumeracin es un conjunto de constantes enteras con un nombre. Si una vez definida
una enumeracin se declara una variable con esta enumeracin, la variable (entera) asociar
estas constantes con los valores posibles de la variable. De hecho, nos aseguraremos que esta
variable no puede contener otro valor que alguna de las constantes enteras definidas.
Para definir una enumeracin se procede de forma parecida a la definicin de una
estructura, cambiando la palabra clave struct por la palabra clave enum. La declaracin de
variables enum tambin se puede hacer en el mismo momento de la definicin de la enumeracin
o bien despus.
Ejemplo:
enum Dia {Lunes,Martes,Mircoles,Jueves,Viernes,Sbado,Domingo} Hoy;
La declaracin de la variable Hoy se hace en el mismo momento de la definicin de la
enumeracin Dia:
enum Dia {Lunes,Martes,Mircoles,Jueves,Viernes,Sbado,Domingo};
. . . . .
Dia Hoy;
La declaracin de la variable Hoy se hace despus de la definicin de la enumeracin. El
identificador de la enumeracin (Dia) se puede utilizar como un autntico nombre de tipo. En
ANSI C es necesario anteponer al identificador de la numeracin la palabra clave enum, de la
misma forma que se hace con las estructuras. En C++ no es necesaria esta palabra clave en la
declaracin de variables.
Una variable del tipo enumeracin es, de hecho, una variable entera (4 octetos).
Internamente asocia cada constante de la lista de la enumeracin con un entero que por defecto
es 0 la primera constante, 1 la segunda constante, Esta asociacin se podra cambiar si en el
momento de la definicin de la enumeracin se especifica el nmero entero asociado a cada
constante.
Aunque internamente una variable de tipo enumeracin es una variable entera, esta slo
puede contener uno de los posibles valores de la lista de enumeracin y no puede asignarse
ningn otro valor.
Los compiladores de C no diferencian entre los tipos int y enum, es por eso que se pueden
hacer asignaciones de este tipo: Hoy=5; //Asignacin vlida solo en C.
En C++ hay que forzar la conversin como: Hoy=(Dia) 5; //Asignacin vlida.
1.10. UNIONES.
Una unin es una variable que puede contener diferentes tipos de datos en la misma
posicin de memoria pero, como es evidente, nunca de forma simultnea. Una unin se define de
forma similar a las estructuras, cambiando la palabra clave struct por union.
union[<nombre de la union>]
{
[<tipo> <nombre de variable>[,<nombre de variable>,]];
.
}
[<variable de unin>[,<variable de unin>,];

La similitud entre uniones y estructuras van an ms all:
De la misma forma que en las estructuras, es posible definir uniones annimas.
Es posible declarar variables de unin en la misma definicin de la unin o despus.
En ANSI C es necesario poner la palabra clave unin delante del identificador de la unin
en una declaracin posterior de una variable de unin, y en C++ no es necesario.
Para referirse a un miembro concreto de una variable de unin se utiliza el operador
punto (.).
Para referirse a un miembro concreto de una variable de unin donde apunta un
puntero se utiliza el operador flecha(->).
Las diferencias entre estructuras y uniones son las siguientes:
Cuando se declara una variable de estructura se reserva espacio de memoria para todos
los miembros de la estructura, en cambio, cuando se declara una variable de unin, se
reserva espacio de memoria para el miembro ms grande.
Cuando se asigna un valor a una variable de unin, este valor se asigna a uno de los
miembros que tiene un tipo concreto. En este momento slo puede referirse a este
miembro de la variable y no a otro. Si se asigna otro valor a otro miembro, el antiguo
valor del primer miembro se pierde.
Veremos un ejemplo de cmo se almacena en la memoria una estructura y una unin,
donde la variable de estructura necesita 13 octetos mientras que la variable de unin slo 8.

1.11. LA PALABRA CLAVE TYPEDEF.
En C/C++ se permite definir nuevos nombres de tipos con la palabra clave typedef.
Realmente no se estn creando nuevos tipos si no que se est definiendo un nuevo nombre para
un tipo ya existente. La sintaxis de esta asignacin es: typedef tipo Nombre_Nuevo;
tipo puede ser cualquier tipo bsico, con o sin modificadores, estructuras, uniones,
enumeraciones, etc. De hecho, en ANSI C era la forma que una estructura, enumeracin o unin
se considerase realmente como un nuevo tipo. Esta utilidad ya no es necesaria en C++. Donde
estas estructuras, son de hecho, nuevos tipos.

1.12. FUNCIONES CON UN NMERO DE ARGUMENTOS VARIABLE.
Es posible en C/C++ crear funciones con un nmero indeterminado de argumentos. Los
argumentos conocidos se ponen de la forma tradicional (debe haber como mnimo 1) y los
desconocidos se sustituyen por tres puntos (). Por ejemplo: int funcin (char c, float f, );
En el archivo de cabecera stdarg.h se definen algunas macros tiles para la manipulacin de
un nmero indeterminado de argumentos. Estas se describen a continuacin:
Un nuevo nombre de tipo: va_list. Ser necesario declarar una variable de este tipo para
tener acceso a la lista de parmetros.
La macro va_start() que tiene la siguiente sintaxis: void va_start(va_list p, ltimo);
Esta macro ajusta el valor de p para que apunte al primer parmetro de la lista.
<ltimo> es el identificador del ltimo parmetro fijo antes de comenzar la lista.
La macro va_arg() que tiene la siguiente sintaxis: void va_argt(va_list p, tipo);
Esta macro retorna el siguiente valor de la lista de parmetros, p debe ser la misma
variable que se inicializ con la macro va_start y tipo es el tipo de parmetro que se
sacar de la lista.
La macro va_end() permite restaurar el estado de la pila que es donde se almacenan los
datos de la lista de parmetros. Esto es necesario para que el programa finalice
normalmente. Su sintaxis es: void va_end(va_list p);
1.13. LOS ARGUMENTOS DE LA FUNCIN MAIN().
Es til, muchas veces, especificar opciones o valores en el momento de ejecutar un
programa desde la lnea de comandos del sistema operativo. Los comandos de Linux pueden ser
ejemplos de ejecucin de un programa con argumentos entrados junto al nombre del programa.
El programa reconocer estos parmetros a travs de los argumentos de la funcin main().
Para declarar los argumentos de la funcin main() es: tipo main (int argc, char *argv[]); o
bien, la forma equivalente: tipo main(int argc, char **argv);
El primer parmetro argc es el nmero de argumentos que se han especificado en la lnea
de comandos (el nombre del programa ejecutable cuenta como el primer argumento). El segundo
parmetro argv es un vector de cadenas de caracteres que contiene los argumentos
especificados.
Por ejemplo, si en la lnea de comandos se escribe: programa arg1 arg2 arg3 (sin
comas):
El primer parmetro, argc va ser 4 y el segundo parmetro, argv[] contendr la lista de
"arg1", "arg2", "arg3".
Si estos parmetros son nmeros, deben convertirse al tipo correspondiente con las
funciones de la librera estndar:

La declaracin de estas funciones se encuentra en el archivo de cabecera stdlib.h.

1.14. MEMORIA DINMICA.
En la ejecucin de un programa, la memoria disponible del ordenador se divide en cuatro
partes:
la que contiene el cdigo del programa;
la que contiene todas las variables globales;
la pila (donde se almacena las variables locales);
la zona de memoria dinmica.
Cuando se reserva espacio de memoria para las variables locales estticas, estas se van
almacenando en la pila, avanzando el puntero de esta pila. Cuando las variables salen de su
mbito, se libera automticamente esta memoria desplazando hacia atrs el puntero de la pila.
Adems de esta forma de reserva de espacio que se hace en tiempo de compilacin hay
otra forma que se puede hacer en tiempo de ejecucin. La memoria reservada en tiempo de
ejecucin se denomina memoria dinmica y corresponde a la cuarta de las zonas antes
mencionadas.
Las variables almacenadas en esta zona no salen nunca del mbito; es decir, son siempre
visibles hasta que se liberen deliberadamente esta memoria. Es pues, responsabilidad del
programador liberar esta memoria reservada.
1.15. LAS FUNCIONES MALLOC() Y FREE().
LOS OPERADORES NEW Y DELETE.
En el lenguaje C hay dos funciones de la librera estndar que se encargan de reservar y
liberar memoria dinmica, se trata de las funciones malloc() y free(). Estas funciones necesitan los
archivos <stdlib.h> y <malloc.h>.
La funcin malloc() contiene un nico argumento entero que consiste en el nmero de
octetos a reservar. Si existe espacio suficiente, esta funcin retornar un puntero del tipo void
que puede ser convertido a cualquier tipo de puntero, en caso contrario; es decir, si no hay
espacio suficiente de memoria retorna un puntero NULL.
La funcin free() contiene como nico argumento el puntero de la primera posicin de
memoria reservada y sirve para liberar esta memoria para poder volver a usarla en otra ocasin.
Es importante asegurarse de que se pasa un puntero vlido en esta funcin, ya que de no ser as
podra caer el sistema.
En C++, las caractersticas de asignacin dinmica se han considerado tan importantes que
se han incluido como parte del lenguaje y, los operadores equivalentes a malloc() y free() en C++
son new y delete. Estos dos operadores C++ son prcticamente equivalentes a las funciones
anteriormente tratadas de C. Hay una diferencia a destacar y es que new no necesita el operador
sizeof para calcular la medida en octetos de la memoria a reservar cuando se pone un tipo tras un
new.
Por ejemplo, en el siguiente cdigo, las tres ltimas lneas son equivalentes:
int *p;
p = (*int) malloc(sizeof (int));
p = (*int) malloc(4);
p = new int;
La sentencia new int; retorna ya un puntero a entero y, por tanto, no es necesaria la
conversin, que s es obligatoria si la funcin retorna un puntero *void como es el caso de la
funcin malloc().

1.16. LAS FUNCIONES CALLOC() Y REALLOC().
Adems de la funcin malloc() vista anteriormente, C incorpora otras funciones que
complementan la asignacin dinmica de memoria. Veamos las funciones calloc() y realloc():
La funcin calloc() admite dos argumentos: el nmero y el tamao de cada elemento, y
retorna un puntero void a la primera posicin reservada, o NULL si la peticin no ha sido posible.
En este caso, y a diferencia de malloc(), el espacio se inicializa con seros. La sintaxis de esta
funcin es: void *calloc (int numero_elementos, int tamao);
Como en la funcin malloc(), el puntero retornado por la funcin calloc() es del tipo void y
es necesario hacer una conversin forzada al tipo adecuado.
La funcin realloc() permite ampliar un espacio contigua ya existente, o proporciona una
zona nueva y mayor de espacio contiguo. La funcin tiene dos argumentos: un puntero a la zona
de memoria existente y un nuevo tamao en octetos de la nueva zona reservada. Esta funcin
retorna tambin un puntero void a la zona nueva reservada. Es importante remarcar que el
segundo argumento es el total de octetos que se desea para la zona de memoria, no el nmero de
octetos a ampliar. La sintaxis de la funcin es: void *realloc (void *p, int nuevo_tamao);

2. PRCTICA 1: MINI AGENDA TELEFNICA.
En esta primera prctica repasaremos algunos conceptos de estructuras. Tambin
repasaremos numerosos aspectos tratados en mdulos anteriores.
2.1. DESARROLLO DE LA PRCTICA.
En esta prctica construiremos una pequea agenda telefnica. Antes de comenzar,
debemos remarcar que esta agenda no ser prctica hasta que lleguemos a la parte de archivos.
De qu sirve una agenda en la cual no podemos guardar los datos en el disco? A pesar de este
inconveniente, veremos en el prximo mdulo que almacenar los datos en un archivo supondr
slo pequeas modificaciones a este programa.
Crearemos un nuevo archivo C denominado m7p01.c y se escribir el siguiente cdigo:
I //m7p01.c MINI AGENDA TELEFNICA -

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX 100

struct { //Esta es una variable indefinida.
char nombre[30];
char apellido1[30];
char apellido2[30];
char telefono[9];
}
entrada[MAX]; // //El nombre de la variable es Entrada, que hace
referencia a la estructura.

int puntero=0;
void nueva_entrada(void);
void borra_entrada(void);
void mostrar(void);
void buscar_nombre(void);
void buscar_apellido1(void);
void buscar_telefono(void);
void parada(void);
//Funciones.

void LimpiaBuffer()
{ while(getchar() != '\n'); }

II int main ()
{
char sel;
do{
system("cls");
printf("Mini agenda telefnica. \n\n\n");
printf("1. Introducir nueva entrada.\n");
printf("2. Borrar entrada.\n");
printf("3. Busqueda por nombre.\n");
printf("4. Busqueda por apellido.\n");
printf("5. Busqueda por telefono.\n");
printf("6. Muestra todas las entradas.\n");
printf("7. Salir. \n\n\n");
printf("\n\n Escoja una opcin (ESC para salir)\n ");

do{
sel = getchar();
}
while ((sel<'1' || sel>'7')&&sel!=27);//Si la seleccion est entre
1 y 7 el programa sigue. Si presionamos ESC (el 27 en ASCII) se acaba el
programa.
switch (sel)
{
case'1':
nueva_entrada();
break;
case'2':
borra_entrada();
break;
case'3':
buscar_nombre();
break;
case'4':
buscar_apellido1();
break;
case'5':
buscar_telefono();
break;
case'6':
mostrar();
break;
case'7':
case 27:
return;
}
}
while(1); // Mientras realicemos una seleccin entre 1 y 7, la condicin
ser TRUE 1 y el programa se ejecuta de forma infinita. Si es sea otra
seleccin, la condicin ser FALSE 0 y el programa vuelve al principio.
return 0;
}

III void nueva_entrada(void)
{
if (puntero==MAX)
{
printf("No es posible aadir mas entradas.");
parada();
return;
}

printf("\n Entrada %d.", puntero);
LimpiaBuffer();

printf("\n Nombre? ";
fgets (entrada[puntero].nombre, 30. stdin);
printf ("Apellido 1? ");
fgets(entrada[puntero].apellido1, 30, stdin);
printf("Apellido 2? ");
fgets(entrada[puntero].apellido2, 30, stdin);
printf("Telefono?");
fgets(entrada[puntero].telefono, 9, stdin);

printf("\n Entrada %d almacenada", puntero);
puntero++;
return;
}

IV void borra_entrada(void)
{
int sel, ct;

printf ("Numero de entrada para borrar?\n");
getchar();//Leer o ir al caracter entrado.
scanf("%d", &sel));

if (sel<0 || sel >= puntero)
{
printf("Numero de entrada erroneo");
parada();
return;
}

for (ct=sel+1; ct<puntero; ct++)
{
entrada [ct-1] = entrada[ct]
}
puntero--;
}

V void mostrar(void)
{
int ct;
for (ct=0; ct<punter; ct++)
{
printf("%d: %s %s %s %s\n", ct, entrada[ct].nombre,
entrada[ct].apellido1, entrada[ct].apellido2,
entrada[ct].telefono);
}
parada();
return;
}

VI void buscar_nombre(void)
{
int nencontrados=0,ct;
char ncer[30];

printf("Nombre a buscar?\n");
scanf(" %s", ncer);

for(ct=0; ct<puntero; ct++)
{
if( !strncmp( ncer, entrada[ct].nombre, strlen(ncer)))
{
nencontrados++;
}
}
printf("Se han encontrado %d entradas", nencontrados);
parada();
return;
}

VII void buscar_apellido1(void)
{
char ap1cer[30];

printf("Apellido1 a buscar?\n");
scanf(" %s", ap1cer);

{
if( !strncmp( ap1cer, entrada[ct].apellido1, strlen(ap1cer)))
{
nencontrados++;
}
}
parada();
return;
}

VIII void buscar_telefono(void)
{
char telcer[9];

printf("Telefono a buscar?\n");
scanf(" %s", telcer);

{
if( !strncmp(telcer, entrada[ct].telefono, strlen(telcer)))
{
nencontrados++;
}
}

parada();
return;
}

IX void parada(void)
{
char c;
printf("\n Presiona una tecla para continuar ");
LimpiaBuffer();
c=getc(stdin);
}

2.2. CAPTURA DE LA EJECUCIN DEL PROGRAMA.

2.3. EXPLICACIN DEL PROGRAMA.
Lo primero que se puede observar es que este es el programa ms largo que hemos hecho
hasta ahora. No obstante, ser fcil de entender ya que hay muchas partes parecidas.
Para facilitar la comprensin del programa, se ha dividido este en nueve partes numeradas
con nmeros romanos en la parte izquierda del cdigo.
La primera parte corresponde a las declaraciones iniciales y variables globales. La segunda
parte es la funcin main() que contiene el men principal. El resto de partes corresponden a las
diferentes funciones definidas.
PARTE I.
En este programa se utilizan 4 archivos de cabecera:
stdio.h, para las funciones estndar de entrada y salida (scanf(), printf(), gets(), ).
stdlib.h, para borrar la pantalla con system("clear").
string.h, para las funciones de manipulacin de cadenas de caracteres (strlen(),
strncmp()).
Adems de la declaracin de las seis funciones que utiliza el programa, en esta primera
parte se ha definido una variable entera global: puntero y una estructura global annima con un
vector de esta estructura denominado entrada. Este vector tendr una capacidad de 100
entradas, ms que suficiente en esta versin del programa en la que no se pueden guardar los
datos en el disco.
Los campos de estructura son, los cuatro, cadenas de caracteres. Como con los telfonos no
se realizan clculos numricos, es conveniente almacenarlos en variables de cadena.
La variable puntero nos indicar en cualquier funcin del programa el nmero de datos que
hay en la memoria.
PARTE II.
La funcin main(), en este caso, slo se encarga de hacer la gestin del men.
En este men slo estn las opciones del 1 al 6, adems de la opcin 7 y la tecla de escape,
que sirve para salir del programa.

PARTE III.
La opcin 1 hace que se ejecute la funcin nueva_entrada(). Esta funcin comprueba que el
nmero de entradas no sea superior al tamao del vector de entradas y despus pide la
introduccin de los cuatro campos. Para llenar uno de los campos de una variable estructura se
utiliza el operador punto.
Por ejemplo, para llenar el cmapo nombre se ha hecho:
printf("\n Nombre? ";
fgets (entrada[puntero].nombre, 30. stdin);
PARTE IV.
La opcin 2 hace que se ejecute la funcin borra_entrada(), que pide un nmero de
entrada, comprueba que sea de una entrada existente y la borra. De hecho, lo que hace es
desplazar todas las entradas de nmero ms grande que el nmero introducido en la entrada
anterior. La ltima entrada no se modifica, pero la variable puntero es decrementada en una
unidad y, por tanto, una llamada a la opcin 1 de nueva entrada la sobrescribir.
Es importante destacar que la asignacin de una variable de estructura a otra se puede
hacer globalmente y no campo a campo; es decir: entrada[ct-1]=entrada[ct]);
PARTE V.
La opcin 3 hace que se ejecute la funcin mostrar(). Esta funcin imprime por pantalla
todas las entradas almacenadas. Esto se hace campo a campo con la siguiente sentencia:
PARTES VI, VII y VIII.
Las opciones 4, 5 y 6 sirven para buscar por un campo. Una vez introducido el texto a
buscar, este almacenamiento en la variable de cadena ncer. La comprobacin se hace para todas
las entradas y es la siguiente:
if( !strncmp( ncer, entrada[ct].nombre, strlen(ncer)))
if( !strncmp( ap1cer, entrada[ct].apellido1, strlen(ap1cer)))
if( !strncmp( telcer, entrada[ct].telefono, strlen(telcer)))
La funcin strncmp() ya fue tratada en el mdulo anterior, sirve para comparar un nmero
determinado de caracteres de dos cadenas. En este caso, esta funcin retornar el valor true en el
caso que la variable entrada[ct] comience por el contenido de la variable ncer, ap1cer o telcer, ya
que el nmero de caracteres a comparar coincide con la longitud de la cadena ncer (strlen(ncer)).
Este tipo de bsqueda se denomina bsqueda secuencial por el hecho que se comienza con
el primer registro y se miran secuencialmente todos los registros hasta encontrar el que
queremos. Cuando los registros estn desordenados, este es el mtodo ms fcil y tan eficiente
como cualquier otro. En el caso que los registros estn ordenados hay otros mtodos de
ordenacin que son mucho ms eficaces que una bsqueda secuencial, por ejemplo, la bsqueda
binaria o dicotmica, ambos casos los veremos en el mdulo 8.
PARTE IX.
Hay momentos en la ejecucin del programa que habr que detenerlo para poder
comprobar el resultado. Para no repetir muchas veces las mismas rdenes, las ponemos en una
funcin y tan slo nos queda llamarla.

3. PRCTICA 2: PUNTEROS A ESTRUCTURAS.
El lenguaje C permite la declaracin de punteros a estructuras de la misma manera que lo
permite en cualquier otro tipo de variable. En esta prctica veremos cmo se declaran y se
utilizan estos punteros.
Crearemos un nuevo archivo C denominado m7p02.cc con el siguiente cdigo:
// m7p02.c - PUNTEROS A ESTRUCTURAS -

#include <stdio.h>
#define MAXTIT 40
#define MAXAUT 30
#define MAXEDI 30

struct biblio
{
char titulo [MAXTIT];
char autor [MAXAUT];
char editorial [MAXEDI];
float precio;
};
/* Fin del patrn */

int main()
{
struct biblio libro =
{
"EL LENGUAJE DE PROGRAMACION C",
"Brian W. Kernighan",
"Prentice Hall", 3580
};

struct biblio *puntero_libro;
puntero_libro = &libro;

printf("\n Las caracteristicas del libro son: \n");
printf("\n %s per %s : %.2f pts. \n", libro.titulo,
libro.autor, libro.precio);

printf("\n %s por %s : %.2f pts. \n",
(*puntero_libro).titulo,(*puntero_libro).autor,
(*puntero_libro).precio);

printf("\n %s por %s : %.2f pts. \n\n",
puntero_libro->titulo, puntero_libro->autor,
puntero_libro->precio);

return 0;
}


La declaracin de punteros en estructuras se hace de la forma habitual, anteponiendo el
carcter '*' al identificador del puntero: struct biblio *puntero_libro;
A esta variable se le asigna como valor inicial la direccin de la variable de estructura libro:
puntero_libro = &libro;
En este momento tenemos tres formas de referirnos a los campos de la estructura:
1) Directamente con la variable de estructura libro y el operador punto (.):
printf("\n %s per %s : %.2f pts. \n", libro.titulo,
libro.autor, libro.precio);
2) Con el puntero puntero_libro y con operador habitual de indireccin *:
printf("\n %s por %s : %.2f pts. \n",
(*puntero_libro).titulo,(*puntero_libro).autor,
(*puntero_libro).precio);
3) Con el puntero puntero_libro y con el operador flecha(->):
printf("\n %s por %s : %.2f pts. \n\n",
puntero_libro->titulo, puntero_libro->autor,
puntero_libro->precio);
El operador (.) conecta una estructura con un miembro de la estructura: el operador (->)
conecta un puntero con un miembro de la estructura.

4. PRCTICA 3: OBTENCIN DEL DA Y LA HORA DEL S.O.
En esta prctica aprenderemos a manipular estructuras, enumerados y algunas aplicaciones
para obtener y manipular tiempo.
Crearemos un nuevo archivo del tipo C++ denominado m7p03.cc con el siguiente cdigo:
//m7p03.cc - Obtencin del da y la hora del Sistema Operativo -

#include <stdio.h>
#include <time.h>

enum emes {enero, febrero, marzo, abril, mayo, junio, julio, agosto,
septiembre, octubre, noviembre, diciembre};

struct instante
{
int ao;
enum emes mes;
int dia;
int hora;
int minuto;
int segundo;
};

int dias_mes[12]={31,28,31,30,31,30,31,31,30,31,30,31};
int dias_ao[4]={366,365,365,365};
char *nombre_mes[12]=
{"enero", "febrero", "marzo", "abril", "mayo", "junio", "julio",
"agosto", "septiembre", "octubre", "noviembre", "diciembre"};

int main()
{
int t;
instante ahora={1970,enero,1,0,0,0};
t=time(NULL);

while (t-dias_ao[ahora.ao%4]*24*3600>0)
{
t=t-dias_ao[ahora.ao%4]*24*3600;
ahora.ao++;
}

while (t-24*3600*dias_mes[ahora.mes]>0)
{
t=t-24*3600*dias_mes[ahora.mes];
if(!(ahora.ao%4)&& ahora.mes==febrero)t=t-24*3600;
ahora.mes=emes(ahora.mes+1);
}

while (t-24*3600>0)
{
ahora.dia++;
t=t-24*3600;
}

while (t-3600>0)
{
ahora.hora++;
t=t-3600;
}

ahora.hora=ahora.hora+2;
/* Franja horaria Espaa=GMT+1, en verano es GMT+2. */

while(t-60>0)
{
ahora.minuto++;
t=t-60;
}

ahora.segundo=t;

printf("Ao:%d, Mes:%s, Dia:%d, Hora:%d, Minuto:%d, Segundo:%d\n",
ahora.ao, nombre_mes[ahora.mes], ahora.dia, ahora.hora, ahora.minuto,
ahora.segundo);

return 0;
}

Una de las funciones importantes de la librera estndar de C/C++ es la funcin time(), el
protocolo de la cual se encuentra en time.h, que retorna el nmero de segundos que han
transcurrido desde las 00horas del 1 de enero de 1970. Esta informacin puede obtenerse de dos
formas:
directamente con el valor de retorno de la funcin;
pasando a esta funcin un puntero long int. Esta funcin pone en la direccin apuntada
por este puntero el nmero de segundos antes mencionado.
En el programa m7p031.cpp se utiliza la primera de las formas, en este caso, se pasa como
argumento un puntero NULL:
int t;
. . . . .
t=time(NULL);
A partir de la informacin obtenida de la funcin time(), el programa obtendr el ao, el
mes, el da, la hora, el minuto y el segundo. Por eso se ha definido una estructura denominada
instante. Esta estructura consta de seis campos denominados: ao, mes, da, hora, minuto y
segundo.
Todos son enteros menos el campo mes, que se ha definido como del tipo enum emes, que
es un tipo enumerado definido anteriormente. Una variable del tipo emes (o enum emes) slo
puede tomar un valor de los 12 posibles (enero, febrero,)

Ya dentro de la funcin main(), se declara una variable de estructura denominada ahora, la
cual tiene la estructura instante. No debe confundir estructura con variable estructura, aunque a
veces se utilice la primera palabra para referirse a la segunda expresin.
En la declaracin de esta variable ahora se hace la inicializacin:
instante ahora={1970,enero,1,0,0,0};
La inicializacin se hace de la misma forma que con los vectores, es decir, poniendo a
continuacin del nombre de la variable la lista de los valores separados entre comas y todos ellos
cerrados entre llaves.
En ANSI C, esta declaracin debera comenzar por la palabra struct. En C++, no es necesario
poner esta palabra en las declaraciones de variables de estructura (aunque no es incorrecto
ponerla).
Los valores iniciales de la variable ahora corresponden a las 00horas, 00minutos y
00segundos del da 1 de enero de 1970.
Los diferentes campos de esta variable estructura se referencian con el operador punto (.),
por ejemplo, ahora.ao, ahora.mes,
Con el valor de t, encontraremos el ao. Esto se hace restando a t los segundos que tienen
respectivamente los aos 1970, 1971, y sumando al campo ao de la variable ahora, 1 por cada
ao entero que restemos. Esto se hace con estas lneas:
int dias_ao[4]={366,365,365,365};
. . . . . . . . . . . .
while (t-dias_ao[ahora.ao%4]*24*3600>0)
{
t=t-dias_ao[ahora.ao%4]*24*3600;
ahora.ao++
}
La condicin de la sentencia while: t-dias_ao[ahora.ao%4]*24*3600>0 comprueba que
en la variable t hay suficientes segundos para quitarle un ao, si el ao es bisiesto, ahora.ao%4
es igual a 0 y das_ao[ahora.ao%4]=366, por tanto, quitaremos 366243600 segundos que
tiene un ao bisiesto.
Si el ao no es bisiesto, ahora.ao%4 ser igual a 1, 2 3 y das_ao[ahora.ao%4]=365,
por tanto, quitaremos 365243600 segundos. Este bucle se repite hasta que el nmero de
segundos no llegue a un ao.
El siguiente bucle calcula el mes de la misma forma. Quita los das correspondientes a cada
mes hasta que el nmero de segundos no llegue a un mes, y as sucesivamente. En el caso de los
meses, si estamos en un ao bisiesto y en el mes de febrero, se quita un da ms.
Respecto al clculo de la hora hay que aadir un comentario: la hora retornada por la
funcin time() es la hora GMT (Greenwich Mean Time). En Espaa se debe sumar 1 2 horas
segn sea horario de invierno o de verano, respectivamente.
La impresin del resultado se hace con la funcin printf(). Es importante notar que las
variables de enumeracin como ahora.mes son consideradas variables enteras. Por defecto, si no
se indica lo contrario, el primer valor (enero) corresponde a 0, el segundo valor (febrero) a 1, y as
respectivamente.

5. PRCTICA 4: MANIPULACIN DE TIEMPOS.
LA ESTRUCTURA tm DE LA LIBRERA ESTNDAR.
En esta prctica aprenderemos a usar una estructura ya definida en la librera estndar C /
C++, conoceremos una funcin que devuelve un puntero a una estructura y aprenderemos a
referenciar valores apuntados por punteros a estructuras.
El programa calcular el nmero de lneas, palabras y caracteres que se introduzcan por el
teclado e imprimir los resultados para la salida estndar (pantalla). Para detectar lneas debe
buscar el carcter fin de lnea '\n'. Para detectar palabras se define una variable Estado que
recuerda si estaba leyendo una palabra cuando encuentra un espacio en blanco, un fin de lnea o
un tabulador ('\t').
Crearemos un nuevo archivo C denominado m6p04.c con el siguiente cdigo:
//m7p04.c - MANIPULACIN DE TIEMPOS. -

#include <time.h>
#include <stdio.h>

int main( void )
{
long tiempos;
struct tm *st;
char *mes[]={"enero", "febrero", "marzo", "abril", "mayo", "junio",
"julio", "agosto", "septiembre", "octubre", "noviembre", "diciembre"};

char *dia_semana[]={"domingo", "lunes", "martes", "miercoles",
"jueves", "viernes", "sabado"};

time( &tiempos);

printf( "Fecha y hora: %s \n", ctime(&tiempos) );

st=localtime(&tiempos);

printf("\n Contenido de (tm_year): %d",st->tm_year);
printf("\t Corresponde al ao %d\n", 1900+st->tm_year);

printf("\n Contenido de (tm_mon) : %d",st->tm_mon);
printf("\t Corresponde al mes %s\n", mes[st->tm_mon]);

printf("\n Contenido de (tm_mday) : %d\n",st->tm_mday);

printf("\n Contenido de (tm_wday) : %d",st->tm_wday);
printf("\t Corresponde al dia %s\n", dia_set[st->tm_wday]);

printf("\n Contenido de (tm_hour) : %d",st->tm_hour);
printf("\n Contenido de (tm_min) : %d",st->tm_min);
printf("\n Contenido de (tm_sec) : %d\n",st->tm_sec);

return 0;
}


En este programa se declara una variable puntero a una estructura tm. La estructura tm
est definida en el archivo de cabecera time.h de la forma que se muestra a continuacin. Si
recuperar ese archivo y busque la definicin de la estructura encontrar este cdigo:
*time.h - definitions/declarations for time routines
struct tm {
int tm_sec; /* seconds after the minute - [0,59] */
int tm_min; /* minutes after the hour - [0,59] */
int tm_hour; /* hours since midnight - [0,23] */
int tm_mday; /* day of the month - [1,31] */
int tm_mon; /* months since January - [0,11] */
int tm_year; /* years since 1900 */
int tm_wday; /* days since Sunday - [0,6] */
int tm_yday; /* days since January 1 - [0,365] */
int tm_isdst; /* daylight savings time flag */
};
Esta estructura tiene 9 campos, todos ellos enteros. Los comentarios del cdigo, aunque
estn en ingls, son suficientemente esclarecedores. Slo comentar que los meses del ao
comienzan en 0 (enero), y terminan en 11 (diciembre), y los das de la semana comienzan en 0
(domingo) y terminan en 6 (sbado).
Comentaremos tambin que:
el campo tm_yday es el dia del ao comenzando en 0 (1 de enero).
el campo tm_isdst es una variable que devuelve 1 si se quiere que se tenga en cuenta el
cambio de horario de verano o 0 si no se quiere.
En este programa, la funcin time() se utiliza de forma diferente al programa anterior. La
sentencia: time( &tiempos); hace que en la variable tiempos se almacene el nmero de
segundos desde las 00:00:00 del 1 de enero de 1970.
Esta lnea sera equivalente a: tiempos = time(NULL);
La funcin ctime() de la sentencia: printf( "Fecha y hora: %s\n", ctime(
&tiempos ) ); tiene como argumento un puntero a una variable long que contiene un nmero
de segundos y devuelve una cadena de caracteres con la fecha y hora.
La funcin localtime() de la sentencia: st=localtime(&tiempos); tiene como
argumento una variable long que contiene un nmero de segundos y vuelve un puntero a una
estructura tm. Los diferentes campos de la variable estructura apuntado por el puntero st se
referencia con el operador flecha (->).

6. PRCTICA 5: OBTENCIN DEL DA DE LA SEMANA DE UNA FECHA
DETERMINADA.
En esta prctica que completa las dos anteriores aprenderemos a realizar operaciones con
fechas y horas.
La funcin mktime() convierte la estructura, el puntero de la cual se pasa como argumento,
a una estructura completa con valores normales. Adems, esta funcin devuelve un valor long int
correspondiente a la fecha y hora con el mismo tipo que el valor de retorno de la funcin time().
Los valores de los campos tm_wday y tm_yday de la variable de estructura original son
ignorados, todos los dems campos son obligatorios y los valores de estos otros campos pueden
ser de valor superior al rango permitido, es decir, es posible que el campo tm_hour sea igual a 30.
en este caso, la funcin mktime () ajusta los valores de los campos para que queden dentro del
rango permitido.
Esta funcin es muy til si se quiere hacer operaciones con fechas y horas. Este programa
pedir una fecha determinada y muestra el da de la semana correspondiente.
Crearemos un nuevo archivo del tipo C++ denominado m7p05.c con el siguiente cdigo:
/*m7p05.cc - OBTENCIN DEL DIA DE LA SEMANA DE UNA FECHA DETERMINADA - */

#include <time.h>
#include <stdio.h>

int main(void)
{
struct tm st;
long tiempo;
char *dia_semana[]={"domingo", "lunes", "martes",
"miercoles", "jueves", "viernes", "sabado"};

printf("\n Introduzca la fecha en formato dd/mm/aaaa: ");
tiempo=time(NULL);
st=*localtime(&tiempo);
scanf("%d/%d/%d",&st.tm_mday, &st.tm_mon, &st.tm_year);

st.tm_year=st.tm_year-1900;
st.tm_mon--;

if( (mktime(&st)) != -1 ) // El condicional != significa es diferente.
printf("\n El dia %d/%d/%d s %s\n",st.tm_mday,
st.tm_mon+1, st.tm_year+1900, dia_set[st.tm_wday]);

else printf("\n La funcion mktime ha fallado.\n");

return 0;
}


En este programa se declara una variable de estructura tm denominada st a la cual se
asigna inicialmente la hora actual con la ltima de estas cuatro lneas:
struct tm st;
long temps;
..............
temps=time(NULL);
st=*localtime(&temps);
................
La funcin localtime () tiene como argumento un puntero a una variable long int y devuelve
un puntero a una estructura tm.
Con la siguiente lnea se pide al usuario tres datos: el da, el mes y el ao, estos tres datos
sern almacenados en los tres campos correspondientes de la variable de estructura st.
scanf("%d/%d/%d",&st.tm_mday, &st.tm_mon, &st.tm_year);
Para adaptar los datos que necesita esta variable se hacen los siguientes ajustes:
st.tm_year=st.tm_year-1900;
st.tm_mon--;
El primero de los ajustes se debe a que el campo tm_year almacena en empezando a contar
en el ao 1900 y el segundo de los ajustes se debe a que en el primer mes (enero) se le asigna el
nmero 0 en lugar del 1.
El clculo del da de la semana se hace con la funcin mktime () de esta forma:
if( (mktime( &st)) != -1 )
printf("\n El dia %d/%d/%d s %s\n",st.tm_mday,
st.tm_mon+1, st.tm_year+1900, dia_set[st.tm_wday]);

else printf("\n La funcion mktime ha fallado.\n");
Si la funcin devuelve el valor -1 indica que no ha podido completar la estructura. Puede ser
debido a que hemos entrado una fecha anterior a 1970.

7. PRCTICA 6: SUMA Y PRODUCTO DE NMEROS COMPLEJOS.
En esta prctica veremos las dos formas de pasar parmetros de estructura a una funcin:
por valor y por referencia.
Los nmeros complejos son una aplicacin comn de las variables estructura. Los nmeros
complejos pertenecen a los conocimientos que muchos de nosotros hemos adquirido en la
enseanza secundaria. En este conjunto, las operaciones aritmticas: suma, resta, producto y
divisin se pueden definir trivialmente a partir de las operaciones aritmticas de nmeros reales.
Un nmero complejo es un par ordenado de nmeros reales (a, b) - habitualmente se
escribe a + bi- . Donde a recibe el nombre de parte real , y b el nombre de parte imaginaria. Si
tenemos dos nmeros complejos: a + bi y c + di, la suma se define como otro nmero complejo,
en el que la parte real es la suma de las partes reales y su parte imaginaria es la suma de las
partes imaginarias; es decir: a + bi + c + di = (a + c) + (b + d) i
El producto de nmeros complejos es un poco ms sofisticado. Se define de la siguiente
forma: (a + bi) * (c + di) = (a * c - b * d) + (a * d + b * c) i
En esta prctica construiremos dos funciones que nos permita hacer estas dos operaciones
con nmeros complejos, en un archivo en C++ denominado m7p06.c con el siguiente cdigo:
//m7p06.cc - SUMA DE NMEROS COMPLEJOS -

#include <stdio.h>
struct complejo
{
int re, im;
};

void impr(complejo);
void suma(complejo, complejo, complejo *);
void producto(complejo, complejo, complejo *);

int main()
{
complex z1,z2,zr;
printf("Introduzca los operadores.\n");
printf("Para introducir un numero complejo\n");
printf("con parte imaginaria negativa poner a+-bi...\n");

printf("Introduzca z1 (formato x+yi):...");
scanf("%d+%di", &z1.re, &z1.im);

printf("Introduzca z2 (formato x+yi):...");
scanf("%d+%di",&z2.re, &z2.im);

suma (z1, z2, &zr);
impr(z1);printf("+ "); impr(z2);printf("= ");
impr(zr);printf("\n");

producto (z1, z2, &zr);
impr(z1);printf("* "); impr(z2);printf("= ");
impr(zr);printf("\n");

return 0;
}


void impr(complejo a)
{
printf("%d+%di ", a.re, a.im);
}

void suma (complejo a, complejo b, complejo *c)
{
c->re=a.re+b.re;
c->im=a.im+b.im;
}

void producto (complejo a, complejo b, complejo *c)
{
c->re=a.re*b.re-a.im*b.im;
c->im=a.im*b.re+a.re*b.im;
}

En este programa se define la estructura complex con dos campos enteros denominados re
e im. Estos dos campos correspondern a la parte real y a la parte imaginaria del nmero
complejo. El usuario introducir las partes real e imaginaria de las dos variables complejas z1 y z2.
El formato para introducir los datos es: numero entero + numero entero i
Este programa no permite la versin simplificada de no escribir la parte imaginaria cuando
esta vale 1, adems, el signo + es obligatorio, aunque la parte imaginaria sea negativa. En este
caso se escribirn juntos los signos + y -. Ejemplo 2+-3i.
En este programa se utilizan dos funciones: impr() y suma(). La primera de estas funciones
admite un nico argumento que es una variable de estructura complex. Este parmetro se pasa
por valor. La funcin hace una copia de todos los campos de la variable y no puede modificar las
iniciales.
Las funciones suma() y producto() tienen tres argumentos, los dos primeros se pasan por
valor y el tercero se pasa por referencia. Esto ltimo es necesario ya que las funciones modifican
este tercer argumento. Tenga en cuenta que la llamada a estas funciones se hace: suma (z1, z2, &
zr) y producto (z1, z2, & zr), es decir, anteponiendo el operador & delante del nombre de la
variable de estructura compleja zr.

8. PRCTICA 7: USO TPICO DE LAS UNIONES.
En esta prctica veremos dos de los usos ms corrientes de las uniones.
8.1. DESARROLLO DE LA PRCTICA 7.1.
Si tenemos estructuras con campos del mismo tipo, muchas veces nos puede interesar
referirnos a estos campos como si fuesen un vector. En este caso, las uniones pueden ser muy
tiles.
Crearemos un nuevo archivo del tipo C++ denominado m7p07.1.cc con el siguiente cdigo:
//m7p07.1.cc - INTRODUCCIN DE NOTAS -

#include <stdio.h>

struct Notas
{
int Mat, Fis, Inf, Qui, Fil;
};

union Alumno
{
struct Notas N;
int Nota[5];
} ;

int main()
{
int ct;
Alumno Joan;

Joan.N.Mat=10;
Joan.N.Fis=9;
Joan.N.Inf=7;
Joan.N.Qui=9;
Joan.N.Fil=10;

printf("\n Mat\t Fis\t Inf\t Qui\t Fil\n");
for(ct=0; ct<5; ct++)
printf("%d\t",Joan.Nota[ct]);

return 0;
}
8.1.1. CAPTURA DE LA EJECUCIN DEL PROGRAMA 7.1.

8.1.2. EXPLICACIN DEL PROGRAMA 7.1.
Una de las ventajas de las variables de estructura es que el nombre de campo puede
identificar de alguna forma su contenido. En el programa anterior, la variable Joan.N.Mat
contiene la nota de matemticas del alumno Joan.

Sin embargo, en muchas ocasiones es ms conveniente que todos los campos de una
misma variable de estructura (en el caso de que sean del mismo tipo) se puedan referenciar
mediante un ndice. Esto se ha conseguido en este programa con una variable de unin.
Joan es una variable del tipo unin alumno, que contiene asimismo una variable de
estructura y un vector. Ambos tipos son un conjunto de 5 enteros que comparten el mismo
espacio de memoria. La variable Joan tiene un total de 54 = 20 octetos.
El contenido del primero de los enteros de esta variable se puede acceder con
Joan.N.Mat o bien con Joan.Nota [0] segn interese.
Para calcular, por ejemplo, la nota media es ms conveniente la segunda notacin:
for (media=0,ct=0;ct<5;ct++) media=media+Joan.Nota[ct];
media=media/5;
Una segunda aplicacin comn de las variables de unin es pasar a una funcin un tipo
indefinido, por ejemplo, en este programa, la misma funcin de impresin se puede usar para
imprimir enteros, nmeros reales o cadenas de caracteres.
Esta es una alternativa al programa de la prctica 3 del mdulo 5 que usaba para este
propsito los punteros tipo void.
//m7p07.2.cc - FUNCIN DE ARGUMENTO DE TIPO INDEFINIDO -

#include <stdio.h>
#include <string.h>

union Nombre
{
int i;
float f;
double d;
char cad[12];
};

void impr(Nombre a, char c);

int main()
{
union Nombre a;

a.i=23;
impr(a,'i');

a.f=5.25;
impr(a,'f');

a.d=6.25E256;
impr(a,'d');

strcpy(a.cad,"Lenguaje");
impr(a,'s');

return 0;
}

void impr(Nombre a, char c)
{
switch (c)
{
case 'i':
printf("a=%d\n",a.i);
break;
case 'f':
printf("a=%f\n",a.f);
break;
case 'd':
printf("%g\n",a.d);
break;
case 's':
printf("a=%s\n",a.cad);
}
}

Este programa define la funcin de impr con dos argumentos, uno del tipo union
nmero y otro del tipo char. Segn el valor de este ltimo parmetro, la funcin sabe de
qu tipo es la variable a pasada. Segn este tipo, la funcin imprime su valor.

9. PRCTICA 8: FUNCIN MEDIA.
En esta prctica implementaremos una funcin con un nmero indefinido de parmetros.
Veremos en este programa una funcin donde el nmero de argumentos puede ser un
nmero variable. Se trata de la funcin media () que calcular la media de un nmero no
determinado de nmeros del tipo double.
Crearemos un nuevo archivo de tipo C++ denominado m7p08.c con el siguiente cdigo:
//m7p08.c - FUNCIN MEDIA. -

#include <stdio.h>
#include <stdarg.h>

double Media(int n, ...);

int main()
{
printf("Media(1) =%f\n", Media(1,1.));
printf("Media(1,2) =%f\n", Media(2,1.,2.));
printf("Media(1,2,3) =%f\n", Media(3,1.,2.,3.));

return 0;
}

double Media(int n, ...)
{
int ct;
double Med=0.;
va_list p;
va_start(p,n);

for(ct=0; ct<n; ct++)
{
Med=Med+va_arg(p, double);
}

va_end(p);
return Med/n;
}

Para declarar una funcin con un nmero indefinido de argumentos se utilizan los tres
puntos ().
La funcin: double media(int n, ) tendr un parmetro obligatorio del tipo int y despus
un nmero no definido de parmetros (en este caso, el primero de los parmetros se interpreta
como el nmero de parmetros que le siguen).
Para tratar las funciones con un nmero indefinido de parmetros es conveniente usar el
tipo va_list y las macros va_start, va_arg y va_end. Estos tipos y macros tienen su definicin en el
archivo de cabecera stdarg.h.
Al comienzo de la funcin se declara una variable del tipo va_list (este tipo es, de hecho, un
puntero): va_list p;
A continuacin se llama a la macro va_start para inicializar la variable p: va_start(p,n);
El segundo argumento de esta variable es el nombre del ltimo parmetro obligatorio antes
de la lista de los otros parmetros.
Cada uno de los valores de la resta de argumentos se referencia con la macro va_arg():
Med=Med+va_arg(p, double);
Esta macro tiene dos argumentos, el puntero p (variable del tipo va_list iniciada con
va_star ()) y el tipo de argumento que debe leer. Esta macro devuelve el valor del siguiente
parmetro y actualiza el puntero p.
Antes de salir de la funcin se llama a va_end () para restituir la pila.

10. PRCTICA 9: ARGUMENTOS DE LA FUNCIN MAIN().
En esta prctica veremos dos ejemplos de aplicacin de los argumentos de la funcin
main().
Cuando se quiere especificar opciones o valores en el momento de ejecutar un programa
desde la lnea de comandos del sistema operativo, stos se pasan a travs de los argumentos de la
funcin main(). La funcin main() puede tener dos argumentos:
El primero, de tipo int, contendr el nmero total de parmetros pasados (el nombre del
archivo ejecutable se cuenta como el primer parmetro).
El segundo es un vector de cadenas de caracteres.
En este primer ejemplo se puede ver fcilmente la forma de extraer estos parmetros:
//m7p091.cc - ARGUMENTOS DE LA FUNCIN MAIN() (I) -

#include <stdio.h>

int main (int argc, char *argv[])
{
int ct;

printf("El numero total de argumentos es %d\n", argc);

for(ct=0; ct<argc; ct++)
printf("El argumento %d es %s\n", ct, argv[ct]);

return 0;
}
En este programa se considerar los parmetros pasados desde la lnea de rdenes,
por este motivo la funcin main() comienza: int main (int argc, char *argv[])
La variable argc contendr el nmero total de parmetros, incluyendo el nmero del
archivo ejecutable, cada parmetro se pasa como cadena de caracteres y se puede
recuperar con arg[].

En el caso que sea necesario pasar parmetros numricos, debe hacerse una conversin. En
el siguiente ejemplo puede verse con nmeros del tipo double.
//m7p092.cc - ARGUMENTOS DE LA FUNCIN MAIN() (II) -

#include <stdio.h>
#include <stdlib.h>

int main (int argc, char *argv[])
{
int ct;
double media=0;

if (argc==1) return;

for(ct=0; ct<argc; ct++) media=media+atof(argv[ct]);
printf("Media de les %d datos :%lf", argc-1, media/(argc-1));

return 0;
}
Este programa calcular la media de los nmeros introducidos tras el nombre del
archivo ejecutable.
La conversin de la cadena a variables del tipo doubl se realiza con la funcin atof(),
el protocolo del cual se encuentra definido en el archivo stdlib.h. Esta funcin intenta
convertir la cadena a doubl y, si no puede, retorna un 0. Por ejemplo:
atof("1.2")=1.2
atof("1.2hola")=1.2
atof("hola1.2")=0
Con el nmero de parmetros numricos es igual a argc-1, para calcular la media se
debe dividir por este nmero. En el caso que argc-1 sea 0, el programa saldr
inmediatamente gracias a la lnea de comprobacin: if (argc==1) return;

11. PRCTICA AMPLIACIN 1: CONSTRUCCIN DE UNA MATRIZ
DINMICAMENTE.
En esta prctica aprenderemos a construir una matriz bidimensional sin reservar memoria
en tiempo de compilacin; es decir, dinmicamente.
Crearemos un nuevo archivo del tipo C++ denominado m7pa01.cc con el siguiente cdigo:
//m7pa01.cc - CONSTRUCCIN DE UNA MATRIZ DINMICAMENTE -

#include <stdio.h>
#include <stdlib.h>

int main(){
int i,j,n;
double *a;

printf("\n Introducir la dimension de la matriz: \n");
scanf("%d", &n);

a=(double*)calloc(n*n, sizeof(double));
//Alternativa1: a=(double*)malloc(n*n*sizeof(double));
//Alternativa2: a=new double[n*n];

//Lectura de los elementos de la matriz.
for (i=0; i<n; i++)
{
for (j=0; j<n; j++)
{
printf("a(%d,%d)= ", i+1,j+1);
scanf("%lf", a+i*n+j);
}
}

//Escritura de los elements de la matriz.
for (i=0; i<n; i++)
{
for (j=0; j<n; j++)
{
printf("a(%d,%d)= %lf\n", i+1, j+1,*(a+i*n+j));

}
}

free (a);
//Si se ha utilizado la Alternativa2: delete(a);

return 0;
}


En este programa, la dimensin de la matriz y, por tanto, el espacio de memoria necesario
para almacenarla no se sabe hasta que se ejecuta el programa y se introduce el valor de la
variable n.
La asignacin de memoria se puede hacer de varias formas. En este programa se utiliza una
de estas formas, pero explicaremos dos alternativas ms.
Primera alternativa: funcin calloc(): a=(double*)calloc(n*n, sizeof(double));
Esta funcin necesita dos argumentos, el nmero de datos y el nmero de octetos de cada
dato. En este caso reservamos espacio para nn datos de 8 octetos. Esta funcin devuelve un
puntero void en la primera posicin de memoria reservada, es por tanto necesario hacer una
conversin anteponiendo (double *) al nombre de la funcin. Tenga en cuenta que la variable a se
ha declarado como un puntero a double.
El protocolo de la funcin calloc () se encuentra en el archivo de cabecera stdlib.h.
Segunda alternativa: funcin malloc(): a=(double*)malloc(n*n*sizeof(double));
Esta funcin necesita slo un argumento, el nmero de octetos total a reservar. Adems, no
hace ningn tipo de inicializacin como la funcin anterior. Esta funcin tambin devuelve un
puntero void que debe convertido como la funcin anterior. El protocolo de esta funcin se
encuentra tambin en el archivo de cabecera stdlib.h.
Tercera alternativa: el operador de C++ new: a=new double[n*n];
Este operador es propio de C++ y no pertenece al estndar ANSI C. De hecho, junto con el
operador delete forma parte de las palabras reservadas C++ y no necesitan ningn archivo de
cabecera para poder usarlas.
Este operador tiene una doble ventaja respecto al operador malloc(), por una parte, no es
necesario hacer uso del operador sizeof() para calcular el nmero de octetos y , por otra parte ,
no es necesario ningn conversin ya que este operador ya vuelve un puntero al tipo especificado
a la derecha del operando.

Es una buena prctica liberar la memoria reservada cuando sta no se utilice ms. Si se ha
reservado la memoria con calloc() o malloc() esto se logra con la funcin free(). Esta funcin
necesita como argumento un puntero a la primera posicin de memoria reservada. Si se ha
reservado la memoria con new la liberacin se hace con el operador delete.
Cuando las funciones malloc() o calloc() o el operador new no pueden reservar la memoria
por falta de espacio , devuelven un puntero NULL, es por tanto, una buena prctica comprobar el
puntero devuelto por estas funciones u operador para evitar errores.
En este programa los nn datos se interpretan como los elementos de una matriz cuadrada
de orden n. Para referirnos al elemento i, j se usa la expresin: *(a+i*n+j) . i y j van de 0 a (n-1).

12. PRCTICA AMPLIACIN 1: REASIGNACIN DE MEMORIA.
En esta prctica veremos el uso de la funcin realloc().
En la prctica anterior slo era necesario una llamada a la funcin calloc() o malloc() de
reserva de memoria, ya que cuando se introduce el nmero n ya se sabe toda la memoria
necesaria.
En muchas situaciones se debe comenzar a almacenar datos antes de saber cuntos datos
se almacenarn en este caso no se puede reservar toda la memoria a la vez, sino que se debe
reservar slo espacio para un dato cada vez que se necesita. Para poder referirse a todos los datos
con un vector es necesario que todos los datos se encuentren en una posicin contigua, esto se
consigue con la funcin realloc().
Crearemos un nuevo archivo del tipo C++ denominado m7pa02.cc con el siguiente cdigo:
//m7pa02.cc - REASIGNACIN DE MEMORIA -

#include<stdio.h>
#include<stdlib.h>

int main(){
int dato, n=0, ct;
int *a;

a=(int *) malloc(sizeof(int));

printf("\n Introducir nmeros enteros. La introduccion de -1\n");
printf("acabara con la entrada de datos...\n");

do
{
scanf("%d",&dada);
a=(int*)realloc(a,(n+2)*sizeof(int));
a[n]=dato;
n++;
}
while(dato!=-1);

printf("\n Se han introducido %d numeros \n",n);
for(ct=0; ct<n; ct++) printf("%d\t",a[ct]);

return 0;
}

Este programa guardar en memoria todos los nmeros enteros introducidos por el teclado
hasta que se introduzca el nmero -1. Entonces nos indicar el nmero de nmeros introducidos y
los volver a imprimir todos.
Se comienza reservando espacio para una variable entera (menos debe introducir un dato):
int *a;
a=(int *) malloc(sizeof(int));

La variable a se declara como un puntero a un entero. La segunda lnea corresponde a la
inicializacin del puntero.
La asignacin de espacio para cada nuevo dato se hace en la lnea marcada del siguiente
bucle:
do
{
scanf("%d",&dada);
a=(int *)realloc(a,(n+2)*sizeof(int));
a[n]=dato;
n++;
}
while(dato!=-1);
La funcin realloc() reserva espacio de memoria contigua para almacenar todos los
nmeros que ya estaban almacenados ms 1. El puntero a apuntar ahora a esta nueva zona.
Este bucle se ejecuta hasta que se introduce un -1, entonces imprime el nmero total de
nmeros introducidos (contando el -1) y la lista de todos los nmeros.

13. EJERCICIOS.
1) Base de datos de pelculas.
Siguiendo el mismo esquema del programa de la prctica 1, se crear una base de datos de
pelculas. Se definir una estructura annima y un vector asociado a esta estructura con el
nombre Entrada. Los campos sern:
struct
{
char Titulo[50];
char Director[50];
char Protagonista[50];
char Duracion;
}
Entrada[MAX];
El programa debe permitir hacer nuevas entradas, borrarlas, mostrarlas y realizar
bsquedas por ttulo, director y protagonista.
Denominaremos al programa m7e1.cc dentro de la carpeta Mdulo_7.
2) Suma de datos.
Con la ayuda de la funcin mktime(), tratada en la prctica 5, se har un programa que
utilice una funcin que sume a una fecha y hora determinada un nmero de segundos. El
protocolo de la funcin deber ser: void Suma_tiempos (tm *Fecha, long Segundos);
Es decir, la funcin tendr dos argumentos, un puntero a una variable de estructura tm y
una variable entera. La funcin modificar el valor de la variable apuntada por Fecha de forma
que la nueva variable corresponda a la suma de estos segundos a la fecha. Por ejemplo, si Fecha
apunta a:
18:01:20 1 de enero de 2001, y sumamos 100.000segundos tendremos la nueva fecha y
hora: 21:48:00 2 de enero de 2001.
Tendremos en cuenta que podemos sumar los segundos directamente en el campo tm_sec
y, aunque se supere el valor mximo de 59, la llamada a la funcin mktime() reajustar el
contenido de los campos para mostrar la fecha y hora correcta.
3) Ms estructuras.
Se pide disear una estructura para almacenar los siguientes datos:
- Nombre de la mquina (un mximo de 20 caracteres);
- Horas;
- Minutos;
- Segundos;
- Fecha (con formato DD-MM-AA);
- Servicio facturado (s/n).
La ejecucin del programa nos permitir escoger entre tres opciones. Una primera para
introducir los datos correspondientes a una estructura, una segunda para listar los registros que
pertenecen a una mquina en concreto y una tercera para salir:
1 - Aadir estructuras alumnos.
2 - Listado de una mquina.
3 - Salir.

Si por ejemplo los datos almacenados son:

Y se pide el consumo de la mquina A-18, el programa mostrar un listado como el
siguiente:
Factura de consumo de la mquina A-18:
Mquina Horas Minutos Segundos Da Mes Ao Facturado

El precio es el resultado de multiplicar los minutos (o fraccin) por 1 cntimo de euro.

4) Argumentos en la funcin main().
Utilizando las ideas de la prctica 9, construiremos una aplicacin que se pueda llamar
desde la lnea de comandos de MS-DOS con tres parmetros: un nmero, un carcter ( + - * / ) y
otro nmero.
La aplicacin tambin deber realizar la operacin, entre el segundo y el cuarto argumento.
La operacin vienen dada por el tercer argumento, que el programa controlar que sea uno de los
siguientes operadores ( +, -, *, / ).
Por ejemplo:
c:\>m7e4 10 + 5
La suma es 15
13.1. PROBLEMAS COMPLEMENTARIOS.
5) Argumentos en la funcin main().
Utilizando las ideas de la prctica 9, construiremos una aplicacin que se pueda llamar
desde la lnea de comandos de MS-DOS con dos parmetros: un carcter y un entero.
La aplicacin debe escribir el carcter indicado por el primer argumento el nmero de veces
que indique el segundo argumento.
Por ejemplo:
c:\>m7e4 10
xxxxxxxxxxxxx
6) Asignacin dinmica.
Siguiendo las ideas de la prctica de ampliacin 2, haremos un programa que calcule la
media de un nmero indeterminado de nmeros introducidos por teclado.
La introduccin de datos (del tipo double) se acabar en el momento de presionar la tecla
de escape (cdigo ASCII 27).
7) Divisin de nmeros complejos.
Completaremos el programa de la prctica 6, para incluir la divisin de nmeros complejos.
El cociente es posible siempre que la parte real y la parte imaginaria del divisor no sean
simultneamente 0. Esta circunstancia se debe comprobar:
- Si tenemos dos nmeros complejos z1=a+bi;
- Y z2=c+di, se define la divisin como;
Denominaremos al programa m7e7.c dentro de la carpeta Mdulo_7.

8) Horario escolar.
El horario escolar de un grupo de bachillerato es de 6 horas diarias de lunes a viernes.
Queremos crear una aplicacin que nos permita introducir los datos de este horario.
Para cada hora se deber definir:
- Nombre de la asignatura;
- Nombre del profesor;
- Nmero de aula.
El horario se almacena en una estructura de datos denominada Horario. Escoge la
estructura de datos ms conveniente para almacenar esta informacin y que tenga las siguientes
funcionalidades:
a) RellenarHorario(). Debe permitir introducir todas las horas.
b) RellenarHora(). Permite introducir los datos de una determinada hora de un da.
c) ListarHorario(). Saca por pantalla el horario.
d) ModificarHora(). Permite cambiar los datos de una determinada hora de un da.
Denominaremos al programa m7e8.c dentro de la carpeta Mdulo_7.

Módulo 7 - Fundamentos de Programación en C, C++ PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Módulo 7 - Fundamentos de Programación en C, C++ PDF

Enviado por

Direitos autorais:

Formatos disponíveis

MP 11 Fundamentos Programacin

Você também pode gostar