SOLUCION DE PROBLEMAS QUE UTILIZAN enumazul2.bnct.ipn.mx/academia/problemarios/guia_ets_enum_typedef_struct... · Programas con enum Página 4 Ing.Isis Espinosa Salazar DEFINICION

Programas con enum

Página 1 Ing. Isis Espinosa Salazar

SOLUCION DE PROBLEMAS QUE UTILIZAN

enum

Programas con enum


2. Clases y funciones miembro 2.1 Construcción de clases y objetos

2.1.1 Estructuras, uniones y palabra reservada class 2.2 Funciones miembro (métodos, acciones u operaciones)

2.2.1 Resolutor de ámbito 2.2.2 Constructor 2.2.3 Destructor

TIPOS ENUMERADOS

Hay otra forma de expresar datos en C. Esto se realiza mediante enum ( enumerado).

enum declara a un subconjunto de valores enteros. Por esta razón se dice que enum no define a un nuevo tipo de datos. Aunque para efectos prácticos, nosotros asumiremos que enum define a un nuevo tipo de datos.

Los miembros de una enumeración son constantes escritas como identificadores que tienen asignados valores enteros, bien sea por omisión o porque nosotros les demos valores iniciales.

enum Etiqueta { lista enumerada };

Etiqueta es el nombre del nuevo tipo de datos y la lista enumerada son constantes.

Ejemplos: enum DiaSemana{ Lunes, Martes, Miercoles, Jueves, Viernes, Sabado, Domingo}; DiaSemana es el nuevo tipo de datos. Las constantes Lunes, Martes, etc., automáticamente son inicializadas con 0, 1, 2, etc., respectivamente. Definamos una variable de tipo DiaSemana llamada Dia: DiaSemana Dia;

Dia es una variable de tipo DiaSemana que solo asume los valores de 0 a 6.

La idea de utilizar los datos enum, es para hacer más claro el programa. Asi, en vez de codificar:

if( Dia == 0 ) Accion1; elseif( Dia == 1 ) Accion2;

podemos mejorar la visibilidad de la codificación utilizando los datos enum de la siguiente manera.

if( Dia == Lunes ) Accion1; elseif( Dia == Martes ) Accion2;

Programas con enum


Otros ejemplos son los siguientes: enum GradoMilitar{ Soldado, Cabo, Sargento, Subteniente, Teniente, Capitan}; enum Logico{ Falso, Verdadero};

enum DiaSemana{ Lunes = 1, Martes, Miercoles, Jueves, Viernes, Sabado, Domingo}; En este último ejemplo, al inicialicar la constante Lunes con 1, automáticamente, Martes, Miercoles, etc., son inicializados con 2, 3, etc., respectivamente Veamos otras variantes: enum DiaSemana{ Lunes = 1, Martes, Miercoles, Jueves = 10, Viernes, Sabado, Domingo}; En este caso Martes y Miercoles son inicializados con 2 y 3, respectivamente. Viernes, Sabado y Domingo son inicializados con 11, 12 y 13 respectivamente. El problema sugerirá cuales son los valores más convenientes.

Programas con enum


DEFINICION DEL PROBLEMA: [ENUM 01.CPP] Definir un tipo enum llamado DiaSemana que tenga como identificadores los días de la semana (Lunes, Martes, Miercoles, Jueves, Viernes, Sabado y Domingo ). Imprimir los valores de estos identificadores. SALIDA:

Los valores de los identificadores son: 1 Los valores de los identificadores son: 2 Los valores de los identificadores son: 3 Los valores de los identificadores son: 4 Imprimir( ) Los valores de los identificadores son: 5 Los valores de los identificadores son: 6 Los valores de los identificadores son: 7 ANALISIS DEL PROBLEMA De la definición del problema y del análisis de la salida se observa que solo se requiere una tarea (función) Imprimir( ):

Su prototipo es: void Imprimir( void ); Esta función imprimirá los valores de los identificadores del tipo enum DiaSemana.

CODIFICACION DEL PROBLEMA

/* Nombre del programa: ENUM 01.CPP */ using namespace std; #include <iostream> //Para cout y cin enum DiaSemana { Lunes = 1, Martes, Miercoles, Jueves, Viernes, Sabado, Domingo }; void Imprimir( void ); int main ( void ) { system( "cls" ); Imprimir( ); cin.get( ); return 0; }//Fin de main( ) void Imprimir( void ) { cout << "Los valores de los identificadores son: " << Lunes << endl << "Los valores de los identificadores son: " << Martes << endl << "Los valores de los identificadores son: " << Miercoles << endl << "Los valores de los identificadores son: " << Jueves << endl << "Los valores de los identificadores son: " << Viernes << endl << "Los valores de los identificadores son: " << Sabado << endl << "Los valores de los identificadores son: " << Domingo << endl << endl; }//Fin de Imprimir( )

Programas con enum


DEFINICION DEL PROBLEMA [ENUM 02.CPP] Utilizando el tipo de datos enum DiaSemana del programa ENUM 01.CPP, elaborar un programa que muestre la siguiente Salida: SALIDA Dame un entero entre [1,7]: 8 El valor ingresado es incorrecto. Leer( ) Oprima ENTER PARA CONTINUAR ValidarOpcion( ) --------------------------------- Dame un entero entre [1,7]: 5 Tu día favorito es el Viernes. Imprimir( ) ANALISIS DEL PROBLEMA De la definición del problema y del análisis de la salida se observa que se requieren las siguientes tareas ( funciones ):

Una función Leer( ), cuyo prototipo es: DiaSemana Leer( void );

El objetivo de esta función es leer un valor entero comprendido entre 1 y 7, lo convierte a tipo enum y devuelve el tipo de dato enum seleccionado.

o Dentro de la función Leer( ), se llama a otra función ValidarOpcion( ), cuyo prototipo es: bool ValidarOpcion( const int Opcion );

El objetivo de esta función es validar que el valor leído este comprendido entre 1 y 7, en caso de ser verdadero devuelve true, en caso de ser falso devuelve false.

Una función Imprimir( ), cuyo prototipo es: void Imprimir( const DiaSemana Dia );

El objetivo de esta función es imprimir un mensaje donde se muestre el día seleccionado.

Programas con enum


CODIFICACION DEL PROGRAMA

/* Nombre del programa: ENUM 02.CPP */ using namespace std; #include <iostream> //Para cout y cin //Tipo enum enum DiaSemana { Lunes = 1, Martes, Miercoles, Jueves, Viernes, Sabado, Domingo }; //Prototipo de funciones DiaSemana Leer( void ); void Imprimir( const DiaSemana Dia ); int main ( void ) { system( "cls" ); DiaSemana Dia; Dia = Leer( ); Imprimir( Dia ); cin.ignore( ); cin.get( ); return 0; }//Fin del main( ) //Función Leer( ) DiaSemana Leer( void ) { int Opcion; DiaSemana Dia; bool Bandera = true; while( Bandera == true ) { system( "cls" ); cout << "Dame un entero entre [1,7]: "; cin >> Opcion; try { if( Opcion < 1 || Opcion > 7 ) throw Opcion; else Bandera = false; }//Fin de try catch( int Opcion) { cout << endl; cout << "El valor ingresado es incorrecto." << endl << "Oprima ENTER PARA CONTINUAR. "; cin.ignore( ); cin.get( ); cout << endl << endl; }//Fin de catch( ) cout << endl; }//Fin del while

Programas con enum


switch ( Opcion ) { case 1: Dia = Lunes; break; case 2: Dia = Martes; break; case 3: Dia = Miercoles; break; case 4: Dia = Jueves; break; case 5: Dia = Viernes; break; case 6: Dia = Sabado; break; case 7: Dia = Domingo; break; }//Fin de switch( ) return( Dia ); } //Fin de Leer() //Función Imprimir( ) void Imprimir( const DiaSemana Dia ) { cout << "Tu dia favorito es el "; switch( Dia ) { case Lunes: cout << "Lunes."; break; case Martes: cout << "Martes."; break; case Miercoles: cout << "Miercoles."; break; case Jueves: cout << "Jueves."; break; case Viernes: cout << "Viernes."; break; case Sabado: cout << "Sabado."; break; case Domingo: cout << "Domingo."; break; }//Fin del switch( ) }//Fin de Imprimir( )

Programas con enum


DEFINICION DEL PROBLEMA [ENUM 03.CPP] Elaborar un programa que mediante un tipo enum Figuras formado por Rectangulo, TrianguloE (triángulo equilatero), Circulo y Salir, realice la siguiente salida: SALIDA SELECCIONE UNA OPCION 1.- Rectangulo 2.- Triangulo 3.- Circulo 4.- Salir Dame tu opción: 6 Opción errónea. Inténtelo nuevamente. ValidarOpcion( )

Enter para continuar. -----------------------------------------------------------------------

SELECCIONE UNA OPCION Menu( ) 1.- Rectangulo 2.- Triangulo 3.- Circulo 4.- Salir Dame tu opción: 1 DAME LOS DATOS DEL RECTANGULO Largo = 2 Leer( ) Ancho = 3 VALORES DEL RECTANGULO Largo = 2.00 Ancho = 3.00

Perimetro = 10.00 CalP( ) Imprimir( ) Area = 6.00

Desea continuar S/N:n

CalA( )

Programas con enum


ANALISIS DEL PROBLEMA De la definición del problema y del análisis de la salida, se observa que se requieren las siguientes tareas:

Una función Menu( ), cuyo prototipo es: Figuras Menu( void ); El objetivo de esta función es mostrar un menú para que el usuario seleccione la figura a la cual se le calculará su perímetro y su área. La opción seleccionada deberá convertirse a tipo enum y la misma será devuelta por la función.

o Dentro de la función Menu( ), se invocará a otra función ValidarOpcion( ) cuyo prototipo es: bool ValidarOpcion( const int Opcion ). El objetivo de está función es validar que la opción seleccionada se encuentre entre 1 y 4. Si es cierto se devuelve true si es falso se devuelve false.

En este caso se requieren tres funciones Leer( ), para leer los datos del rectángulo (largo y ancho), del triángulo equilatero (lado) y las del círculo (el radio) . Utilizaremos funciones sobrecargadas (polimorfismo parámetrico). Los respectivos prototipos son los siguientes:

void Leer( float &RefLargo, float &RefAncho );

void Leer( float &RefLado ); float Leer( void );

Se requieren igualmente tres funciones Imprimir( ), para imprimir los datos, perímetro y área del

rectángulo, del triángulo y del círculo. Utilizaremos funciones sobrecargadas (polimorfismo parámetrico) para el rectángulo y el triángulo, no pudiendo sobrecargarse para el círculo, por lo que usaremos la función ImprimirC( ). Sus prototipos son los siguientes:

void Imprimir( const float Largo, const float Ancho );

void Imprimir( const float Lado ); void ImprimirC( const float Radio );

o Dentro de la respectiva función Imprimir( ), requerimos, para cada una de ellas una función

CalP( ) para calcular el perímetro de la figura correspondiente. Utilizaremos funciones sobrecargadas para el rectángulo y el triángulo y definiremos la función CalPC( ) para calcular el perímetro del círculo. Sus prototipos son los siguientes:

float CalP( const float Largo, const float Ancho );

float CalP( const float Lado ); float CalPC( const float Radio );

o Dentro de la respectiva función Imprimir( ), requerimos, para cada una de ellas una función

CalA( ) para calcular el área de la figura correspondiente. Utilizaremos funciones sobrecargadas para el rectángulo y el triángulo y definiremos la función CalAC( ) para calcular el área del círculo. Sus prototipos son los siguientes:

float CalA( const float Largo, const float Ancho );

float CalA( const float Lado ); float CalAC( const float Radio );

Programas con enum



/* Nombre del programa: ENUM 03.CPP*/ using namespace std; #include <iostream> //Para cout y cin #include <cctype> //Para toupper( ) #include <cmath> //Para M_PI y sin( ) enum Figuras { Rectangulo = 1, TrianguloE, Circulo, Salir }; Figuras Menu( void ); void Leer( double &RefLargo, double &RefAncho ); void Leer( double &RefLado ); double Leer( void ); double CalP( const double Largo, const double Ancho ); double CalP( const double Lado ); double CalPC( const double Radio); double CalA( const double Largo, const double Ancho ); double CalA( const double Lado ); double CalAC( const double Radio ); void Imprimir( const double Largo, const double Ancho ); void Imprimir( const double Lado ); void ImprimirC( const double radio ); int main( void ) { system( "cls"); Figuras Figura; char Respuesta; double Largo, Ancho, Lado, Altura, Radio; cout.setf( ios::fixed ); cout.setf( ios::showpoint ); cout.precision( 2 ); do { Figura = Menu( ); switch( Figura ) { case Rectangulo: cout << endl; cout << "DAME LOS DATOS DEL RECTANGULO" << endl; Leer( Largo, Ancho ); cout << "VALORES DEL RECTANGULO" << endl; Imprimir( Largo, Ancho ); break; case TrianguloE: cout << endl; cout << "DAME LOS DATOS DEL TRIANGULO" << endl; Leer( Lado );

cout << "VALORES DEL TRIANGULO" << endl; Imprimir( Lado ); break;

Programas con enum


case Circulo: cout << endl; cout << "DAME LOS DATOS DEL CIRCULO" << endl; Radio = Leer( ); cout << "VALORES DEL CIRCULO" << endl; ImprimirC( Radio ); break; case Salir: break; }//Fin de switch( ) cout << "Desea continuar S/N: "; cin >> Respuesta; }while( Respuesta = toupper( Respuesta ) == 'S' ); /******************************************************************************** toupper( ) es una función para convertir un caracter a mayúscula. tolower( ) es una función para convertir un caracter a minúscula. ********************************************************************************/ return 0; }//Fin de main( ) Figuras Menu( void ) { int Opcion; bool Bandera = true; Figuras Figura; while( Bandera == true ) { system( "cls" ); cout << "SELECCIONE UNA OPCION" << endl << "1.- Rectangulo" << endl << "2.- Triangulo" << endl << "3.- Circulo" << endl << "4.- Salir" << endl << endl; cout << "Dame tu opci¢n: "; cin >> Opcion; cout << endl; try { if( Opcion < 1 || Opcion > 4 ) throw Opcion; else Bandera = false; }//Fin de try catch( int e ) { cout << "Opci¢n err¢nea. Int‚ntelo nuevamente." << endl; cout << "Enter para continuar."; cin.ignore( ); cin.get( ); }//Fin de catch }//Fin del while

Programas con enum


switch( Opcion ) { case 1: Figura = Rectangulo; break; case 2: Figura = TrianguloE; break; case 3: Figura = Circulo; break; case 4: Figura = Salir; break; }//Fin del switch( ) return Figura; }//Fin de Menu( ) void Leer( double &RefLargo, double &RefAncho ) { cout << "Largo = "; cin >> RefLargo; cout << "Ancho = "; cin >> RefAncho; cout << endl; }//Fin de Leer( ) void Leer( double &RefLado )

{ cout << "Lado = "; cin >> RefLado; cout << endl; }//Fin de Leer( ) double Leer( void ) { double Radio; cout << "Radio = "; cin >> Radio; cout << endl; return Radio; }//Fin de LeerRT( ) double CalP( const double Largo, const double Ancho ) { return( 2 * ( Largo + Ancho ) ); }//Fin de CalP( ) double CalP( const double Lado ) { return( 3 * Lado ); }//Fin de CalP( ) double CalPC( const double Radio) { return( M_PI * 2.0 * Radio ); }//Fin de CalPC double CalA( const double Largo, const double Ancho ) { return( Largo * Ancho ); }//Fin de CalA( )

Programas con enum


double CalA( const double Lado ) { return( ( Lado * Lado * sin( 60.0 * M_PI / 180.0 ) ) / 2.0 ); }//Fin de CalA( ) /******************************************************************************* En un triángulo equilatero la Altura = hipotenusa * sen( 60ª ). X grados = x * ( PI / 180.0 ) radianes. En este caso la hipotenusa es igual a Lado. *******************************************************************************/ double CalAC( const double Radio ) { return( M_PI * pow( Radio, 2.0 ) ); }//Fin de CalAC( ) void Imprimir( const double Largo, const double Ancho ) { cout << "Largo = " << Largo << endl; cout << "Ancho = " << Ancho << endl; cout << "Perimetro = " << CalP( Largo, Ancho ) << endl; cout << "Area = " << CalA( Largo, Ancho ) << endl << endl; }//Fin de Imprimir( ) void Imprimir( const double Lado ) { cout << "Base = " << Lado << endl; cout << "Altura = " << ( Lado * sin( 60.0 * M_PI / 180.0 ) ) << endl; cout << "Perimetro = " << CalP( Lado ) << endl; cout << "Area = " << CalA( Lado ) << endl << endl; }//Fin de Imprimir( ) void ImprimirC( const double Radio ) { cout << "Radio = " << Radio << endl; cout << "Perimetro = " << CalPC( Radio ) << endl; cout << "Area = " << CalAC( Radio ) << endl << endl; }//Fin de ImprimirC( )

Programas con typedef



typedef



DAR NOMBRE A SUS PROPIOS TIPOS DE DATOS

El uso de typedef (definición de tipo) en C permite definir un nuevo nombre, alias o apodo a un tipo de datos de C. Una declaración typedef es similar a la declaración de una variable con la excepción de que se utiliza la palabra reservada typedef. Su formato es:

typedef Tipo NuevoTipo;

Es importante notar que la declaración typedef no crea un nuevo tipo, simplemente crea sinónimos

para tipos ya existentes. Aunque actua como si se tratara de un nuevo tipo de dato.

Ejemplos

typedef char Letra; //Letra es sinónimo de char

Letra Caracter;

typedef unsigned char Byte;

Byte Octeto;

typedef struct

{

double Real, Imaginario;

} Complejo;

Complejo C1;

typedef enum { Rojo, Verde, Apagado } EstadoLuces;

EstadoLuces Luces; // Luces es una variable enumerada que acepta los valores:

// Rojo, Verde, Apagado.

typedef char *Cadena; // cadena es un apuntador a char (char *).

Cadena Caracteres;

typedef char Nombre[ 20 ]; // Nombre es un vector de caracteres con 20 elementos.

Nombre ApellidoPaterno;



DEFINICION DEL PROBLEMA [TYPEDEF 01.CPP] Redefinir los tipos int por Entero, float por Flotante, char *AptCadena por AptCadena, Entero Vector[ ] por Vector y Flotante Matriz[ ][ ] por Matriz. SALIDA DESEADA Introducir los 3 valores enteros del vector Leer( ) 1 2 3 Introducir las 3 Filas y 2 Columas con valores reales de la matriz 1.1 2.2 Leer( ) 3.3 4.4 5.5 6.6

Introduce una cadena de caracteres: Isis Espinosa Salazar Leer( ) SALIDA DE LOS VALORES DEL VECTOR Y DE LA MATRIZ VECTOR 1 Imprimir( ) 2 3 MATRIZ 1.1 2.2 Imprimir( ) 3.3 4.4 5.5 6.6 SALIDA DE LA CADENA DE CARACTERES Isis Espinosa Salazar Imprimir( ) ANALISIS DEL PROBLEMA De la definición del problema y del análisis de la salida se observa que se requieren las siguientes tareas:

Tres funciones Leer( ): una para el vector, otra para la matriz y finalmente otra para leer una

cadena de caracteres. Utilizaremos funciones sobrecargadas para cada una de ellas. Sus respectivos prototipos son:

void Leer( Vector Vec ); void Leer( Matriz Mat ); AptCadena Leer( void );



Tres funciones Imprimir( ): una para el vector, otra para la matriz y finalmente otra para imprimir la cadena de caracteres. Igualmente utilizaremos funciones sobrecargadas para cada una de ellas. Sus respectivos prototipos son:

void Imprimir( const Vector Vec ); void Imprimir( const Matriz Mat );

void Imprimir( AptCadena Caracteres );


/* Nombre del programa: TYPEDEF 01.CPP*/ using namespace std; #include <iostream> //Para cout y cin #include <string> //Para la clase string typedef int Entero; typedef char *AptCadena; const Entero Filas = 3; const Entero Columnas = 2; typedef Entero Vector[ Filas ]; typedef float Flotante; typedef Flotante Matriz[ Filas ][ Columnas ]; void Leer( Vector Vec ); void Leer( Matriz Mat ); void Leer( string &RefCadena ); void Imprimir( const Vector Vec ); void Imprimir( const Matriz Mat ); void Imprimir( const string Cadena ); int main ( void ) { system( "cls" ); Vector Vec; Matriz Mat; string Cadena; cout << "Introducir los " << Filas << " valores enteros del vector " << endl; Leer( Vec ); cout << "Introducir las " << Filas << " Filas y " << Columnas << " Columas con valores reales de la matriz" << endl; Leer( Mat ); Leer( Cadena );

cout << "SALIDA DE LOS VALORES DEL VECTOR Y DE LA MATRIZ" << endl; Imprimir( Vec ); Imprimir( Mat ); cout << "SALIDA DE LA CADENA DE CARACTERES" << endl; Imprimir( Cadena ); cin.get( ); return 0; }//Fin de main( )



void Leer( Vector Vec ) { for( Entero i = 0; Filas > i; i++ ) cin >> Vec[ i ]; cout << endl; }//Fin de Leer( ) void Leer( Matriz Mat ) { for ( Entero i = 0; Filas > i; i++ ) for ( Entero j = 0; Columnas > j; j++ ) cin >> Mat[ i ] [ j ]; cout << endl; }//Fin de Leer( ) void Leer( string &RefCadena ) { fflush( stdin ); cout << "Introduce una cadena de caracteres: "; getline( cin, RefCadena); cout << endl << endl; }//Fin de Leer( ) void Imprimir( const Vector Vec ) { cout << endl << "VECTOR" << endl; for( Entero i = 0; Filas > i; i++ ) cout << Vec[ i ] << endl; cout << endl; }//Fin de Imprimir( ) void Imprimir( const Matriz Mat ) { cout << "MATRIZ"; for( Entero i = 0; Filas > i; i++ ) { cout << endl; for( Entero j = 0; Columnas > j; j++ ) cout << " " << Mat[ i ] [ j ]; }//Fin del for cout << endl << endl; }//Fin de Imprimir( ) void Imprimir( string Cadena ) { cout << Cadena << endl << endl; }//Fin de Imprimir( )

Programas con struct



struct



Estructuras Las estructuras son tipos de datos adicionales, esto es, se pueden construir utilizando elementos de otros tipos,

incluso con otras estructuras. Considere la siguiente definición de estructura:

struct Tiempo

{ int Hora; // 0-23 (formato de reloj de 24 horas) int Minuto; // 0-59 int Segundo; // 0-59

}; // Fin de la estructura Tiempo{ }

La palabra reservada struct introduce la definición de la estructura. El identificador Tiempo es la etiqueta de la estructura que da nombre a la definición de la estructura y se utiliza

para declarar las variables del tipo de la estructura. En este ejemplo, el nuevo nombre de tipo es Tiempo. Los nombres declarados entre las llaves de la definición de la estructura son los miembros de la estructura. Los miembros de la misma estructura deben tener nombres únicos, pero dos estructuras diferentes pueden contener

miembros con el mismo nombre sin conflicto alguno. Cada definición de estructura termina con un punto y coma.

La explicación anterior también es válida para las clases; como veremos pronto, en C++ las estructuras y las clases

son bastante similares.

La definición de Tiempo contiene tres miembros de tipo int: Hora, Minuto y Segundo. Los miembros de la estructura pueden ser de cualquier tipo y una estructura puede contener miembros de tipos

diferentes. Sin embargo, una estructura no puede contener una instancia de sí misma. Por ejemplo, no se puede declarar un miembro de tipo Tiempo en la definición de la estructura Tiempo. Sin embargo, se puede incluir un apuntador hacia otra estructura Tiempo. A una estructura que contiene un miembro que es un apuntador hacia el mismo tipo de estructura se le llama

estructura autorreferencial. Las estructuras autorreferenciales son útiles para formar estructuras de datos ligadas tales como listas ligadas,

colas, pilas y árboles los cuales se estudiarán en otro curso.

La definición anterior de estructura no reservan espacio en memoria; en vez de ello, la definición crea un nuevo tipo de

dato que se utiliza para declarar variables. Las variables de estructura se declaran como las variables de otros tipos.

Las declaraciones:

Tiempo ObjetoTiempo; // objeto de tipo Tiempo Tiempo ArregloTiempo[ 10 ]; // arreglo con estructuras de tipo Tiempo



Tiempo *AptTiempo = &ObjetoTiempo; // apuntador hacia una variable de tipo Tiempo Tiempo &RefTiempo = ObjetoTiempo; // referencia hacia una variable de tipo Tiempo

Declaran a ObjetoTiempo como una variable de tipo Tiempo. A ArregloTiempo como un arreglo de 10 elementos de tipo Tiempo. A AptTiempo como un apuntador a una variable de tipo Tiempo, el cual se inicializa mediante la dirección de

ObjetoTiempo. Y RefTiempo, para que sea una referencia al objeto Tiempo que se inicializa con ObjetoTiempo.

Acceso a los miembros de una estructura El acceso a los miembros de una estructura (o de una clase) se realiza mediante los operadores de acceso a

miembros: El operador punto ( . ) y el operador flecha ( -> ). El operador punto accede a un miembro de una estructura o de una clase mediante el nombre de la variable del

objeto o mediante una referencia al objeto. Por ejemplo, para imprimir el miembro Hora de ObjetoTiempo, utilice la instrucción:

cout << ObjetoTiempo.Hora;

Para imprimir el miembro Hora de un objeto Tiempo, referenciado mediante RefTiempo, utilice la instrucción:

cout << RefTiempo.Hora; El operador flecha, el cual consiste en un signo menos ( - ) y un signo de mayor ( > ) sin espacio intermedio, accede a

los miembros de una estructura o de una clase mediante un apuntador al objeto. Suponga que el apuntador AptTiempo se declara para apuntar hacia un objeto Tiempo y que la dirección de

ObjetoTiempo se asigna a AptTiempo. Para imprimir el miembro Hora de ObjetoTiempo mediante el apuntador AptTiempo, utilice la instrucción:

cout << AptTiempo -> Hora;

La expresión AptTiempo -> Hora es equivalente a (*AptTiempo).Hora, el cual desreferencia al apuntador y accede al

miembro Hora mediante el operador punto. Los paréntesis son necesarios aquí debido a que el operador punto ( . ) tiene un nivel de precedencia más alto que el operador de desreferencia del apuntador ( * ). El operador flecha y el operador punto, junto con los paréntesis y los corchetes ( [ ] ) tienen el segundo nivel de precedencia más alto (después del operador de resolución de alcance); estos operadores se asocian de izquierda a derecha.

Error común de programación La expresión (*AptTiempo).Hora hace referencia al miembro Hora de la estructura a la que apunta AptTiempo. El

operador punto ( . ) tiene un nivel de precedencia más alto que el asterisco ( * ), de manera que omitir los paréntesis ocasionaría que la expresión se evaluara como si los paréntesis estuvieran de la siguiente manera * (AptTiempo.Hora). Esto sería un error de sintaxis debido a que con apuntadores, usted debe utilizar el operador flecha para hacer referencia a un miembro.



Tip de rendimiento De manera predeterminada, las estructuras se pasan por valor. Para evitar la sobrecarga de copias de la estructura, pase la estructura por referencia.

Observación de ingeniería de software Para evitar la sobrecarga de los pasos por valor y aún obtener el beneficio de la protección de los datos contra modificaciones, pase los argumentos grandes como referencias de tipo const. Existen algunas desventajas al crear algunos nuevos tipos de datos de esta manera. La inicialización no es necesaria

de manera específica, de manera que es posible tener datos no inicializados y sus problemas subsecuentes. Incluso si los datos se inicializan, podrían no estar inicializados de manera correcta. Es posible asignar valores no válidos a los miembros de una estructura, debido a que el programa tiene acceso directo a los datos.

Si el programador modifica la implementación de struct (por ejemplo, la Hora se puede representar como el número de segundos desde medianoche), todos los programas que utilizan struct se deben modificar de manera acorde. Esto se debe a que el programador manipula de manera directa la representación de datos. No existe una interfaz de la representación de datos para garantizar que el programador utiliza los servicios del tipo de dato de manera correcta y para garantizar que los datos permanecen en un estado consistente.

Observación de ingeniería de software Es importante escribir programas que sean claros y fáciles de mantener. Cambiar es la regla en vez de la excepción. Los programadores deben prever que su código se modificará. Como veremos, las clases facilitan la modificación de programas. Existen otros problemas asociados con las estructuras al estilo C. En C, las estructuras no se pueden imprimir como

unidad; en vez de esto, sus miembros se deben imprimir y formatear uno a la vez. Es posible escribir una función para imprimir los miembros de una estructura mediante un formato apropiado. Otro tema, Sobrecarga de Operadores: objetos de tipo cadena y de tipo arreglo, muestra la manera de sobrecargar al operador << para permitir a los objetos de un tipo de estructura o de clase imprimirse de manera fácil. En C, las estructuras no se pueden comparar en su to-talidad; éstas deben compararse miembro a miembro. Otro tema muestra también la manera de sobrecargar los operadores de igualdad y los de relación, para comparar objetos de tipo estructura (C++) y clase.

Mas Ejemplos

struct Estudiante enum Colores{ Azul, Negro, Amarillo, Rojo, { verde }; char Nombre[ 30 ]; struct Automovil int Boleta; { int AnioIngreso; int Modelo; float PromCal; Colores Color; bool Egresado; float Precio; } Juan; } Ford, Chevey, Dodge; enum Condiciones { Despejado, Nublado, Lluvioso }; struct Clima { char Fecha[ 10 ]; float Temperatura; float Presion; Condiciones Condicion; } Manana, Mediodia, Tarde, Noche;



struct Registro { char Fabricante [ 20 ]; int Importe; float PrecioUnitario; }; En caso de no definir las variables del tipo de la estructura inmediatamente después de

enunciar la estructura, las variables estructuras podrían definirse aparte de la siguiente manera:

Estudiante Juan; Automóvil Ford; Automóvil Chevy; Automóvil Dodge; Clima Manana, Mediodia, Tarde, Noche;



INICIALIZACION DE VARIABLES DE LA ESTRUCTURA

NombreEstructura NombreVariableEstructura = { Valor miembro1, Valor miembro2, Valor miembro3, …, Valor miembroN };

Ejemplo

Estudiante Juan = { “Juan Pérez Jolote”, 12345, 2003, 7.98, false }; Clima Mediodia = { “28/08/2003”, 41, 30.15, Nublado };

Operador miembro ( . )

NombreEstructura.NombreMiembro = Dato;

Ejemplos

strcpy( Juan.Nombre, “Juan Pérez Jolote” ); Juan.Boleta = 0001; Juan.AnioIngreso = 2003; Juan.PromCal = 7.98; Juan.Egresado = false; cout << “Escriba el nombre del estudiante: ”; gets( Juan.Nombre ); cout << “Escriba la boleta del estudiante : ”; cin >> Juan.Boleta; cout << “Escriba el año de ingreso del estudiante: ”; cin >> Anio.Ingreso; cout << “Escriba el promedio de calificaciones del estudiante: ”; cin >> Juan.PromCal; cout << “¿El estudiante es egresado? (S/N): ”; cin >> Respuesta; if( Respuesta == ‘s’ || Respuesta == ‘S’ ) Juan.Egresado = true; else Juan.Egresado = false;



DEFINICION DEL PROBLEMA [ESTRUC 01.CPP] Dadas tres cantidades reales positivas, se requiere decidir si dichas cantidas forman o no un triángulo. En caso de que formen un triángulo decir que tipo de triángulo es (escaleno, equilátero, isósceles). Las tres cantidades forman una estructura que llamaremos Triangulo. Tres cantidades reales positivos que representan los lados de un supuesto triángulo, forman un triángulo si la suma de las cantidades de dos de sus lados es mayor que el tercero. Supongamos que las cantidades sean: Lado1, Lado2, Lado3, entonces, las condiciones requeridas son: (Lado1 + Lado2) > Lado3 y (Lado1 + Lado3) > Lado2 y (Lado2 + Lado3) > Lado1 Un triángulo es escaleno si sus lados son diferentes, es decir: Lado1 != Lado2 y Lado1 != Lado3 y Lado2 != Lado3 Un triángulo es equilátero, si sus tres lados son iguales, es decir: Lado1 = Lado2 y Lado2 = Lado3 Un triángulo es isósceles si dos de sus lados son iguales, es decir: ((Lado1 = Lado2 ) y Lado1 != Lado3) || ((Lado1 = Lado3 ) y Lado1 != Lado2) || ((Lado2 = Lado3 ) y Lado2 != Lado1) O bien por eliminación: un triángulo es isósceles si no es ni escaleno ni equilátero. SALIDA:

SOLICITUD DE LOS DATOS DEL POSIBLE TRIANGULO Dame la longitud del primer lado : 3 Dame la longitud del segundo lado : 4 Dame la longitud del tercer lado : 5 Con las longitudes de los lados siguientes Lado 1 = 3 Lado 2 = 4 Lado 3 = 5 Se forma un triangulo ESCALENO -------------------------------------------------------------------------- SOLICITUD DE LOS DATOS DEL POSIBLE TRIANGULO Dame la longitud del primer lado : 9 Dame la longitud del segundo lado : 9 Dame la longitud del tercer lado : 9 Con las longitudes de los lados siguientes Lado 1 = 9 Lado 2 = 9 Lado 3 = 9 Se forma un triangulo EQUILATERO --------------------------------------------------------------------------



SOLICITUD DE LOS DATOS DEL POSIBLE TRIANGULO Dame la longitud del primer lado : 5 Dame la longitud del segundo lado : 5 Dame la longitud del tercer lado : 6 Con las longitudes de los lados siguientes Lado 1 = 5 Lado 2 = 5 Lado 3 = 6 Se forma un triangulo ISOSCELES --------------------------------------------------------------------------- SOLICITUD DE LOS DATOS DEL POSIBLE TRIANGULO Dame la longitud del primer lado : 1 Dame la longitud del segundo lado : 2 Dame la longitud del tercer lado : 3 Con las longitudes de los lados siguientes Lado 1 = 1 Lado 2 = 2 Lado 3 = 3 No se forma un triangulo

ANALISIS DEL PROBLEMA De la definición del problema y del análisis de la salida se observa que se requieren las siguientes tareas:

Una función Leer( ) que lea los datos de la estructura. Su prototipo es el siguiente:

void Leer( Triangulo &RefT );

o bien

Triangulo Leer( void );

Utilizaremos la primera opción de prototipo.

Cuatro funciones lógicas que nos digan si se forman o no un triangulo, si es triangulo de que tipo es. Sus prototipos son los siguientes:

bool EsTriangulo( const Triangulo &RefT ); bool EsEscaleno( const Triangulo &RefT );

bool EsEquilatero( const Triangulo &RefT ); bool EsIsosceles( const Triangulo &RefT );

Una función Imprimir( ) que imprima los datos de la estructura y los mensajes respectivos. Su

prototipo es el siguiente:

void Imprimir( const Triangulo &RefT );




/* Nombre del programa: ESTRUC 01.CPP */ using namespace std; #include <iostream> //Para cout y cin struct Triangulo { float Lado1; float Lado2; float Lado3; };//Fin de la estructura Triangulo{ } void Leer( Triangulo &RefT ); bool EsTriangulo( const Triangulo &RefT ); bool EsEscaleno( const Triangulo &RefT ); bool EsEquilatero( const Triangulo &RefT ); bool EsIsosceles( const Triangulo &RefT ); void Imprimir( const Triangulo &RefT ); int main( void ) { system( "cls" ); Triangulo T1; Leer( T1 ); Imprimir( T1 ); cin.ignore( ); cin.get( ); return 0; }//Fin del main( ) void Leer( Triangulo &RefT ) { cout << "SOLICITUD DE LOS DATOS DEL POSIBLE TRIANGULO" << endl; cout << "Dame la longitud del primer lado : "; cin >> RefT.Lado1; cout << "Dame la longitud del segundo lado: "; cin >> RefT.Lado2; cout << "Dame la longitud del tercer lado : "; cin >> RefT.Lado3; cout << endl; }//Fin de Leer( ) bool EsTriangulo( const Triangulo &RefT ) { bool Bandera; Bandera = ( RefT.Lado1 + RefT.Lado2 ) > RefT.Lado3 && ( RefT.Lado1 + RefT.Lado3 ) > RefT.Lado2 && ( RefT.Lado2 + RefT.Lado3 ) > RefT.Lado1; return Bandera; }//Fin de EsTriangulo( )



bool EsEscaleno( const Triangulo &RefT ) { bool Bandera; Bandera = EsTriangulo( RefT ); Bandera = Bandera && ( ( RefT.Lado1 != RefT.Lado2 ) && ( RefT.Lado1 != RefT.Lado3 ) && ( RefT.Lado2 != RefT.Lado3 ) ); return Bandera; }//Fin de EsEscaleno( ) bool EsEquilatero( const Triangulo &RefT ) { bool Bandera; Bandera = EsTriangulo( RefT ); Bandera = Bandera && ( ( RefT.Lado1 == RefT.Lado2 ) && ( RefT.Lado1 == RefT.Lado3 ) && ( RefT.Lado2 == RefT.Lado3 ) ); return Bandera; }//Fin de EsEquilatero( ) bool EsIsosceles( const Triangulo &RefT ) { bool Bandera; Bandera = EsTriangulo( RefT ); Bandera = Bandera && ( ( ( RefT.Lado1 == RefT.Lado2 ) && ( RefT.Lado1 != RefT.Lado3 ) ) || ( ( RefT.Lado1 == RefT.Lado3 ) && ( RefT.Lado1 != RefT.Lado2 ) ) || ( ( RefT.Lado2 == RefT.Lado3 ) && ( RefT.Lado2 != RefT.Lado1 ) ) ); return Bandera; }//Fin de EsIsosceles( ) void Imprimir( const Triangulo &RefT ) { cout << "Con las longitudes de los lados siguientes" << endl << "Lado 1 = " << RefT.Lado1 << endl << "Lado 2 = " << RefT.Lado2 << endl << "Lado 3 = " << RefT.Lado3 << endl << endl; if( EsTriangulo( RefT ) ) { cout << "Se forma un triangulo "; if( EsEscaleno( RefT ) ) cout << "ESCALENO" << endl; else if(EsEquilatero( RefT ) ) cout << "EQUILATERO" << endl; else cout << "ISOSCELES" << endl; }//Fin del if else cout << "No se forma un triangulo" << endl; }//Fin de Imprimir( )



Ejercicio

Mejore el programa anterior elaborando funciones que realicen las siguientes tareas:

a) Calcule el perímetro del triángulo b) Calcule el área del triángulo c) Calcule cada uno de los ángulos internos del triángulo d) Calcule la altura del triángulo e) Calcule el radio y el área del círculo inscrito f) Calcule el radio y el área del círculo circunscrito

Las fórmulas requeridas son las siguientes:

Perímetro = P = (Lado1 + Lado2 + Lado3 ). Semiperímetro = S = P/2

á Si es el ángulo opuesto al Lado1, el ángulo opuesto al Lado2 y el ángulo opuesto al Lado3, entonces se tienen las siguientes fórmulas:

La altura h del triángulo, dependerá de que lado se tome como base, en general:

Altura = h = Lado1 sen = Lado2 sen Para el círculo inscrito y circunscrito:

á y el Area Ai = r2

á

y el Area Ac = R2



DEFINICION DEL PROBLEMA [ESTRUC 02.CPP] La corriente en un circuito AC que contiene una resistencia, una capacitancia y una inductancia en serie, se da por la fórmula siguiente:

21

2

Donde las variables utilizadas tienen los siguientes significados y unidades:

I = Intensidad de corriente en amperios. E = Voltaje en voltios. R = Resistencia en ohmios. L = Inductancia en henrios. C = Capacitancia en faradios. F = Frecuencia en ciclos por segundo

Dada una estructura que contienen valores de E, R ,L,C y F, elabore un programa que lea los datos e imprima los mismos asi como el valor de I. Nota: Reciba las estructuras en las funciones utilizando apuntadores. Utilizado en la función la notación punto.

SALIDA:

SOLICITUD DE DATOS DEL CIRCUITO DE CORRIENTE ALTERNA Voltaje = 1 Resistencia = 1 Inductancia = 1 Capacitancia = 1 Frecuencia = 1

Intensidad de corriente = 0.37466



void Leer( CircuitoAC *AptC );

Una funcion CalcularInt( ) para calcular el valor de la Intensidad de la corriente. Su prototipo es el siguiente:

float CalcularInt( const CircuitoAC *AptC );

Una función Imprimir( ) que imprima el valor de la intensidad de la corriente. Su prototipo es el

siguiente:

void Imprimir( const CircuitoAC *AptC );




/* Nombre del programa: ESTRUC 02.CPP */ using namespace std; #include <iostream> //Para cout y cin #include <cmath> //Para sqrt( ) y pow( ) struct CircuitoAC { float Voltaje; float Resistencia; float Inductancia; float Capacitancia; float Frecuencia; };//Fin de la estructura CircuitoAC{ } void Leer( CircuitoAC *AptC ); float CalcularInt( const CircuitoAC *AptC ); void Imprimir( const CircuitoAC *AptC ); int main( void ) { CircuitoAC C; system( "cls" ); Leer( &C ); Imprimir( &C ); cin.ignore( ); cin.get( ); return 0; }//Fin del main( ) void Leer( CircuitoAC *AptC ) { cout << "SOLICITUD DE DATOS DEL CIRCUITO DE CORRIENTE ALTERNA" << endl; cout << "Voltaje = "; cin >> (*AptC ).Voltaje; cout << "Resistencia = "; cin >> (*AptC ).Resistencia; cout << "Inductancia = "; cin >> (*AptC ).Inductancia; cout << "Capacitancia = "; cin >> (*AptC ).Capacitancia; cout << "Frecuencia = "; cin >> (*AptC ).Frecuencia; cout << endl; }//Fin de Leer( ) float CalcularInt( const CircuitoAC *AptC ) { float Corriente; Corriente = ( * AptC ).Voltaje / sqrt( pow( ( *AptC ).Resistencia, 2.0f ) + ( ( 2.0f * M_PI * ( * AptC ).Frecuencia * ( * AptC ).Inductancia ) - ( 1.0 / ( 2.0 * M_PI * ( * AptC ).Frecuencia * ( * AptC ).Capacitancia ) ) ) ); return Corriente; }//Fin de CalcularInt( )



Es importante notar que para cambiar un miembro de estructura, el programa debe pasar un apuntador a la estructura. Dentro de la función, el apuntador es desreferenciado utilizando el operador de indirección asterisco ( * ):

( *Apuntador ).Miembro = Valor; Para resolver el apuntador, C empieza dentro de los paréntesis, primero obtiene la ubicación de la estructura. Después C agrega a la dirección el desplazamiento al miembro especificado. Si omite el paréntesis:

*Apuntador.Miembro = Valor; C supone que el miembro es un apuntador y utiliza el operador de indirección asterisco para resolver la situación. Esta sintaxis sería correcta para una estructura que tiene un miembro que es un apuntador, tal como se muestra a continuación:

struct SistemaSolar { char Nombre[ 48 ]; int *CiertoApuntador; } Planeta;

Como puede ver, el segundo miembro es un apuntador a un valor de tipo int. Suponiendo que el apuntador ha sido inicializado con alguna dirección, la siguiente sentencia coloca el valor de 5 en la ubicación de memoria:

*Planeta.CiertoApuntador = 5;

void Imprimir( const CircuitoAC *AptC ) { cout << "Intensidad de corriente = " << CalcularInt( AptC ) << endl << endl; }//Fin de Imprimir( )



DEFINICION DEL PROBLEMA [ESTRUC 03.CPP] Un punto en el espacio tridimensional de Euclides viene dada por sus coordenadas (Xi, Yi, Zi). La fórmula para calcular la distancia entre dos puntos A(Xa, Ya, Za ) y B(Xb, Yb, Zb ) viene dada por:

Los cosenos directores de la línea que va del origen al punto están dados por las fórmulas siguientes:

=

=

=

a) Leer dos puntos situados en el espacio b) Calcular los cosenos directores de cada punto y la distancia entre los dos puntos c) Imprimir datos y resultados.

Nota: Utilizar en los parámetros de las funciones apuntadores a una estructura. Dentro de la función utilizar la notación flecha.

SALIDA DATOS DE LAS COORDENADAS DEL PUNTO 1 Dame la coordenada X: 1 Dame la coordenada Y: 1 Dame la coordenada Z: 1 DATOS DE LAS COORDENADAS DEL PUNTO 2 Dame la coordenada X: 2 Dame la coordenada Y: 2 Dame la coordenada Z: 2 VALORES DE LAS COORDENADAS DEL PUNTO 1: ( 1, 1, 1 ) VALORES DE LOS COSENOS DIRECTORES CX = 0.57735 CY = 0.57735 CZ = 0.57735 VALORES DE LAS COORDENADAS DEL PUNTO 2: ( 2, 2, 2 ) VALORES DE LOS COSENOS DIRECTORES CX = 0.57735 CY = 0.57735 CZ = 0.57735 LA DISTANCIA ENTRE EL PUNTO 1 Y EL PUNTO 2 ES = 1.73205





void Leer( Punto *AptP );

Una funcion CalcularDist ( ) para calcular la distancia entre dos puntos. Su prototipo es el siguiente:

float CalcularDist( const Punto *AptP1, const Punto *AptP2 );

Una funcion CalCos( ) para calcular los valores de los cosenos directores, mismos que se dejan en

otra estructura de tipo CosDirPun. Su prototipo es el siguiente:

void CalCos( CosDirPun *AptCO, const Punto *AptP );

Una función Imprimir( ) que imprima las coordenadas de cada punto, sus cosenos directores y finalmente la distancia entre los dos puntos. Su prototipo es el siguiente:

void Imprimir( CosDirPun *AptCO, const Punto *AptP1, const Punto *AptP2 );



CODIFICACION DEL PROBLEMA /* Nombre del programa: ESTRUC 03.CPP */

using namespace std; #include <iostream> //Para cout y cin #include <cmath> //Para pow( ) y sqrt( ) struct Punto { float CoordX; float CoordY; float CoordZ; }; //Fin de la estructura Puntos{ } struct CosDirPun { float CX; float CY; float CZ; };//Fin de la estructura CosDirPun{ } void Leer( Punto *AptP ); float CalcularDist( const Punto *AptP1, const Punto *AptP2 ); void CalCos( CosDirPun *AptCO, const Punto *AptP ); void Imprimir( CosDirPun *AptCO, const Punto *AptP1, const Punto *AptP2 ); int main( void ) { system( "cls" ); Punto P1, P2; CosDirPun CDP; //Bloque para leer los dos puntos P1 y P2 Leer( &P1 ); Leer( &P2); //Bloque para imprimir los puntos P1, P2 y la distancia entre ellos. Imprimir( &CDP, &P1, &P2 ); cin.ignore( ); cin.get( ); return 0; }//Fin del main( ) void Leer( Punto *AptP ) { static int i = 1; cout << "DATOS DE LAS COORDENADAS DEL PUNTO " << i << endl; cout << "Dame la coordenada X: "; cin >> AptP -> CoordX; cout << "Dame la coordenada Y: "; cin >> AptP -> CoordY; cout << "Dame la coordenada Z: "; cin >> AptP -> CoordZ; i++; cout << endl; }//Fin del Leer( )



float CalcularDist( const Punto *AptP1, const Punto *AptP2 ) { float Distancia; Distancia = sqrt( pow( ( AptP1 -> CoordX - AptP2 -> CoordX ), 2.0f ) + pow( ( AptP1 -> CoordY - AptP2 -> CoordY ), 2.0f ) + pow( ( AptP1 -> CoordZ - AptP2 -> CoordZ ), 2.0f ) ); return Distancia; }//Fin de CalcularDist( ) void CalCos( CosDirPun *AptCO, const Punto *AptP ) { float Denominador; Denominador = sqrt( pow( AptP -> CoordX, 2.0f ) + pow( AptP -> CoordY, 2.0f )+ pow( AptP -> CoordZ, 2.0f ) ); AptCO -> CX = AptP -> CoordX / Denominador; AptCO -> CY = AptP -> CoordY / Denominador; AptCO -> CZ = AptP -> CoordZ / Denominador; }//Fin de CalCos( ) void Imprimir( CosDirPun *AptCO, const Punto *AptP1, const Punto *AptP2 ) { static int k = 1; cout << "VALORES DE LAS COORDENADAS DEL PUNTO " << k << ": " << "( " << AptP1 -> CoordX << ", " << AptP1 -> CoordY << ", " << AptP1 -> CoordZ << " )" << endl; CalCos( AptCO, AptP1 ); cout << "VALORES DE LOS COSENOS DIRECTORES" << endl << "CX = " << AptCO -> CX << endl << "CY = " << AptCO -> CY << endl << "CZ = " << AptCO -> CZ << endl << endl; cout << "VALORES DE LAS COORDENADAS DEL PUNTO " << ++k << ": " << "( " << AptP2 -> CoordX << ", " << AptP2 -> CoordY << ", " << AptP2 -> CoordZ << " )" << endl; CalCos( AptCO, AptP2 ); cout << "VALORES DE LOS COSENOS DIRECTORES" << endl << "CX = " << AptCO -> CX << endl << "CY = " << AptCO -> CY << endl << "CZ = " << AptCO -> CZ << endl << endl; cout << "LA DISTANCIA ENTRE EL PUNTO " << --k << " Y EL PUNTO " << ++k << " ES = " << CalcularDist( AptP1, AptP2 ) << endl << endl; }//Fin de Imprimir( )



DEFINICION DEL PROBLEMA [ESTRUC 04.CPP] Resolver el programa anterior pero para n puntos, para simplificar lo haremos con tres. Es decir utilizar un arreglo de tres elementos de tipo Punto. Y una estructura de tipo CosDirPun. SALIDA DATOS DE LAS COORDENADAS DEL PUNTO 1 Dame la coordenada X: 1 Dame la coordenada Y: 1 Dame la coordenada Z: 1 DATOS DE LAS COORDENADAS DEL PUNTO 2 Dame la coordenada X: 2 Dame la coordenada Y: 2 Dame la coordenada Z: 2 DATOS DE LAS COORDENADAS DEL PUNTO 3 Dame la coordenada X: 3 Dame la coordenada Y: 3 Dame la coordenada Z: 3 VALORES DE LAS COORDENADAS DEL PUNTO 1: ( 1, 1, 1 ) VALORES DE LOS COSENOS DIRECTORES CX = 0.57735 CY = 0.57735 CZ = 0.57735 VALORES DE LAS COORDENADAS DEL PUNTO 2: ( 2, 2, 2 ) VALORES DE LOS COSENOS DIRECTORES CX = 0.57735 CY = 0.57735 CZ = 0.57735 LA DISTANCIA ENTRE EL PUNTO 1 Y EL PUNTO 2 ES = 1.73205 VALORES DE LAS COORDENADAS DEL PUNTO 2: ( 2, 2, 2 ) VALORES DE LOS COSENOS DIRECTORES CX = 0.57735 CY = 0.57735 CZ = 0.57735 VALORES DE LAS COORDENADAS DEL PUNTO 3: ( 3, 3, 3 ) VALORES DE LOS COSENOS DIRECTORES CX = 0.57735 CY = 0.57735 CZ = 0.57735 LA DISTANCIA ENTRE EL PUNTO 2 Y EL PUNTO 3 ES = 1.73205

ANALISIS DEL PROBLEMA

En realidad se trata del mismo problema anterior, lo único que cambiará será el programa principal. Para simplificar solo mostraremos la codificacion del programa principal.




/* Nombre del programa: ESTRUC 04.CPP */ int main( void ) { system( "cls" ); const int NUM_PTOS = 5; Punto ArrePunto[ NUM_PTOS ]; CosDirPun CDP; //Bloque para leer los puntos for( int i = 0; i < NUM_PTOS; i++ ) Leer( &ArrePunto[i] ); //Bloque para imprimir los puntos y la distancia entre ellos. for( int i = 0; i < NUM_PTOS - 1; i++ ) Imprimir( &CDP, &ArrePunto[i], &ArrePunto[ i + 1 ] ); cin.ignore( ); cin.get( ); return 0; }//Fin del main( )



EJERCICIOS

1. Se tiene un cono truncado circular recto y las fórmulas siguientes:

Area Lateral = G( r + R ) Area Total = Area Lateral + ( r2 + R2 )

3

Donde: G = Generatriz r = Radio de la base inferior R = Radio de la base superior A1 = Area de la base inferior A2 = Area de la base superior V = Volumen del cono truncado H = Altura del cono truncado

Elaborar un programa que realice las siguientes tareas: a) Lea una cuadrupla de datos (H1, R1, R2, G), siendo R1, R2 los radios de las respectivas bases. b) Calcule el área lateral del cono truncado c) Calcule el área total del cono truncado d) Calcule las áreas de cada base e) Calcule el volumen del tronco de cono f) Imprima los datos y los cálculos correspondientes.

2. En un triángulo ABC, LA es el lado opuesto al ángulo A, LB es el lado opuesto al ángulo B y LC es el

lado opuesto al ángulo C. El coseno del ángulo A puede calcularse por medio de la fórmula siguiente:

2

Desarrolle las expresiones respectivas del coseno para los otros ángulos (B y C).

Elabore un programa que efectúe las siguientes tareas: a) Lea una terna (LA, LB, LC) b) Determinar si forman un triángulo, en cuyo caso c) Calcular el coseno de cada ángulo d) Imprimir datos y resultados.

3. El momento de inercia de un rectángulo con respecto a su diagonal viene dada por la siguiente fórmula:

6

Donde:

I = Momento de inercia B y H = Lados del rectángulo



Elabore un programa que efectúe las siguientes tareas: a) Leer un par de valores (B, H) b) Calcular el momento de inercia c) Imprimir datos y resultados

4. Un problema común en un curso de fundamentos de física concierne a cálculos de energía para un objeto

vibrante al final de un resorte en movimiento armónico simple (vea la siguiente figura). Los términos de energía que se utilizan son: eneregía cinética (energía de movimiento), energía potencial (energía almacenada, latente), y energía total (la suma de las energías cinética y potencial).

Sin adentrarse en la teoría, las fórmulas que se emplean (referidas a la figura anterior) son las siguientes:

Donde:

K = Es la constante del resorte (Kg/s2) TE = Es la energía total (Joules) PE = Es la energía potencial (Joules) KE = Es la energía cinética (Joules) A = Es la amplitud del movimiento (en metros) X = Es el desplazamiento inicial considerado (en metros) M = Es la masa del objeto (en kg) T = Es el tiempo del período, para un ciclo de movimiento (en segundos) Elaborar un programa que: a) Lea los datos de la amplitud (A), el desplazamiento (X), la masa (M) y el período (T). b) Determina la constante K del resorte y las tres energías relacionadas. c) Imprima datos y resultados

5. Un tipo de ecuaciones simultáneas es de la forma ilustrada en la siguiente figura:



Los coeficientes de X e Y son constantes reales, e igualmente los términos en C. Este tipo de ecuación simultánea en dos variables se puede resolver mediante las fórmulas mostradas a continuación, siendo A1B2 – A2B1, diferente de cero. Si fuerea igual a cero, el sistema no tiene solución.

Elabore un programa que realice los siguientes procesos: a) Lea la terna de datos (A, B, C) para cada ecuación b) Obtenga la solución del sistema de ecuaciones. Si el sistema no tiene solución se ha de desplegar un

mensaje descriptivo c) Imprimir datos y resultados

6. Un problema común en una planta manufacturera, en donde las partes se fabrican en serie por grandes

cantidades, se almacenan y se usan de acuerdo con las necesidades de ensamblaje de un producto, es determinar el tamaño de la serie más económica. La ecuación mostrada se emplea para calcular el número de piezas que deben fabricarse en un lote:

2

21

Donde: X = Es el tamaño del lote (número de piezas) S = Es el costo del montaje y desmontaje ($/pieza) D = Representa los días de trabajo por año U = Es la tasa de uso (pieza/día) T = Es un porcentaje que representa los impuestos y los seguros R = Es la tasa de retorno de la inversión (en porcentaje) C = Es el costo de la mano de obra y del material ($/pieza) A = Es el costo del almacenamiento anual ($/pieza) P = Es la tasa de producción (piezas/día) Un ejemplo de los datos de entrada es como sigue: S = 400, D = 243, U = 300, T = 0.05, R = 0.15, C = 0.72, A = 0.25, P = 1500. Elaborar un programa que: a) Lea un registro de entrada, con los datos requeridos b) Calcule para el registro el valor de X c) Imprima datos y resultados

7. La ecuación de movimiento uniformemente acelerado, que incluye el efecto del desplazamiento inicial,

está dada por la fórmula siguiente:

2

Donde: S = Es el desplazamiento en un tiempo T (metros) S0 = Es el desplazamiento inicial (metros) V0 = Es la velocidad inicial (metros/segundo)



A = Es la aceleración (metros/segundos2) T = Es el tiempo (segundos) Elaborar un programa que: a) Lea los valores requeridos b) Calcule el valor de S c) Imprima datos y cálculos

8. Para determinar el coeficiente de transferencia del calor total de un cambiador de flujo es necesario

conocer la diferencia media logarítmica de temperatura (Tm), la cual se calcula con la fórmula siguiente:

Las variables T1, T2, Ta, Tb son las mostradas en la siguiente figura:

Elaborar un programa que efectúe los siguientes procesos: a) Lea un registro de datos: T1, T2, Ta, Tb b) Calcule la diferencia media logarítmica de temperatura (Tm), si un registro no cumple la relación

expresada por la fórmula ( el denominador está indeterminado o es negativo) debe mostrarse un mensaje descriptivo

c) Imprimir datos y cálculos 9. Una de las leyes de la óptica se expresa con la ecuación siguiente:

1 1 1

Donde: F = Es la distancia focal de los lentes A = Es la distancia de los lentes al objeto B = Es la distancia de los lentes a la imagen Si A es positivo (A > 0), la imagen es una imagen real; si A es negativa (A< 0), se dice que la imagen es virtual. Si B es positivo (B > 0), la imagen es una imagen real; si B es negativa (B < 0 ), se dice quie la imagen es virtual. F es positiva (F>0) para lentes convergentes y negativa (F<0) para lentes divergentes. a) Calcule la distancia B para todos los valores de A = 1, 2, 3, …, 100 y F = 1, 2, 3, …, 100 b) Mostrar un mensaje apropiado para cada valor de B



10. La resistencia total de N resistores arreglados en paralelo es igual a:

11 1 1

Escriba un programa en C que:

a) Lea cuatro resistencia cuyos valores son R1, R2, R3 y R4 y que b) calcule la resistencia total Rt (Ver figura) c) Imprima datos y resultados

11. Escriba un programa que calcule la resultante de dos fuerzas coplanares F1 y F2 y el ángulo que esta

resultante forma con el eje de las x’s.

Los componentes horizontal y vertical de una fuerza F que forma un ángulo con el eje x viene dado por:

La resultante FR de dos fuerzas F1 y F2 que forman un ángulo 1 y 2 con el eje x puede obtenerse mediante las siguientes ecuaciones:

FRx = F1x + F2x FRy = F1y + F2y



Pruebe con F1 = 20, 1 = 300, F2 = 40, 2 = 700

12. El flujo del agua en un canal abierto viene dado aproximadamente por la ecuación de Chezy-Manning:

1.486 / /

Donde:

Q = Es el flujo del agua ( pies cúbicos por segundo) n = Es el coeficiente de fricción de Manning a = El área de la sección transversal del canal ( pies2) s = Es la pendiente del canal (lado sobre el cual corre el agua) y rh = Es el radio hidráulico (área dividido por el perímetro de la sección mojada) Para un canal en forma de rectángulo: d b

a = bd

2

b = Es el ancho del canal y d = Es la profundidad del agua en el canal

Escriba un programa que determine el flujo Q del agua, el área del canal y el radio hidráulico, en un canal dados los valores de b, d, n y s. Pruebe con b = 10 pies, d = 5 pies, s = 0.002 y n = 0.015



13. Para un circuito de corriente alterna que contiene una resistencia, capacitor e inductancia, la impedancia total, corriente, ángulo de fase, frecuencia de la resonancia y ancho de banda viene dado por:

21

2

Corriente =

Á 2

12

hertz

2

Donde:

R = Es la resistencia en ohms L = Es la inductancia en henrys C = Es la capacitancia en farads f = Es la frecuencia en hertz

Escriba un programa que lea R, L C, V y f y calcule la impedancia Z, la corriente I, el ángulo de fase, , la frecuencia de resonancia fres y el ancho de banda B.

Pruebe con: R = 300 ohms, L = 0.05 henry, C = 0.001 farads, V = 110 volts y f = 60 hertz.

14. Dada una estructura llamada Inventario, cuyos datos miembros son: el nombre del fabricante, el nombre del artículo, el número de piezas en el almacén y el precio de cada pieza, elaborar un programa que:

a) Lea los datos de la estructura b) Calcule el valor total de la piezas que hay en el almacén c) Imprima datos y resultados

La salida requerida es la siguiente:



SALIDA

15. Dada una estructura llamada Tiempo formada por los campos Hora, Minuto y Segundo. Leer una

hora determinada e imprimirla en formato de 12 horas o en formato de 24 horas. Dado que no se valida la entrada de la hora, pueden meterse valores erróneos, como se muestra en la salida.

La salida requerida es la siguiente: SALIDA

16. Dada una estructura llamada Cuenta, cuyos campos son los siguientes:

Balance, Tasa de Interes Anual

Nota: No se valida que el retiro sea correcto.

Se requiere obtener la siguiente salida:

Salida: Nombre del fabricante : Comercial Mexicana Artículo : Resistencia Número de piezas : 3 Precio de cada pieza : 6.00 Fabricante : Comercial Mexicana Articulo : Resistencia Precio Unitario : 6.00 Cantidad : 3 Valor total : 18.00

Salida: La cena se servirá a las 18:30:00 hora militar, que son las 6:30:00 PM hora estándar. Hora con valores inválidos: 29:73:00



SALIDA

17. Utilizando la estructura tm que viene junto con el lenguaje C++, escribir la fecha del sistema.


Fecha actual: 19-04-2009

18. Dada una estructura que contiene los siguientes campos:

Identificación del empleado, un apuntador al salario del empleado

a) Lea los datos del empleado b) Imprima los resultados


Salida: Introducir el estado actual de cuenta : 10000.00 Introducir la tasa de interes anual de cuenta : 12 Estado Actual de la cuenta: 10000.00 Tasa de interes anual : 12.00 Introducir el deposito de la cuenta : 5000.00 Estado Actual de la cuenta : 15000.00 Tasa de interes anual : 12.00 Introducir el retiro de la cuenta : 5000.00 Estado Actual de la cuenta : 10000.00 Tasa de interes anual : 12.00 CARGO DE LOS INTERESES MENSUALES Estado Actual de la cuenta : 10100.00 Tasa de interes anual : 12.00 CORRUPCION DE LOS DATOS Estado Actual de la cuenta : 1000000.00 Tasa de interes anual : 345.00

Salida: Dame la identificacion del empleado :12345 Dame el pago mensual del empleado :15000.00 Al empleado con identificación: 12345 se le pagó $15000.00



SOLUCION DEL EJERCICIO 14 ANALISIS DEL PROBLEMA

Se crean tres funciones: LeerInventario( ), ValorInventario( ) e ImprimirInventario ( ) cuyos prototipos son los siguientes:

void LeerInventario( Inventario *AptI ); float ValorInventario( const Inventario *AptI ); void ImprimirInventario( const Inventario *AptI );


/* Nombre del programa: EJER ESTRUC 14.CPP using namespace std; #include <iostream> //Para cout y cin //#include <stdlib.h> //Para malloc( ) struct Inventario { string Fabricante; string Articulo; int Cantidad; float PrecioUnitario; }; //Fin de la estructura Inventario{ } void LeerInventario( Inventario *AptI ); float ValorInventario( const Inventario *AptI ); void ImprimirInventario( const Inventario *AptI ); int main( void ) { system( "cls" ); Inventario *AptInventario; float ValorInven; /* Asignar memoria al puntero a la estructura. */ //AptInventario = ( Inventario * ) malloc( sizeof( Inventario) ); AptInventario = new Inventario; LeerInventario( AptInventario ); ValorInven = ValorInventario( AptInventario ); cout.setf( ios:: fixed ); cout.setf( ios:: showpoint ); cout.precision( 2 ); ImprimirInventario( AptInventario ); cin.ignore( ); cin.get( ); //free( AptInventario ); delete AptInventario; return 0; }// Fin de main( )



void LeerInventario( Inventario *AptI ) { cout << "Nombre del fabricante : "; getline( cin, AptI ->Fabricante ); cout << "Articulo : "; getline( cin, AptI -> Articulo ); cout << "Numero de piezas : "; cin >> AptI-> Cantidad; cout << "Precio de cada pieza : "; cin >> AptI -> PrecioUnitario; cout << endl; }//Fin de LeerInventario( ) float ValorInventario( const Inventario *AptI ) { return AptI -> Cantidad * AptI -> PrecioUnitario; }//Fin de ValorInventario( ) void ImprimirInventario( const Inventario *AptI ) { cout << "Fabricante : " << AptI -> Fabricante << endl; cout << "Articulo : " << AptI -> Articulo << endl; cout << "Precio Unitario : " << AptI -> PrecioUnitario << endl; cout << "Cantidad : " << AptI -> Cantidad << endl; cout << "Valor total : " << ValorInventario( AptI ) << endl; }//Fin de ImprimirInventario( )



SOLUCION DEL EJERCICIO 15


Se crean tres funciones: Leer( ), ImprimirHoraMilitar( ) e ImprimirHoraNormal( ) cuyos prototipos son los siguientes:

void Leer( Tiempo &RefT ); void ImprimirHoraMilitar( const Tiempo &RefT ); void ImprimirHoraNormal( const Tiempo &RefT );

CODIFICACION DEL PROGRAMA /* Nombre del programa: EJER ESTRUC 15.CPP */

using namespace std; #include <iostream> //Para cout y cin #include <iomanip> //Para setfill( ) y setw( ) struct Tiempo // Definición de la estructura { int Hora; // 0-23 int Minuto; // 0-59 int Segundo; // 0-59 }; //Fin de la estructura Tiempo{ } void Leer( Tiempo &RefT ); void ImprimirHoraMilitar( const Tiempo &RefT ); void ImprimirHoraNormal( const Tiempo &RefT ); int main( void ) { system( "cls" ); Tiempo HoraCena; Leer( HoraCena ); cout << "La cena se servira a las "; ImprimirHoraMilitar( HoraCena ); cout << " hora militar, " << endl << "que son las "; ImprimirHoraNormal( HoraCena ); cout << " hora estandar." << endl << endl; Leer( HoraCena ); cout << endl << "Hora con valores invalidos: "; ImprimirHoraMilitar( HoraCena ); cout << endl; cin.ignore( ); cin.get( ); return 0; }// Fin de main( )



void Leer( Tiempo &RefT ) { cout << "Dame la hora : "; cin >> RefT.Hora; cout << "Dame los minutos : "; cin >> RefT.Minuto; cout << "Dame los segundos : "; cin >> RefT.Segundo; cout << endl; }//Fin de Leer( ) // Imprime la hora en formato militar void ImprimirHoraMilitar( const Tiempo &Hm ) { cout << setfill( '0' )

<< setw( 2 ) << Hm.Hora << ":" << setw( 2 ) << Hm.Minuto << ":" << setw( 2 ) << Hm.Segundo; }// Fin de ImprimirHoraMilitar( ) void ImprimirHoraNormal( const Tiempo &Hn ) { cout << ( ( Hn.Hora == 0 || Hn.Hora == 12 ) ? 12 : Hn.Hora % 12 ) << ":"

<< setfill( '0' ) << setw( 2 ) << Hn.Minuto << ":" << setw( 2 ) << Hn.Segundo

<< ( Hn.Hora < 12 ? " AM" : " PM" ); }// Fin de ImprimirHoraNormal( )




Se crean cuatro funciones: LeerCuenta( ), SumarInteres( ), Deposito( ), Retiro( ) e ImprimirCuenta( ) cuyos prototipos son los siguientes:

void LeerCuenta( Cuenta &RefC ); void SumarInteres( Cuenta &RefC ); void Deposito( Cuenta &RefC ); void Retiro( Cuenta &RefC ); void ImprimirCuenta( const Cuenta &RefC );


/* Nombre del programa: EJER ESTRUC 16.CPP */ #include <iostream> //Para cout y cin using namespace std; struct Cuenta { float Balance; float TasaInteresAnual; }; void LeerCuenta( Cuenta &RefC ); void SumarInteres( Cuenta &RefC ); void Deposito( Cuenta &RefC ); void Retiro( Cuenta &RefC ); void ImprimirCuenta( const Cuenta &RefC ); int main( void ) { system( "cls" ); Cuenta Cuenta1; LeerCuenta( Cuenta1 ); cout.setf( ios::fixed ); cout.setf( ios::showpoint ); cout.precision( 2 ); ImprimirCuenta( Cuenta1 ); cin.get( ); Deposito( Cuenta1 ); ImprimirCuenta( Cuenta1 ); cin.get( ); Retiro( Cuenta1 ); ImprimirCuenta( Cuenta1 ); cin.get( ); cout << "CARGO DE LOS INTERESES MENSUALES" << endl; SumarInteres( Cuenta1 ); ImprimirCuenta( Cuenta1 ); cin.get( );



cout << "CORRUPCION DE LOS DATOS" << endl; Cuenta1.Balance = 1000000.00; Cuenta1.TasaInteresAnual = 345; ImprimirCuenta( Cuenta1 ); cin.get( ); return 0; }//Fin de main( ) void LeerCuenta( Cuenta &RefC ) { cout << "Introducir el estado actual de cuenta : "; cin >> RefC.Balance; cout << "Introducir la tasa de interés anual de cuenta : "; cin >> RefC.TasaInteresAnual; cout << endl; }//Fin de LeerCuenta( ) void SumarInteres( Cuenta &RefC ) { RefC.Balance = RefC.Balance + RefC.Balance * ( RefC.TasaInteresAnual / 12 / 100 ); }//Fin de SumarInteres( ) void Deposito( Cuenta &RefC ) { float Importe; cout << "Introducir el deposito de la cuenta : "; cin >> Importe; cout << endl; RefC.Balance = RefC.Balance + Importe; }//Fin de Deposito( ) void Retiro( Cuenta &RefC ) { float Importe; cout << "Introducir el retiro de la cuenta : "; cin >> Importe; cout << endl; RefC.Balance = RefC.Balance - Importe; }//Fin de Retiro( ) void ImprimirCuenta( const Cuenta &RefC ) { cout << "Estado Actual de la cuenta : " << RefC.Balance << endl << "Tasa de interes anual : " << RefC.TasaInteresAnual << endl << endl; }//Fin de ImprimirCuenta( )



SOLUCION DEL EJERCICIO 17


Se crean dos funciones: LeerFecha( ) e ImprimirFecha( ) cuyos prototipos son los siguientes:

tm *LeerFecha( void );

void ImprimirFecha( const tm *AptFecSis ); CODIFICACION DEL PROGRAMA /* Nombre del programa: EJER ESTRUC 17.CPP */

#include <iostream> //Para cout y cin #include <iomanip> //Para setfill( ) y setw( ) using namespace std; tm *LeerFecha( void ); void ImprimirFecha( tm *AptFecSis ); int main (void) { system( "cls" ); tm *AptFecSis; AptFecSis =LeerFecha( ); ImprimirFecha( AptFecSis ); cin.get( ); return 0; }//Fin de main( ) tm *LeerFecha( void ) { tm *AptFecSis; time_t Tiempo2; time( &Tiempo2 ); AptFecSis = localtime( &Tiempo2 ); return AptFecSis; }//Fin de LeerFecha( ) void ImprimirFecha( tm *AptFecSis ) { cout << "Fecha actual: " << setfill( '0' ) << setw( 2 ) << ( *AptFecSis).tm_mday << "-" << setw( 2 ) << ( *AptFecSis).tm_mon << "-" << setw( 2 ) << ( *AptFecSis).tm_year << endl; }//Fin de ImprimirFecha( )




Se crean dos funciones: Leer( ) e Imprimir( ) cuyos prototipos son los siguientes:

void Leer( Lista &RefL ); void Imprimir( const Lista &RefL );


using namespace std; #include <iostream> //Para cout y cin #include <iomanip> //Para setiosflags( ) struct Lista { int IdEmpleado; double *AptPagoMes; };//Fin de la Lista void Leer( Lista &RefL ); void Imprimir( const Lista &RefL ); int main( void ) { system( "cls" ); Lista L1; Leer( L1 ); cout << setiosflags( ios::fixed ) << setiosflags( ios::showpoint ) << setprecision( 2 ); Imprimir( L1 ); cin.ignore( ); cin.get( ); return 0; }//Fin de main( ) void Leer( Lista &RefL ) { cout << "Dame la identificacion del empleado : "; cin >> RefL.IdEmpleado; RefL.AptPagoMes = new double; cout << "Dame el pago mensual del empleado : "; cin >> *( RefL.AptPagoMes ); cout << endl; }//Fin de Leer( ) void Imprimir( const Lista &RefL ) { cout << setw( 6 )

<< "Al empleado con identificacion: " << RefL.IdEmpleado << " se le pago $" << *RefL.AptPagoMes << endl; }//Fin de Imprimir( )



DEFINICION DEL PROBLEMA [ESTRUC 05.CPP] En un programa definir una estructura llamada Empleado, formada por los siguientes campos:

RFC, Apellido paterno, Apellido materno, Nombre, Salario mensual y Tasa de impuesto

Crear un arreglo de 5 (en la salida se muestran sólo dos) elementos de tipo Empleado. Leerlos, realizar cálculos e imprimir datos y cálculos. SALIDA SOLICITUD DE DATOS DEL EMPLEADO RFC = 11111 Apellido paterno = Perez Apellido materno = Jolote Nombre = Juan Salario mensual = 10000.00 Tasa del Impuesto = .10 RFC = 22222 Apellido paterno = Avila Apellido materno = Sanchez Nombre = Pedro Salario mensual = 20000.00 Tasa del Impuesto = .20 IMPRESION DE DATOS DEL EMPLEADO RFC = 11111 Apellido paterno = Perez Apellido materno = Jolote Nombre = Juan Salario mensual = 10000.00 Tasa del impuesto = 0.10 Importe impuesto = 1000.00 Salario Neto = 9000.00 RFC = 22222 Apellido paterno = Avila Apellido materno = Sanchez Nombre = Pedro Salario mensual = 20000.00 Tasa del impuesto = 0.20 Importe impuesto = 4000.00 Salario Neto = 16000.00



ANALISIS DEL PROBLEMA Seguiremos la misma estrategia que hasta ahora hemos venido haciendo, esto es, resolveremos el problema para un empleado y posteriormente en el programa principal creamos un arreglo enviando elemento por elementos. De la definición del problema y del análisis de la salida se observa que se requieren las siguientes tareas:


void Leer( Empleado *AptObrero);

Dos funciones para calcular el importe del impuesto y el importe neto respectivamente. Sus prototipos son los siguientes:

float ImporteImpuesto( const Empleado *AptObrero );

float ImporteNeto( const Empleado *AptObrero);

Una función Imprimir( ) que imprima tanto los datos como los cálculos efectuados por cada empleado. Su prototipo es el siguiente:

void Imprimir( const Empleado *AptObrero );




/* Nombre del programa ESTRUC 05.CPP */ using namespace std; #include <iostream> //Para cout y cin #include <string> //Para getline( ) y la clase string struct Empleado { string RFC; string ApelPat; string ApelMat; string Nombre; float SalarioMensual; float TasaImpuesto; }; //Fin de la estructura Empleado{ } void Leer( Empleado *AptObrero); float ImporteImpuesto( const Empleado *AptObrero ); float ImporteNeto( const Empleado *AptObrero); void Imprimir( const Empleado *AptObrero ); int main (void) { system( “cls” ) const int NUM_EMPL = 5; Empleado TRABAJADORES[ NUM_EMPL ]; cout << "SOLICITUD DE DATOS DEL EMPLEADO" << endl; for( int i = 0 ; i < NUM_EMPL; i++ ) Leer( &TRABAJADORES[ i ] ); cout.setf( ios::fixed ); cout.setf( ios::showpoint ); cout.precision( 2 ); cout << "IMPRESION DE DATOS DEL EMPLEADO" << endl; for( int i = 0; i < NUM_EMPL; i++ ) Imprimir( &TRABAJADORES[ i ] ); cin.ignore( ); cin.get( ); return 0; }//Fin del main( )



void Leer( Empleado *AptObrero ) { cout << "RFC = "; getline( cin, AptObrero -> RFC ); cout << "Apellido paterno = "; getline( cin, AptObrero -> ApelPat ); cout << "Apellido materno = "; getline( cin, AptObrero -> ApelMat ); cout << "Nombre = "; getline( cin, AptObrero -> Nombre ); cout << "Salario mensual = "; cin >> AptObrero -> SalarioMensual; cout << "Tasa del Impuesto = "; cin >> AptObrero -> TasaImpuesto; cout << endl; fflush( stdin ); //Para limpiar el buffer de entrada. Se quedó un Enter. }//Fin de Leer( ) float ImporteImpuesto( const Empleado *AptObrero ) { return ( AptObrero -> SalarioMensual ) * ( AptObrero -> TasaImpuesto ); }//Fin de ImporteImpuesto( ) float ImporteNeto( const Empleado *AptObrero ) { return ( AptObrero -> SalarioMensual ) - ImporteImpuesto( AptObrero ); }//Fin de ImporteNeto( ) void Imprimir( const Empleado *AptObrero ) { cout << "RFC = " << AptObrero -> RFC << endl << "Apellido paterno = " << AptObrero -> ApelPat << endl << "Apellido materno = " << AptObrero -> ApelMat << endl << "Nombre = " << AptObrero -> Nombre << endl << "Salario mensual = " << AptObrero -> SalarioMensual << endl << "Tasa del impuesto = " << AptObrero -> TasaImpuesto << endl << endl << "Importe impuesto = " << ImporteImpuesto( AptObrero ) << endl << "Salario Neto = " << ImporteNeto( AptObrero ) << endl << endl; }//Fin de Imprimir( )



DEFINICION DEL PROBLEMA [ESTRUC 06.CPP] Modificar el programa ESTRUC 05.CPP, de tal manera, que se maneje el arreglo dentro de la función, en vez de hacerlo en el programa principal, como se hizo en el programa anterior. Esto modifica el problema notoriamente. SALIDA La misma salida que el programa ESTRUC 05.CPP. ANALISIS DEL PROBLEMA

Se modificarán las funciones Leer( ) e Imprimir( ) en sus parámetros, para que ahora reciba al arreglo como arreglo. Los nuevos prototipos son los siguientes:

void Leer( Empleado Obreros[ ], const int NUM_EMPL );

void Imprimir( const Empleado Obreros[ ], const int NUM_EMPL );

En el cuerpo de estas funciones, se ilustrarán el uso de la notación de arreglo con índice, el nombre del arreglo como apuntador utilizando el operador flecha, el nombre del arreglo como apuntador utilizando el operador punto. En estos dos últimos casos se usa la dirección base y el desplazamiento.




/* Nombre del programa: ESTRUC 06.CPP*/ using namespace std; #include <iostream> //Para cout y cin #include <string> //Para getline( ) y la clase string struct Empleado { string RFC; string ApelPat; string ApelMat; string Nombre; float SalarioMensual; float TasaImpuesto; }; //Fin de la estructura Empleado{ } void Leer( Empleado Obreros[ ], const int NUM_EMPL ); float ImporteImpuesto( const Empleado *AptTrabajador ); float ImporteNeto( const Empleado *AptTrabajador); void Imprimir( const Empleado Obreros[ ], const int NUM_EMPL ); int main (void) {

system( “cls” ); const int NUM_EMPL = 5; Empleado Obreros[ NUM_EMPL ]; cout << "SOLICITUD DE DATOS DEL EMPLEADO" << endl; Leer( Obreros, NUM_EMPL ); cout.setf( ios::fixed ); cout.setf( ios::showpoint ); cout.precision( 2 ); cout << "IMPRESION DE DATOS DEL EMPLEADO" << endl; Imprimir( Obreros, NUM_EMPL ); cin.ignore( );

cin.get( ); return 0; }//Fin del main( )



void Leer( Empleado Obreros[ ], const int NUM_EMPL ) { for( int i = 0; i < NUM_EMPL; i++ ) { cout << "RFC = "; getline( cin, Obreros[ i ].RFC ); cout << "Apellido paterno = "; getline( cin, Obreros[ i ].ApelPat ); cout << "Apellido materno = "; getline( cin, ( Obreros + i ) -> ApelMat ); cout << "Nombre = "; getline( cin, ( Obreros + i ) -> Nombre ); cout << "Salario mensual = "; cin >> ( * ( Obreros + i ) ).SalarioMensual; cout << "Tasa del Impuesto = "; cin >> ( * ( Obreros + i ) ).TasaImpuesto; cout << endl; fflush( stdin ); //Para limpiar el buffer de entrada. Se quedó un Enter }//Fin del for }//Fin de Leer( ) float ImporteImpuesto( const Empleado *AptTrabajador ) { return ( AptTrabajador -> SalarioMensual ) * ( AptTrabajador -> TasaImpuesto ); }//Fin de ImporteImpuesto( ) float ImporteNeto( const Empleado *AptTrabajador ) { return ( AptTrabajador -> SalarioMensual ) - ImporteImpuesto( AptTrabajador ); }//Fin de ImporteNeto( ) void Imprimir( const Empleado Obreros[ ], const int NUM_EMPL ) { for( int i = 0; i < NUM_EMPL; i++ ) { cout << "RFC = " << ( Obreros + i ) -> RFC << endl << "Apellido paterno = " << ( Obreros + i ) -> ApelPat << endl << "Apellido materno = " << Obreros[ i ].ApelMat << endl << "Nombre = " << Obreros[ i ].Nombre << endl << "Salario mensual = " << ( * ( Obreros + i ) ).SalarioMensual << endl << "Tasa del impuesto = " << ( * ( Obreros + i ) ).TasaImpuesto << endl << endl << "Importe impuesto = " << ImporteImpuesto( &Obreros[ i ] ) << endl << "Salario Neto = " << ImporteNeto( &Obreros[ i ] ) << endl << endl; }//Fin del for }//Fin de Imprimir( )



Vectores y matrices dentro de estructuras

También puede declarar vectores o matrices dentro de una estructura. Considere el siguiente ejemplo. En él, uno de

los miembros de la estructura es una matriz de dos dimensiones. Recuerde que ya empleo vectores de caracteres para representar cadenas de caracteres en estructuras anteriores. En esto no hay ninguna diferencia.

#include <iostream.h> //Para cout y cin struct Estructura { float Matriz [ 5 ] [ 6 ]; int Edad; float Promedio; }; void main( void ) { }//Fin de main( )

Arreglos multidimensionales de estructuras

También puede tener arreglos multidimensionales cuyos elementos sean estructuras. Considere el siguiente ejemplo.

Aquí se presenta una matriz de dos dimensiones cuyos elementos son estructuras que contienen tres miembros, uno de ellos es a su vez una matriz de dos dimensiones.

#include <iostream.h> //Para cout y cin struct Estructura { float Matriz [ 5 ] [ 6 ]; int Edad; float Promedio; };

Estructura MatrizComplicada[ 3 ] [ 2 ]; void main( void ) { }//Fin de main( )

Como se puede observar, matrizComplicada[ 3 ] [ 2 ] es una matriz de dos dimensiones de tipo estructura. De esta

forma se tiene una matriz que consta de 3 2 = 6 estructuras, cada una de las cuales contiene a su vez tres miembros, uno de los cuales es también una matriz.



La siguiente estructura crea un arreglo de estructuras de 100 empleados. Dentro de cada estructura existe otro arreglo de

estructuras llamado fecha que corresponde a la fecha de despido del empleado o a su primera contratación o a su última

contratación. Inicializar los miembros de fecha con los datos referentes al día de hoy.

struct Empleado { char Nombre[ 64 ]; int Edad;

char SS[ 11 ]; int ClavePago; float Salario; unsigned int NumeroEmpleado;

struct Fecha

{ int Dia; int Mes;

int Anhio; } SituacionEmpleado[ 3 ]; //Fin de la subestructura Fecha } EmpleadoCia[ 100 ]; //Fin de la superestructura empleado EmpleadoCia[ 10 ].SituacionEmpleado[ 0 ].Dia = 1; EmpleadoCia[ 10 ].SituacionEmpleado[ 0 ].Mes = 9; EmpleadoCia[ 10 ].SituacionEmpleado[ 0 ].Anhio = 2009;



DEFINICION DEL PROBLEMA [ESTRUC 07.CPP] Elaborar un programa que contenga una estructura llamada Cilindro. Esta estructura esta formada por dos estructuras: El Punto y el Circulo y un dato que es la altura. La figura siguiente muestra este anidamiento:

Cilindro (estructuras anidadas) Diagrama jerarquico Relación “tiene un” Relación “es un” Los campos por estructura son los siguientes: PUNTO

La coordenada x, la coordenada Y

CIRCULO

El radio

CILINDRO

La estructura Punto, La estructura Circulo y la altura.

Punto

Circulo

Cilindro

Punto Circulo



SALIDA DATOS DEL CILINDRO DATOS DEL PUNTO Dame la coordenada x del punto: 10 Leer( ) Dame la coordenada y del punto: 20 Leer( ) DATOS DEL CIRCULO Dame el radio del circulo : 1.0 Leer( ) Dame el valor de la altura : 1.0 VALORES DEL CILINDRO Las coordenadas del punto son : [10.00, 20.00] Imprimir( ) LOS VALORES DEL CIRCULO SON Radio = 1.00 Diametro = 2.00 Diametro( ) Perimetro = 6.28 Perimetro( ) Imprimir( ) Imprimir( ) Area = 3.14 Area( ) Area Lateral = 6.28 AreaLateral( ) Area Total = 12.57 AreaTotal( ) Volumen = 3.14 Volumen( ) ANALISIS DEL PROBLEMA

De la definición del problema y del análisis de la salida se observan que se requieren las siguientes funciones:

Tres funciones Leer( ), una para el Punto, otra para el Circulo y una más para el Cilindro. Como los parámetros son distintos, puede utilizarse funciones sobrecargadas.

Tres funciones Imprimir( ), una para el Punto, otra para el Circulo y otra más para el Cilindro.

Como los parámetros son distintos, pueden utilizarse funciones sobrecargadas.

Para el Círculo se requieren realizar tres cálculos: para obtener el diámetro, el perímetro y el área.

Para el Cilindro se requieren realizar tres cálculos: para obtener el area lateral, el área total y el volumen.

Estas funciones organizadas por estructura, con sus respectivos prototipos son:



PARA EL PUNTO

Una función Leer( ), con el siguiente prototipo:

void Leer( Punto &RefP );

Una función Imprimir( ), con el siguiente prototipo:

void Imprimir( const Punto &RefP );

PARA EL CIRCULO

Una función Leer( ), con el siguiente prototipo:

void Leer( Circulo &RefC );


void Imprimir( const Circulo &RefC );

Dentro de la función Imprimir( ) se llaman a las funciones para realizar cálculos:

o Una función Diametro( ) para calcular el diámetro del Circulo, con el siguiente prototipo:

float Diametro( const Circulo &RefC );

o Una función Perímetro( ) para calcular el perímetro del Círculo, con el siguiente prototipo:

float Perimetro( const Circulo &RefC );

o Una función Area( ) para calcular el área del Círculo, con el siguiente prototipo:

float Area( const Circulo &RefC );

PARA EL CILINDRO

Una función Leer( ) con el siguiente prototipo:

void Leer( Cilindro &RefCil );


void Imprimir( const Cilindro RefCil );

Dentro de la función Imprimir( ) se llaman a las funciones para realizar cálculos:

o Una función AreaLateral( ) para calcular el área lateral del Cilindro, con el siguiente prototipo:

float AreaLateral( const Cilindro &RefCi1 );



o Una función AreaTotal( ) para calcular el área total del Cilindro, con el siguiente prototipo:

float AreaTotal( const Cilindro &RefCil );

o Una función Volumen( ) para calcular el volumen del Cilindro, con el siguiente prototipo:

float Volumen( const Cilindro &RefCi1 );

Nota: Las funciones serán definidas inmediatamente despues de las respectivas estructuras, sin utilizar

prototipos, esto nos obliga a ser cuidadoso en el orden en que se definen las funciones.




/* Nombre del programa: ESTRUC 07.CPP*/ using namespace std; #include <iostream> //Para cout y cin #include <cmath> //Par M_PI struct Punto { float CoordX; float CoordY; }; //Fin de la estructura Punto{ } struct Circulo { double Radio; }; //Fin de la estructura Circulo{ } struct Cilindro { Punto P; Circulo C; float Altura; };//Fin de la estructura Cilindro{ } // Prototipos del Punto void Leer( Punto &RefP ); void Imprimir( const Punto &RefP ); // Prototipos de Circulo void Leer( Circulo &RefC ); float Diametro( const Circulo &RefC ); float Perimetro( const Circulo &RefC ); float Area( const Circulo &RefC ); void Imprimir( const Circulo &RefC ); // Prototipos del Cilindro void Leer( Cilindro &RefCil ); float AreaLateral( const Cilindro &RefCil ); float AreaTotal( const Cilindro &RefCil ); float Volumen( const Cilindro &RefCil ); void Imprimir( const Cilindro RefCil ); int main( void ) { systen( “cls” ); Cilindro Cil1; cout.setf( ios::fixed ); cout.setf( ios::showpoint ); cout.precision( 2 ); Leer( Cil1 ); Imprimir( Cil1 ); cin.ignore( );

cin.get( ); return 0; }//Fin del main( )



// Funciones del Punto void Leer( Punto &RefP ) { cout << endl << endl; cout << "\tDATOS DEL PUNTO" << endl; cout << "\tDame la coordenada x del punto: "; cin >> RefP.CoordX; cout << "\tDame la coordenada y del punto: "; cin >> RefP.CoordY; }//Fin de Leer( ) void Imprimir( const Punto &RefP ) { cout << endl << endl; cout << "\tLas coordenadas del punto son: [" << RefP.CoordX << ", " << RefP.CoordY << "]" << endl; }//Fin de Imprimir( ) // Funciones del Circulo void Leer( Circulo &RefC ) { cout << endl << endl; cout << "\tDATOS DEL CIRCULO" << endl; cout << "\tDame el radio del circulo: "; cin >> RefC.Radio; }//Fin de Leer( ) float Diametro( const Circulo &RefC ) { return( 2 * RefC.Radio ); }//Fin de Diametro( ) float Perimetro( const Circulo &RefC ) { return( Diametro( RefC ) * M_PI ); }//Fin de Perimetro( ) float Area( const Circulo &RefC ) { return( M_PI * pow( RefC.Radio, 2.0 ) ); }//Fin de Area( ) void Imprimir( const Circulo &RefC ) { cout << endl << endl; cout << "\tLOS VALORES DEL CIRCULO SON" << endl; cout << "\tRadio = " << RefC.Radio << endl << "\tDiametro = " << Diametro( RefC ) << endl << "\tPerimetro = " << Perimetro( RefC ) << endl << "\tArea = " << Area( RefC ) << endl << endl; }//Fin de Imprimir( ) //Funciones del Cilindro void Leer( Cilindro &RefCil ) { cout << endl << endl; cout << "DATOS DEL CILINDRO" << endl; Leer( RefCil.P ); Leer( RefCil.C ); cout << endl; cout << "\tDame el valor de la altura : "; cin >> RefCil.Altura; }//Fin de Leer( ) float AreaLateral( const Cilindro &RefCil ) { return( Perimetro( RefCil.C ) * RefCil.Altura ); }//Fin de AreaLateral( )



float AreaTotal( const Cilindro &RefCil ) { return( AreaLateral( RefCil ) + 2 * Area( RefCil.C ) ); }//Fin de AreaTotal( ) float Volumen( const Cilindro &RefCil ) { return( Area( RefCil.C ) * RefCil.Altura ); }//Fin de Volumen( ) void Imprimir( const Cilindro RefCil ) { cout << endl << endl; cout << "VALORES DEL CILINDRO" << endl; Imprimir( RefCil.P ); Imprimir( RefCil.C ); cout << "\tAltura = " << RefCil.Altura << endl << "\tArea Lateral = " << AreaLateral( RefCil ) << endl << "\tArea Total = " << AreaTotal( RefCil ) << endl << "\tVolumen = " << Volumen( RefCil ) << endl << endl; }//Fin de Imprimir( )



DEFINICION DEL PROBLEMA [ESTRUC 08.CPP] Resolver el problema ESTRUC 14.CPP, utilizando el anidamiento que se muestra en la figura: CILINDRO (estructuras anidadas) Diagrama jerárquico

Relación “tiene un” Relación “es un” SALIDA La misma salida que el programa ESTRUC 07.CPP solo que mostrando el anidamiento mediante tabuladores. ANALISIS DEL PROBLEMA El mismo que el del programa ESTRUC 07.CPP CODIFICACION DEL PROBLEMA

Circulo

Punto

/* Nombre del programa: ESTRUC 08.CPP */ using namespace std; #include <iostream> //Para cout y cin #include <cmath> //Par M_PI struct Punto { float CoordX; float CoordY; }; //Fin de la estructura Punto{ } struct Circulo { Punto P; float Radio; }; //Fin de la estructura Circulo{ } struct Cilindro { Circulo C; float Altura; };//Fin de la estructura Cilindro{ } // Prototipos de Punto void Leer( Punto &RefP ); void Imprimir( const Punto &RefP );

Punto

Circulo

Cilindro



// Prototipos del Circulo void Leer( Circulo &RefC ); float Diametro( const Circulo &RefC ); float Perimetro( const Circulo RefC ); float Area( const Circulo &RefC ); void Imprimir( const Circulo &RefC ); // Prototipos del Cilindro void Leer( Cilindro &RefCil ); float AreaLateral( const Cilindro &RefCil ); float AreaTotal( const Cilindro &RefCil ); float Volumen( const Cilindro &RefCil ); void Imprimir( const Cilindro &RefCil ); int main( void ) { system( “cls” ); Cilindro Cil1; Leer( Cil1 ); cout.setf( ios::fixed ); cout.setf( ios::showpoint ); cout.precision( 2 ); Imprimir( Cil1 ); cin.ignore( );

cin.get( ); return 0; }//Fin del main( ) // Funciones del Punto void Leer( Punto &RefP ) { cout << endl << endl; cout << "\t\tDATOS DEL PUNTO" << endl; cout << "\t\tDame la coordenada x del punto: "; cin >> RefP.CoordX; cout << "\t\tDame la coordenada y del punto: "; cin >> RefP.CoordY; }//Fin de Leer( ) void Imprimir( const Punto &RefP ) { cout << endl << endl; cout << "\t\tVALORES DEL PUNTO" << endl; cout << "\t\tLas coordenadas del punto son: [" << RefP.CoordX << ", " << RefP.CoordY << "]" << endl << endl; }//Fin de Imprimir( ) // Funciones del Circulo void Leer( Circulo &RefC ) { cout << endl << endl; cout << "\tDATOS DEL CIRCULO" << endl; Leer( RefC.P ); cout << endl; cout << "\tDame el radio del circulo: "; cin >> RefC.Radio; }//Fin de Leer( )



float Diametro( const Circulo &RefC ) { return( 2 * RefC.Radio ); }//Fin de Diametro( ) float Perimetro( const Circulo RefC ) { return( Diametro( RefC ) * M_PI ); }//Fin de Perimetro( ) float Area( const Circulo &RefC ) { return( M_PI * pow( RefC.Radio, 2.0 ) ); }//Fin de Area( ) void Imprimir( const Circulo &RefC ) { cout << endl << endl; cout << "\tVALORES DEL CIRCULO" << endl; Imprimir( RefC.P ); cout << "\tRadio = " << RefC.Radio << endl << "\tDiametro = " << Diametro( RefC ) << endl << "\tPerimetro = " << Perimetro( RefC ) << endl << "\tArea = " << Area( RefC ) << endl << endl; }//Fin de Imprimir( ) // Funciones del Cilindro void Leer( Cilindro &RefCil ) { cout << endl << endl; cout << "DATOS DEL CILINDRO" << endl; Leer( RefCil.C ); cout << endl; cout << "\tDame el valor de la altura : "; cin >> RefCil.Altura; }//Fin de Leer( ) float AreaLateral( const Cilindro &RefCil ) { return( Perimetro( RefCil.C ) * RefCil.Altura ); }//Fin de AreaLateral( ) float AreaTotal( const Cilindro &RefCil ) { return( AreaLateral( RefCil ) + 2 * Area( RefCil.C ) ); }//Fin de AreaTotal( ) float Volumen( const Cilindro &RefCil ) { return( Area( RefCil.C ) * RefCil.Altura ); }//Fin de Volumen( ) void Imprimir( const Cilindro &RefCil ) { cout << endl << endl; cout << "VALORES DEL CILINDRO" << endl; Imprimir( RefCil.C ); cout << "\tArea Lateral = " << AreaLateral( RefCil ) << endl << "\tArea Total = " << AreaTotal( RefCil ) << endl << "\tVolumen = " << Volumen( RefCil ) << endl << endl; }//Fin de Imprimir( )



EJERCICIOS

1. Un rectángulo se puede definir mediante las coordenadas de dos de sus puntos: las coordenadas del punto superior izquierdo y las coordenadas del punto inferior derecho. Es decir, se tiene una estructura anidada formadas por un Rectangulo y un punto. Los datos miembros de cada estructura son los siguientes:

Punto : Las coordenas X y Y Rectangulo : Los dos puntos opuestos del rectángulo (esi = esquina superior izquierda, eid = esquina

inferior derecha) a) Leer e imprimir los datos del punto b) Leer los datos del rectangulo c) Calcular el área del rectangulo d) Imprimir datos y resultados del rectangulo


2. Una farmacia desea almacenar sus productos en una estructura de registros. Cada registro tiene los

siguientes campos:

Código Nombre Descripción del medicamento (antibiótico, analgésico, etc. ) Laboratorio Proveedor, Precio Porcentaje de IVA Cantidad en existencia Fecha de caducidad

Salida: LEER LOS DATOS DEL RECTANGULO Dame la coordenada X: 1 Dame la coordenada Y: 2 Dame la coordenada X: 4 Dame la coordenada Y: 8 IMPRESION DE LOS DATOS DEL RECTANGULO Las coordenadas del punto son: [1, 2 ] Las coordenadas del punto son: [4, 8 ] Area del rectangulo = 18



La fecha deberá guardar por separado el día, mes y año. Diseñe la estructura de datos y un programa que cargue los datos en un registro e imprima el mismo.


3. Podemos definir un polígono mediante las coordenadas de cada uno de sus lados. Diseñar la estructura de

datos que permita definir un polígono de n lados – con un máximo de 30 lados – y crear un algoritmo para introducir las coordenadas cartesianas de cada uno de sus lados. Finalmente mediante una función mostrar las coordenadas de cada uno de sus lados.

La salida requerida es la siguiente:

SALIDA

Salida: Dame código medicamento : ABCD1234 Dame nombre medicamento : Cafiaspirina Dame descripción medicamento : Analgésico Dame laboratorio medicamento : Fizer Dame proveedor medicamento : Farmacia Juan de Dios Dame precio medicamento : 12.75 Dame porcentaje IVA : .15 Dame cantidad en existencia : 245 Dame Dia, Mes, Año caducidad : 1 1 2005 Código medicamento : ABCD1234 Nombre medicamento : Cafiaspirina Descripción medicamento : Analgésico Laboratorio medicamento : Fizer Proveedor medicamento : Farmacia Juan de Dios Precio medicamento : 12.75 Porcentaje IVA : 0.15 Cantidad en existencia : 245 Fecha : 1/1/2005

Salida: Dame el número de lados [3,30]: 2 Dato erroneo. Intentelo de nuevo Enter para continuar. Dame el numero de lados [3,30]: 3 Dame Coordenada X: 1 Dame Coordenada Y: 1 Dame Coordenada X: 2 Dame Coordenada Y: 2 Dame Coordenada X: 3 Dame Coordenada Y: 3 LAS COORDENADAS DE LOS LADOS SON: Las coordenadas del lado 1 son: (1, 1) Y (2, 2) Las coordenadas del lado 2 son: (2, 2) Y (3, 3) Las coordenadas del lado 3 son: (3, 3) Y (1, 1)



4. Dado una estructura llamada Estudiante, formada por los siguientes campos:

Nombre del estudiante, boleta, especialidad, calificaciónes de sus exámenes.

El campo calificaciónes de sus exámenes es un arreglo. Calcular el promedio de sus calificaciones en formato numérico y en carácter. La salida requerida es la siguiente: SALIDA

5. Resolver el ejercicio anterior utilizando estructuras anidadas. Una para las calificaciones y otra para

estudiante.

La salida requerida es la misma.

6. Una empresa tiene almacenados a sus vendedores en un registro. Por cada vendedor se guarda su :

Registro Federal de Causantes Apellidos Nombre Zona Sueldo Base Ventas Mensuales Las ventas mensuales será un vector de 12 elementos que guardará las ventas realizadas en cada uno de los meses. Total Anual será la suma de las ventas mensuales del vendedor. La comisión se calculará

Salida: Escriba el nombre del estudiante : Miguel Angel Toledo Escriba la boleta del estudiante : 1 Escriba la especialidad del estudiante : Fisico Matemático ¿Cuántos registros de prueba hay? : 5 Escriba calificaciones 1 : 6 Escriba calificaciones 2 : 7 Escriba calificaciones 3 : 8 Escriba calificaciones 4 : 9 Escriba calificaciones 5 : 10 Nombre del estudiante : Miguel Angel Toledo Boleta del estudiante : 1 Especialidad : Fisico Matemático Calificaciones : 6, 7, 8, 9, 10, Promedio calificaciones : 8 Calificación final : B



aplicando un porcentaje variable al Total Anual del vendedor. Dicho porcentaje variará según las ventas anuales del vendedor, según la siguiente tabla: Menos de 1,500,000.00 0.00% Desde 1,500,000.00 hasta 2,150,000.00 13.75% Desde 2,150,000.00 hasta 2,900,000.00 16.50% Desde 2,900,000.00 hasta 3,350,000.00 17.60% Más de 3,350,000.00 18.85% Dicha tabla la habrá de cargar el usuario introduciendo exclusivamente el límite superior y el porcentaje de comisión. Diseñar las estructuras de datos necesarias y realizar un algoritmo que permita Leer los dados del empleado La tabla de comisiones Calcule el Total Anual y Obtenga la Comisión que se lleva el empleado mediante la tabla descrita anteriormente.



SALIDA

Salida: Limite Superior 1 : 1500001 Tasa comisión 1 : 0.00 Limite Superior 2 : 2150001 Tasa comisión 2 : 13.75 Limite Superior 3 : 2900001 Tasa comisión 3 : 16.50 Limite Superior 4 : 3350001 Tasa comisión 4 : 17.60 Limite Superior 5 : 9999999 Tasa comisión 5 : 18.85 MOSTRAR CONTENIDO DE LA TABLA Limite Superior 1 : 1500001 Tasa comisión 1 : 0 Limite Superior 2 : 2150001 Tasa comisión 2 : 13.75 Limite Superior 3 : 2900001 Tasa comisión 3 : 16.5 Limite Superior 4 : 3350001 Tasa comisión 4 : 17.6 Limite Superior 5 : 9999999 Tasa comisión 5 : 18.85 INTRODUZCA DATOS DEL VENDEDOR RFC : TOMM679594 Apellidos : Pérez Jolote Nombre : Juan Zona : CENTRO Sueldo Base : 10000.00 Ventas Mensuales : Mes[1] = 200000.00 Mes[2] = 200000.00 Mes[3] = 200000.00 Mes[4] = 200000.00 Mes[5] = 200000.00 Mes[6] = 200000.00 Mes[7] = 200000.00 Mes[8] = 200000.00 Mes[9] = 200000.00 Mes[10] = 200000.00 Mes[11] = 200000.00 Mes[12] = 200000.00



DATOS DE SALIDA DEL VENDEDOR RFC : TOMM679594 Apellidos : Pérez Jolote Nombre : Juan Zona : CENTRO Sueldo Base : 10000 Ventas Mensuales : Mes[1] = 200000.00 Mes[2] = 200000.00 Mes[3] = 200000.00 Mes[4] = 200000.00 Mes[5] = 200000.00 Mes[6] = 200000.00 Mes[7] = 200000.00 Mes[8] = 200000.00 Mes[9] = 200000.00 Mes[10] = 200000.00 Mes[11] = 200000.00 Mes[12] = 200000.00 Total Anual : 2400000.00 Importe Comisión : 396000.00



SOLUCION AL EJERCICIO 1 ANALISIS DEL PROBLEMA

Se requieren la siguiente función para el punto:

void Leer( Punto &RefP ); void Imprimir( const Punto &RefP );

Se requieren la siguiente función para el rectángulo:

void Leer( Rectangulo &RefR );

double Area( const Rectangulo &RefR ); void Imprimir( const Rectangulo &RefR );


/* Nombre del programa: EJER ESTRUC 01.CPP */ #include <iostream> //Para cout y cin #include <cmath> //Para fabs() using namespace std; struct Punto { double X; double Y; };//Fin de la estructura Punto{ } struct Rectangulo { Punto ESI; // Esquina superior izquierda Punto EID; // Esquina supererior derecha };//Fin de la estructura Rectangulo{ } //Prototipos del Punto{ } void Leer( Punto &RefP ); void Imprimir( const Punto &RefP ); //Prototipos del Rectangulo{ } void Leer( Rectangulo &RefR ); double Area( const Rectangulo &RefR ); void Imprimir( const Rectangulo &RefR ); int main( void ) { clrscr( ); Rectangulo R1; cout << "LEER LOS DATOS DEL RECTANGULO" << endl; Leer( R1 ); cout << "IMPRESION DE LOS DATOS DEL RECTANGULO" << endl; Imprimir( R1 ); cin.ignore( ); cin.get( ); return 0; }//Fin de main()



void Leer( Punto &RefP ) { cout << "Dame la coordenada X: "; cin >> RefP.X; cout << "Dame la coordenada Y: "; cin >> RefP.Y; cout << endl; }//Fin de Leer( ) void Imprimir( const Punto &RefP ) { cout << "Las coordenadas del punto son: [" << RefP.X << ", " << RefP.Y << " ]" << endl << endl; }//Fin de Imprimir( ) void Leer( Rectangulo &RefR ) { Leer( RefR.ESI ); Leer( RefR.EID ); }//Fin de Leer( ) double Area( const Rectangulo &RefR ) { return ( fabs( RefR.ESI.X - RefR.EID.X ) * fabs( RefR.ESI.Y - RefR.EID.Y ) ); }//Fin de Area( ) void Imprimir( const Rectangulo &RefR ) { Imprimir( RefR.ESI ); Imprimir( RefR.EID ); cout << "Area del rectangulo = " << Area( RefR ) << endl << endl; }//Fin de Imprimir( )




Se requieren la siguientes funciones: o Para las estructura Fecha se requiera una función para leer y otra para imprimir. Sus

prototipos son los siguientes:

void Leer( Fecha &RefF ); void Imprimir( const Fecha &RefF );

o Para la estructura Medicina se requieren una función para leer y otra para imprimir. Sus prototipos son los siguientes:

void Leer( Medicamentos &RefM ); void Imprimir( const Medicamentos &RefM );


using namespace std; #include <iostream> //Para cout y cin #include <iomanip> //Para setw( ) y setfill( ); struct Fecha { int Dia; int Mes; int Annio; };//Fin de la estructura Fecha{ } struct Medicamentos { string Codigo; string Nombre; string Descripcion; string Laboratorio; string Proveedor; float Precio; float IVA; int Existencia; Fecha Caducidad; }; // Fin de la estructura Medicamentos //Prototipos de Fecha{ } void Leer( Fecha &RefF ); void Imprimir( const Fecha &RefF ); //Prototipos de Medicamentos{ } void Leer( Medicamentos &RefM ); void Imprimir( const Medicamentos &RefM ); int main( void ) { system( "cls" ); Medicamentos Medicina; Leer( Medicina ); Imprimir( Medicina ); cin.ignore( ); cin.get( ); return 0; }//Fin de main( )



void Leer( Fecha &RefF ) { cout << "Dame Dia, Mes, Año caducidad: "; cin >> RefF.Dia >> RefF.Mes >> RefF.Annio; cout << endl; }//Fin de Leer( ) void Imprimir( const Fecha &RefF ) { cout << setfill( '0' ) << setw( 2 ) << RefF.Dia << '/' << setw( 2 ) << RefF.Mes << '/' << setw( 4 ) << RefF.Annio << endl << endl; }//Fin de Imprimir( ) void Leer( Medicamentos &RefM ) { cout << "Dame codigo medicamento : "; getline( cin, RefM.Codigo ); cout << "Dame nombre medicamento : "; getline( cin, RefM.Nombre ); cout << "Dame descripción medicamento : "; getline( cin, RefM.Descripcion ); cout << "Dame laboratorio medicamento : "; getline( cin, RefM.Laboratorio ); cout << "Dame proveedor medicamento : "; getline( cin, RefM.Proveedor ); cout << "Dame precio medicamento : "; cin >> RefM.Precio; cout << "Dame porcentaje IVA : "; cin >> RefM.IVA; cout << "Dame cantidad en existencia : "; cin >> RefM.Existencia; Leer( RefM.Caducidad ); }//Fin Leer( ) void Imprimir( const Medicamentos &RefM ) { cout << "Codigo medicamento : " << RefM.Codigo << endl; cout << "Nombre medicamento : " << RefM.Nombre << endl; cout << "Descripcion medicamento: " << RefM.Descripcion << endl; cout << "Laboratorio medicamento : " << RefM.Laboratorio << endl; cout << "Proveedor medicamento : " << RefM.Proveedor << endl; cout << "Precio medicamento : " << RefM.Precio << endl; cout << "Porcentaje IVA : " << RefM.IVA << endl; cout << "Cantidad en existencia : " << RefM.Existencia << endl; cout << "Fecha : "; Imprimir( RefM.Caducidad ); }//Fin de Imprimir( )




Se requieren la siguiente función para el punto:

void Leer( Punto &RefP ) void Imprimir( const Punto &RefP )

Se requieren la siguiente función para el polígono:

bool ValidarLados( const int NumLados ); int Leer( void ); void Leer( Poligono ArregloPoligono[ ], int NumLados ); void Imprimir( Poligono ArregloPoligono[ ], int NumLados );


/* Nombre del programa: EJER ESTRUC 03.CPP */ #include <iostream> //Para cout y cin using namespace std; struct Punto { float CoordX; float CoordY; }; //Fin de la clase Punto{ } struct Poligono { Punto PuntoInicial; Punto PuntoFinal; }; //Fin de la clase Poligono{ } void Leer( Punto &RefP ); void Imprimir( const Punto &RefP ); int Leer( void ); void Leer( Poligono ArregloPoligono[ ], int NumLados ); void Imprimir( Poligono ArregloPoligono[ ], int NumLados ); int main( void ) { system( "cls" ); int NumLados; const int MAXLADOS = 30; Poligono ArregloPoligono[ MAXLADOS ]; NumLados = Leer( ); Leer( ArregloPoligono, NumLados); Imprimir( ArregloPoligono, NumLados); cin.ignore( ); cin.get( ); return 0; }//Fin del main( )



void Leer( Punto &RefP ) { cout << endl; cout << "Dame Coordenada X: "; cin >> RefP.CoordX; cout << "Dame Coordenada Y: "; cin >> RefP.CoordY; }//Fin de LeerPunto( ) void Imprimir( const Punto &RefP ) { cout << "(" << RefP.CoordX << ", " << RefP.CoordY << ")"; }//Fin de Imprimir( ) int Leer( void ) { bool Bandera = true; int NumLados; while( Bandera == true ) { system( “cls” ); cout << "Dame el numero de lados [3,30]: "; cin >> NumLados; try { if( NumLados < 3 || NumLados > 30 ) throw NumLados; else Bandera = false; }//Fin de try catch( int e ) { cout << endl; cout << "Dato erroneo. Intentelo de nuevo" << endl << "Enter para continuar."; cin.ignore( ); cin.get( ); cout << endl << endl; }//Fin del if };//Fin del while return NumLados; }//Fin de Leer( ) void Leer( Poligono ArregloPoligono[ ], int NumLados ) { int i = 0; Leer( ArregloPoligono[ i ].PuntoInicial ); do { Leer( ArregloPoligono[ i ].PuntoFinal ); i++; ArregloPoligono[ i ].PuntoInicial = ArregloPoligono[ i - 1 ].PuntoFinal; } while( i < NumLados - 1 ); ArregloPoligono[ NumLados - 1 ].PuntoFinal = ArregloPoligono[ 0 ].PuntoInicial; }//Fin de Leer( )



void Imprimir( Poligono ArregloPoligono[ ], int NumLados ) { int i =0; cout << endl << endl; cout << "LAS COORDENADAS DE LOS LADOS SON:" << endl; cout << "Las coordenadas del lado " << ( i + 1 ) << " son: "; Imprimir( ArregloPoligono[ i ].PuntoInicial ); cout << " Y "; do { Imprimir( ArregloPoligono[ i ].PuntoFinal ); cout << endl; i++; cout << "Las coordenadas del lado " << ( i + 1 ) << " son: "; Imprimir( ArregloPoligono[ i ].PuntoInicial ); cout << " Y "; }while( i < NumLados - 1 ); cout << "(" << ArregloPoligono[ i ].PuntoFinal.CoordX << ", " << ArregloPoligono[ i ].PuntoFinal.CoordY << ")" << endl; }//Fin de Imprimir( )




Se requieren la siguientes funciones:

void Leer( int &NumCal, Estudiante &RefE ); float Promedio( const Estudiante &RefE ); char ConvertirLetra( const Estudiante &RefE ); void Imprimir( const int NumCal, const Estudiante &RefE );


/* Nombre del programa: EJER ESTRUC 04.CPP */ #include <iostream> //Para cout y cin using namespace std; struct Estudiante { string Nombre; int Boleta; string Especialidad; float CalExamen[ 15 ]; char CalFinal; }; //Fin de el objeto estructura Estudiante{ } void Leer( int &NumCal, Estudiante &RefE ); float Promedio( const Estudiante &RefE ); char ConvertirLetra( const Estudiante &RefE ); void Imprimir( const int NumCal, const Estudiante &RefE ); int main( void ) { system( "cls" ); Estudiante E1; int NumCal; Leer( NumCal, E1 ); cout << endl; Imprimir( NumCal, E1 ); cin.ignore( ); cin.get( ); return 0; }//Fin de main( )



void Leer( int &NumCal, Estudiante &RefE ) { cout << " Escriba el nombre del estudiante : "; getline( cin, RefE.Nombre ); cout << " Escriba la boleta del estudiante : "; cin >> RefE.Boleta; fflush( stdin ); cout << " Escriba la especialidad del estudiante : "; getline( cin, RefE.Especialidad ); cout << " ¿Cuántos registros de prueba hay? : "; cin >> NumCal; cout << endl << endl; for( int i = 0; i < NumCal; i++ ) { cout << " Escriba calificaciones " << ( i + 1 ) << ": "; cin >> RefE.CalExamen[ i ]; } // Fin del for cout << endl; }//Fin de Leer( ) float Promedio( const int NumCal, const Estudiante &RefE ) { float Prom = 0.0; for( int i = 0; i < NumCal; i++ ) { Prom += RefE.CalExamen[ i ]; } // Fin del for Prom = Prom / NumCal; return Prom; }//Fin de Promedio( ) char ConvertirLetra( const int NumCal, const Estudiante &RefE ) { float Prom = Promedio( NumCal, RefE ); char CalFinal; if( Prom < 6 ) CalFinal = 'R'; if( Prom >= 6 && Prom < 7 ) CalFinal = 'D'; if( Prom >= 7 && Prom < 8 ) CalFinal = 'C'; if( Prom >= 8 && Prom < 9 ) CalFinal = 'B'; if( Prom >= 9 && Prom < 10 ) CalFinal = 'A'; return CalFinal; }//Fin de ConvertirLetra( ) void Imprimir( const int NumCal, const Estudiante &RefE ) { cout << " Nombre del estudiante : " << RefE.Nombre << endl; cout << " Boleta del estudiante : " << RefE.Boleta << endl; cout << " Especialidad : " << RefE.Especialidad << endl; cout << " Calificaciones : "; for( int i = 0; i < NumCal; i++ ) cout << RefE.CalExamen[ i ] << ", "; cout << endl; cout << " Promedio calificaciones : " << Promedio( NumCal, RefE ) << endl; cout << " Calificación final : " << ConvertirLetra( NumCal, RefE ) << endl; }// Fin Imprimir( )




Se requieren la siguientes funciones: o Para las estructura Calificaciones se requiera una función para leer el número de

calificaciones, otra para leer las calificaciones, finalmente una más para imprimir los resultados deseados.

int Leer( void ); void Leer( const int NumCal, Calificaciones &RefC ); void Imprimir( const int NumCal, const Calificaciones &RefC )

o Para la estructura Estudiante se requieren una para leer los datos del estudiante, otra para calcular el promedio de sus calificaciones, una para convertir las calificaciones a formato letra y finalmente una función para imprimir los resultados deseados.

void Leer( int &NumCal, Estudiante &RefE ); float Promedio( const NumCal, const Estudiante &RefE ); char ConvertirLetra( const int NumCal, const Estudiante &RefE ); void Imprimir( const int NumCal, const Estudiante &RefE )


/* Nombre del programa: EJER ESTRUC 05.CPP */ using namespace std; #include <iostream> //Para cout y cin using namespace std; struct Calificaciones { float CalExamen[ 15 ]; };//Fin de la estructura Calificaciones[ } struct Estudiante { string Nombre; int Boleta; string Especialidad; Calificaciones CalExamen; char CalFinal; }; //Fin de el objeto estructura Estudiante{ } //Prototipos de la estructura Calificaciones{ } int Leer( void ); void Leer( const int NumCal, Calificaciones &RefC ); void Imprimir( const int NumCal, const Calificaciones &RefC ); //Prototipos de la estructura Estudiante{ } void Leer( int &NumCal, Estudiante &RefE ); float Promedio( const int NumCal, const Estudiante &RefE ); char ConvertirLetra( const int NumCal, const Estudiante &RefE ); void Imprimir( const int NumCal, const Estudiante &RefE );



int main( void ) { system( "cls" ); Estudiante E1; int NumCal; Leer( NumCal, E1 ); cout << endl; Imprimir( NumCal, E1 ); cin.ignore( ); cin.get( ); return 0; }//Fin de main( ) int Leer( void ) { int NumCal; cout << " ¿Cuántos registros de prueba hay? : "; cin >> NumCal; cout << endl << endl; return NumCal; }//Fin de Leer( ) void Leer( const int NumCal, Calificaciones &RefC ) { for( int i = 0; i < NumCal; i++ ) { cout << " Escriba calificaciones " << ( i + 1 ) << ": "; cin >> RefC.CalExamen[ i ]; } // Fin del for }//Fin de Leer( ) void Imprimir( const int NumCal, const Calificaciones &RefC ) { for( int i = 0; i < NumCal; i++ ) cout << RefC.CalExamen[ i ] << ", "; }//Fin de Imprimir( ) void Leer( int &NumCal, Estudiante &RefE ) { cout << " Escriba el nombre del estudiante : "; getline( cin, RefE.Nombre ); cout << " Escriba la boleta del estudiante : "; cin >> RefE.Boleta; cin.ignore( ); cout << " Escriba la especialidad del estudiante : "; getline( cin, RefE.Especialidad ); NumCal = Leer( ); Leer( NumCal, RefE.CalExamen ); cout << endl; }//Fin de Leer( )



float Promedio( const int NumCal, const Estudiante &RefE ) { float Prom = 0.0; for( int i = 0; i < NumCal; i++ ) { Prom += RefE.CalExamen.CalExamen[ i ]; } // Fin del for Prom = Prom / NumCal;

return Prom; }//Fin de Promedio( ) char ConvertirLetra( const int NumCal, const Estudiante &RefE ) { float Prom = Promedio( NumCal, RefE ); char CalFinal; if( Prom < 6 ) CalFinal = 'R'; if( Prom >= 6 && Prom < 7 ) CalFinal = 'D'; if( Prom >= 7 && Prom < 8 ) CalFinal = 'C'; if( Prom >= 8 && Prom < 9 ) CalFinal = 'B'; if( Prom >= 9 && Prom < =10 ) CalFinal = 'A'; return CalFinal; }//Fin de ConvertirLetra( ) void Imprimir( const int NumCal, const Estudiante &RefE ) { cout << " Nombre del estudiante : " << RefE.Nombre << endl; cout << " Boleta del estudiante : " << RefE.Boleta << endl; cout << " Especialidad : " << RefE.Especialidad << endl; cout << " Calificaciones : "; for( int i = 0; i < NumCal; i++ ) cout << RefE.CalExamen.CalExamen[ i ] << ", "; cout << endl; cout << " Promedio calificaciones : " << Promedio( NumCal, RefE ) << endl; cout << " Calificacion final : " << ConvertirLetra( NumCal, RefE ) << endl; }// Fin Imprimir( )




Se requieren la siguientes funciones: o Para las estructura Comision se requiera una función para leer y otra para imprimir. Sus

prototipos son los siguientes:

void Leer( Comision &RefC, const int Indice ); void Imprimir( const Comision &RefC, const int Indice );

o Para la estructura VentasVendedor se requieren una función para leer , dos funciones para calcular el total de ventas anuales por vendedor y la comisión que recibe cada vendedor por las ventas realilzadas. Sus prototipos son los siguientes:

void Leer( VentasVendedor &RefVV); float TotalVentas( const VentasVendedor &RefVV ); float CalcularComision( const Comision TablaComision [ ],

const int TamCom, const float TotalAnual )

void Imprimir( const VentasVendedor &RefVV, const Comision TablaComision[ ], const int TamCom );


/* Nombre del programa: EJER ESTRUC 06.CPP * using namespace std; #include <iostream> //Para cout y cin struct Comision { long int LimiteSuperior; float Porcentaje; };//Fin de la estructura Comision{ } struct VentasVendedor { string RFC; string Apellidos; string Nombre; string Zona; float SueldoBase; float VentasMensuales[ 12 ]; };//Fin de la estructura Ventas{ } //Prototipos de Comision{ } void Leer( Comision &RefC, const int Indice ); void Imprimir( const Comision &RefC, const int Indice ); //Prototipos de VentasVendedor{ } void Leer( VentasVendedor &RefVV); float TotalVentas( const VentasVendedor &RefVV ); float CalcularComision( const Comision TablaComision [ ], const int TamCom, const float TotalAnual ); void Imprimir( const VentasVendedor &RefVV, const Comision TablaComision[ ], const int TamCom );



int main( void ) { system( "cls" ); const int TamCom = 5; Comision TablaComision[ TamCom ]; VentasVendedor Vendedor; cout << "INTRODUCIR LOS DATOS DE LA TABLA DE COMISIONES" << endl; for( int i = 0; i < TamCom; i++ ) Leer( TablaComision[ i ], i ); cout.setf( ios::fixed ); cout.setf( ios::showpoint ); cout.precision( 2 ); cout << "IMPRIMIR LOS DATOS DE LA TABLA DE COMISIONES" << endl; for( int i = 0; i < 5; i++ ) Imprimir( TablaComision[ i ], i ); Leer( Vendedor ); Imprimir( Vendedor, TablaComision, TamCom ); cin.ignore( ); cin.get( ); return 0; }//Fin de main( ) void Leer( Comision &RefC, const int Indice ) { cout << "Limite Superior " << ( Indice + 1 ) << " : "; cin >> RefC.LimiteSuperior; cout << "Tasa comisión " << ( Indice + 1 ) << " : "; cin >> RefC.Porcentaje; cout << endl; }//Fin de Leer( ) void Imprimir( const Comision &RefC, const int Indice ) { cout << "\tLimite Superior " << ( Indice + 1 ) << " : " << RefC.LimiteSuperior << endl; cout << "\tTasa comisión " << ( Indice + 1 ) << " : " << RefC.Porcentaje << endl << endl; }//Fin de Imprimir( ) void Leer( VentasVendedor &RefVV) { cin.ignore( );

cout << "INTRODUZCA DATOS DEL VENDEDOR" << endl; cout << "RFC : "; getline( cin, RefVV.RFC ); cout << "Apellidos : "; getline( cin, RefVV.Apellidos ); cout << "Nombre : "; getline( cin, RefVV.Nombre ); cout << "Zona : "; getline( cin, RefVV.Zona ); cout << "Sueldo Base : "; cin >> RefVV.SueldoBase; cout << "Ventas Mensuales: " << endl << endl; for( int i = 0; i < 12; i++ ) { cout << "\tMes[" << ( i + 1 ) << "] = "; cin >> RefVV.VentasMensuales[ i ]; }//Fin del for }//Fin de Leer( )



float TotalVentas( const VentasVendedor &RefVV ) { float Total = 0.0; for( int i = 0; i < 12; i++ ) Total += RefVV.VentasMensuales[ i ]; return Total; }//Fin de TotalVentas( ) float CalcularComision( const Comision TablaComision [ ], const int TamCom, const float TotalAnual ) { int i = 0; while( ( TablaComision[ i ].LimiteSuperior < TotalAnual ) && ( i != TamCom ) ) { i++; }//Fin del while if( i == TamCom ) return( TotalAnual * ( TablaComision[ i - 1 ].Porcentaje ) / 100 ); else return( TotalAnual * TablaComision[ i ]. Porcentaje / 100 ); }//Fin de CalcularComision( ) void Imprimir( const VentasVendedor &RefVV, const Comision TablaComision[ ], const int TamCom ) { cout << endl; cout << "DATOS DE SALIDA DEL VENDEDOR" << endl; cout << "RFC : " << RefVV.RFC << endl; cout << "Apellidos : " << RefVV.Apellidos << endl; cout << "Nombre : " << RefVV.Nombre << endl; cout << "Zona : " << RefVV.Zona << endl; cout << "Sueldo Base : " << RefVV.SueldoBase << endl; cout << "Ventas Mensuales: " << endl << endl; for( int i = 0; i < 12; i++ ) { cout << "\tMes[" << ( i + 1 ) << "] = " << RefVV.VentasMensuales[ i ] << endl; }//Fin del for

cout << endl; cout << "Total Anual : " << TotalVentas( RefVV ) << endl; cout << "Importe Comisión : " << CalcularComision( TablaComision, TamCom, TotalVentas( RefVV )) << endl << endl; }//Fin de Imprimir( )

Programas con union


PROYECTOS CON struct

Proyectos con struct


DEFINICION DEL PROBLEMA [PROYECTO 01A.CPP] Modelar la estructura Racional formado por los campos Numerador y Denominador. Mostrar y validar un menu, leer el racional, validando que el denominador no sea cero y normalizando el racional, ejecutar las operaciones de suma, resta, multiplicación y división y finalmente imprimir el resultado de la operación. Ver la salida. En el caso de la división, el numerador del segundo operando no puede ser cero. SALIDA:

SELECCIONA UNA OPCION 1.- Suma de racionales 2.- Resta de racionales

3.- Multiplicacion de racionales 4.- Division de racionales 5.- Salir Dame tu opcion: 6 Opcion equivocada. Intentelo nuevamente. Enter para continuar. Menu( ) -------------------------------------------------------------- SELECCIONA UNA OPCION 1.- Suma de racionales 2.- Resta de racionales 3.- Multiplicacion de racionales ValidarOpcion( ) 4.- Division de racionales 5.- Salir Dame tu opcion: 1 DATOS DEL NUMERO RACIONAL Dame el numerador : 1 Dame el denominador : 0 El denominador debe ser distinto de cero. LeerRacional( )

Intentelo nuevamente. Enter para continuar. ValidarDenominador( ) Dame el denominador : 2 DATOS DEL NUMERO RACIONAL Dame el numerador : 3 Dame el denominador : 4 EL RESULTADO DE LA SUMA ES Suma( ) 1/2 + 3/2 = 5/4 Resta( ) Imprimir( ) Multiplicacion( ) Deseas continuar S/N: n División ( )



ANALISIS DEL PROBLEMA De la definición del problema y del análisis de la salida, se observa que se requieren las siguientes tareas:

Una función Menu( ), que muestra el menú de opciones. Su prototipo es el siguiente:

int Menu( void );

o Dentro de Menu( ) se llama a una función ValidarOpcion( ) que valida que la opción seleccionada sea la correcta. Dependiendo de si la opción es correcta o no, devuelve verdadereo o falso respectivamente. Su prototipo es el siguiente:

bool ValidarOpcion(const int Opcion );

Una función LeerRacional( ) que lea tanto el numerador como el denominador del racional. Se valida que el denominador no sea cero. Su prototipo es el siguiente:

Racional LeerRacional( void ); o bien

void LeerRacional( Racional &RefR );

o Dentro de la función LeerRacional( ) se invoca a la función ValidarDenominador( ) que devuelve falso o verdadero, dependiendo de si el denominador fué cero o no. Su prototipo es el siguiente:

bool ValidarDenominador( const int Den );

o Se invoca también a la función Normalizar( ) para garantizar que el denominador siempre sea positivo. Su prototipo es el siguiente:

void Normalizar( Racional &RefR );

o En esta etapa podría o no tomarse la decisión de simplificar el racional introducido. Pero

podemos preparar la programación para que así sea en caso de que se desee. Es decir, también podemos invocar a una función Simplificar( ), que exprese el racional en su forma más simple. Su prototipo es el siguiente:

void Simplificar( Racional &RefR );

Dentro de la función Simplificar( ) se invoca a la función MCD( ) que calcula el

máximo comúin divisor de dos números. Su prototipo es el siguiente:

int MCD( int Dividendo, int Divisor );

Funciones que realicen la suma, resta, multiplicación y división de dos racionales. Sus prototipos son los siguientes:

Racional Suma( const Racional &RefR1, const Racional &RefR2 ); Racional Resta( const Racional &RefR1, const Racional &RefR2 );

Racional Multiplicacion( const Racional &RefR1, const Racional &RefR2 ); Racional Division( const Racional &RefR1, const Racional &RefR2 );



Una función Imprimir( ) que imprima el resultado de la operación, sus operandos y el operador correspondiente. Su prototipo es el siguiente:

void Imprimir( const Racional &RefR, const Racional &RefR1, const Racional &RefR2,

char Simbolo ); CODIFICACION DEL PROBLEMA

/* Nombre del programa: PROYECTO 01A.CPP */ using namespace std; #include <iostream> //Para cout y cin #include <cctype> //Para to upper( ) #include <string> //Para la clase string using namespace std; struct Racional { int Numerador; int Denominador; };//Fin de la estructura Racional int Menu( void ); void Normalizar( Racional &RefR ); int MCD( int Dividendo, int Divisor ); void Simplificar( Racional &RefR ); Racional LeerRacional( void ); Racional Suma( const Racional &RefR1, const Racional &RefR2 ); Racional Resta( const Racional &RefR1, const Racional &RefR2 ); Racional Multiplicacion( const Racional &RefR1, const Racional &RefR2 ); Racional Division( const Racional &RefR1, const Racional &RefR2 ); void Imprimir( const Racional &RefR, const Racional &RefR1, const Racional &RefR2, char Simbolo ); int main( void ) { system( “cls” ); Racional R, R1, R2; int Opcion; char Respuesta, Simbolo; string OperacionRealizada; do { Opcion = Menu( ); if( Opcion != 5 ) { R1 = LeerRacional( ); R2 = LeerRacional( ); }//Fin del if switch( Opcion ) { case 1: R = Suma( R1, R2 ); Simbolo = '+'; OperacionRealizada = "SUMA"; break;



case 2: R = Resta( R1, R2 ); Simbolo = '-'; OperacionRealizada = "RESTA"; break; case 3: R = Multiplicacion( R1, R2 ); Simbolo = '*'; OperacionRealizada = "MULTIPLICACION"; break; case 4: R = Division( R1, R2 ); Simbolo = '/'; OperacionRealizada = "DIVISION"; break; case 5: break; }//Fin del switch( ) if( ( R2.Numerador == 0 && Opcion == 4 ) || ( Opcion == 5 ) ) { cout << endl << endl; }//Fin del if else { Simplificar( R ); cout << endl << "EL RESULTADO DE LA " << OperacionRealizada << " ES" << endl; Imprimir( R, R1, R2, Simbolo ); }//Fin del else cout << "Deseas continuar S/N: "; cin >> Respuesta; }while( Respuesta = toupper( Respuesta ) == 'S' ); return 0; }//Fin del main( ) int Menu( void ) { int Opcion; bool Bandera = true; while( Bandera == true ) { system( “cls” ); cout << "SELECCIONA UNA OPCION" << endl; cout << "1.- Suma de racionales" << endl << "2.- Resta de racionales" << endl << "3.- Multiplicacion de racionales" << endl << "4.- Division de racionales" << endl << "5.- Salir" << endl << endl; cout << "Dame tu opcion: "; cin >> Opcion; try { if( Opcion < 1 || Opcion > 5 ) throw Opcion; else Bandera = false; }// Fin de try( )



catch( int e ) { cout << endl; cout << "Opcion equivocada. Intentelo nuevamente. " << "Enter para continuar."; cin.ignore( );

cin.get( ); cout << endl << endl; }//Fin de catch( ) }// fin del while return Opcion; }//Fin de Menu( ) void Normalizar( Racional &RefR ) { RefR.Numerador = -RefR.Numerador; RefR.Denominador = -RefR.Denominador; }//Fin de Normalizar( ) int MCD( int Dividendo, int Divisor ) { int Residuo; while( Dividendo % Divisor != 0 ) { Residuo = Dividendo % Divisor; Dividendo = Divisor; Divisor = Residuo; }//Fin del while return Divisor; }//Fin de MCD( ) void Simplificar( Racional &RefR ) { int mcd; Racional R; R = RefR; if( R.Numerador < 0 ) R.Numerador = -R.Numerador; mcd = MCD( R.Numerador, R.Denominador ); RefR.Numerador = RefR.Numerador / mcd; RefR.Denominador = RefR.Denominador / mcd; if( RefR.Denominador < 0 ) Normalizar( RefR ); }//Fin de Simplificar( ) Racional LeerRacional( void ) { Racional R; bool Bandera = true; int Den; cout << endl; cout << "DATOS DEL NUMERO RACIONAL" << endl; cout << "Dame el numerador: "; cin >> R.Numerador;



while( Bandera == true ) { cout << "Dame el denominador: "; cin >> Den; try { if( Den == 0 ) throw Den; else Bandera = false; }//Fin de try( ) catch( int e ) { cout << endl; cout << "El denominador debe ser distinto de cero." << endl << "Intentelo nuevamente. Enter para continuar."; cin.ignore( );

cin.get( ); cout << endl << endl; }//Fin del catch( ) }// Fin del while R.Denominador = Den; if( R.Denominador < 0 ) Normalizar( R ); return R; }//Fin de LeerRacional( ) Racional Suma( const Racional &RefR1, const Racional &RefR2 ) { Racional R; R.Denominador = RefR1.Denominador * RefR2.Denominador; R.Numerador = ( RefR2.Denominador * RefR1.Numerador ) + ( RefR1.Denominador * RefR2.Numerador ); return R; /* El cuerpo de esta función también pudo haber sido: Racional R = { ( RefR2.Denominador * RefR1.Numerador ) + ( RefR1.Denominador * RefR2.Numerador ), RefR1.Denominador * RefR2.Denominador }; return R; */ }//Fin de Suma( ) Racional Resta( const Racional &RefR1, const Racional &RefR2 ) { Racional R = { ( RefR2.Denominador * RefR1.Numerador ) - ( RefR1.Denominador * RefR2.Numerador ), RefR1.Denominador * RefR2.Denominador }; return R; }//Fin de Resta( ) Racional Multiplicacion( const Racional &RefR1, const Racional &RefR2 ) { Racional R = { RefR1.Numerador * RefR2.Numerador, RefR1.Denominador * RefR2.Denominador}; return R; }//Fin de Multiplicacion( )



Racional Division( const Racional &RefR1, const Racional &RefR2 ) { try { if( RefR2.Numerador == 0 ) throw 1; }//Fin de try( ) catch( int e ) { cout << endl; cout << "No es posible hacer la division. Enter para continuar "; cin.ignore( );

cin.get( ); cout << endl << endl; return RefR2; }//Fin de catch( ) Racional R = { RefR1.Numerador * RefR2.Denominador, RefR1.Denominador * RefR2.Numerador}; return R; }//Fin de Division( ) void Imprimir( const Racional &RefR, const Racional &RefR1, const Racional &RefR2, char Simbolo ) { cout << RefR1.Numerador << '/' << RefR1.Denominador << " " << Simbolo << " " << RefR2.Numerador << '/' << RefR2.Denominador << " = " << RefR.Numerador << '/' << RefR.Denominador << endl << endl; }//Fin de Imprimir( )



DEFINICION DEL PROBLEMA [PROYECTO 01B.CPP] Mejorar el programa PROYECTO 01A.CPP Sobrecargando los operatores +, -, * y /. SALIDA: La misma salida que la del programa PROYECTO 01A.CPP. ANALISIS DEL PROBLEMA Las tareas son las del programa PROYECTO 01A.CPP, solo se agregan las siguientes funciones sobrecargadas:

Funciones sobrecargadas que realicen la suma, resta, multiplicación y división de dos racionales.

Sus prototipos son los siguientes:

Racional operator+( const Racional &RefR1, const Racional &RefR2 ); Racional operator-( const Racional &RefR1, const Racional &RefR2 ); Racional operator*( const Racional &RefR1, const Racional &RefR2 ); Racional operator/( const Racional &RefR1, const Racional &RefR2 );


/* Nombre del programa: PROYECTO 01B.CPP */ using namespace std; #include <iostream> //Para cout y cin #include <cctype> //Para to upper( ) #include <string> //Para la clase string using namespace std; struct Racional { int Numerador; int Denominador; };//Fin de la estructura Racional int Menu( void ); void Normalizar( Racional &RefR ); int MCD( int Dividendo, int Divisor ); void Simplificar( Racional &RefR ); Racional LeerRacional( void ); Racional Suma( const Racional &RefR1, const Racional &RefR2 ); Racional Resta( const Racional &RefR1, const Racional &RefR2 ); Racional Multiplicacion( const Racional &RefR1, const Racional &RefR2 ); Racional Division( const Racional &RefR1, const Racional &RefR2 ); Racional operator+( const Racional &RefR1, const Racional &RefR2 ); Racional operator-( const Racional &RefR1, const Racional &RefR2 ); Racional operator*( const Racional &RefR1, const Racional &RefR2 ); Racional operator/( const Racional &RefR1, const Racional &RefR2 ); void Imprimir( const Racional &RefR, const Racional &RefR1, const Racional &RefR2, char Simbolo );



int main( void ) { system( “cls” ); Racional R, R1, R2; int Opcion; char Respuesta, Simbolo; string OperacionRealizada; do { Opcion = Menu( ); if( Opcion != 5 ) { R1 = LeerRacional( ); R2 = LeerRacional( ); }//Fin del if switch( Opcion ) { case 1: R = Suma( R1, R2 ); Simbolo = '+'; OperacionRealizada = "SUMA"; break; case 2: R = Resta( R1, R2 ); Simbolo = '-'; OperacionRealizada = "RESTA"; break; case 3: R = Multiplicacion( R1, R2 ); Simbolo = '*'; OperacionRealizada = "MULTIPLICACION"; break; case 4: R = Division( R1, R2 ); Simbolo = '/'; OperacionRealizada = "DIVISION"; break; case 5: break; }//Fin del switch( ) if( ( R2.Numerador == 0 && Opcion == 4 ) || ( Opcion == 5 ) ) { cout << endl << endl; }//Fin del if else { Simplificar( R ); cout << endl << "EL RESULTADO DE LA " << OperacionRealizada << " ES" << endl; Imprimir( R, R1, R2, Simbolo ); }//Fin del else cout << "Deseas continuar S/N: "; cin >> Respuesta; }while( Respuesta = toupper( Respuesta ) == 'S' );



do { Opcion = Menu( ); if( Opcion != 5 ) { R1 = LeerRacional( ); R2 = LeerRacional( ); } switch( Opcion ) { case 1: R = R1 + R2; Simbolo = '+'; OperacionRealizada = "SUMA"; break; case 2: R = R1 - R2; Simbolo = '-'; OperacionRealizada = "RESTA"; break; case 3: R = R1 * R2; Simbolo = '*'; OperacionRealizada = "MULTIPLICACION"; break; case 4: R = R1 / R2; Simbolo = '/'; OperacionRealizada = "DIVISION"; break; case 5: break; }//Fin del switch( ) if( ( R2.Numerador == 0 && Opcion == 4 ) || ( Opcion == 5 ) ) { cout << endl << endl; }//Fin del if else { Simplificar( R ); cout << endl << "EL RESULTADO DE LA " << OperacionRealizada << " ES" << endl; Imprimir( R, R1, R2, Simbolo ); }//Fin del else cout << "Deseas continuar S/N: "; cin >> Respuesta; }while( Respuesta = toupper( Respuesta ) == 'S' ); return 0; }//Fin del main( ) int Menu( void ) { int Opcion; bool Bandera = true;



while( Bandera == true ) { clrscr( ); cout << "SELECCIONA UNA OPCION" << endl; cout << "1.- Suma de racionales" << endl << "2.- Resta de racionales" << endl << "3.- Multiplicacion de racionales" << endl << "4.- Division de racionales" << endl << "5.- Salir" << endl << endl; cout << "Dame tu opcion: "; cin >> Opcion; try { if( Opcion < 1 || Opcion > 5 ) throw Opcion; else Bandera = false; }// Fin de try( ) catch( int e ) { cout << endl; cout << "Opcion equivocada. Intentelo nuevamente. " << "Enter para continuar.";

cin.ignore( ); cin.get( ); cout << endl << endl; }//Fin de catch( ) }// fin del while return Opcion; }//Fin de Menu( ) void Normalizar( Racional &RefR ) { RefR.Numerador = -RefR.Numerador; RefR.Denominador = -RefR.Denominador; }//Fin de Normalizar( ) int MCD( int Dividendo, int Divisor ) { int Residuo; while( Dividendo % Divisor != 0 ) { Residuo = Dividendo % Divisor; Dividendo = Divisor; Divisor = Residuo; }//Fin del while return Divisor; }//Fin de MCD( ) void Simplificar( Racional &RefR ) { int mcd; Racional R; R = RefR; if( R.Numerador < 0 ) R.Numerador = -R.Numerador; mcd = MCD( R.Numerador, R.Denominador ); RefR.Numerador = RefR.Numerador / mcd; RefR.Denominador = RefR.Denominador / mcd;



if( RefR.Denominador < 0 ) Normalizar( RefR ); }//Fin de Simplificar( ) Racional LeerRacional( void ) { Racional R; bool Bandera = true; int Den; cout << endl; cout << "DATOS DEL NUMERO RACIONAL" << endl; cout << "Dame el numerador: "; cin >> R.Numerador; while( Bandera == true ) { cout << "Dame el denominador: "; cin >> Den; try { if( Den == 0 ) throw Den; else Bandera = false; }//Fin de try( ) catch( int e ) { cout << endl; cout << "El denominador debe ser distinto de cero." << endl << "Intentelo nuevamente. Enter para continuar."; cin.ignore( ); cin.get( ); cout << endl << endl; }//Fin del catch( ) }// Fin del while R.Denominador = Den; if( R.Denominador < 0 ) Normalizar( R ); return R; }//Fin de LeerRacional( ) Racional Suma( const Racional &RefR1, const Racional &RefR2 ) { Racional R; R.Denominador = RefR1.Denominador * RefR2.Denominador; R.Numerador = ( RefR2.Denominador * RefR1.Numerador ) + ( RefR1.Denominador * RefR2.Numerador ); return R; /* El cuerpo de esta función también pudo haber sido: Racional R = { ( RefR2.Denominador * RefR1.Numerador ) + ( RefR1.Denominador * RefR2.Numerador ), RefR1.Denominador * RefR2.Denominador }; return R; */ }//Fin de Suma( )



Racional Resta( const Racional &RefR1, const Racional &RefR2 ) { Racional R = { ( RefR2.Denominador * RefR1.Numerador ) - ( RefR1.Denominador * RefR2.Numerador ), RefR1.Denominador * RefR2.Denominador }; return R; }//Fin de Resta( ) Racional Multiplicacion( const Racional &RefR1, const Racional &RefR2 ) { Racional R = { RefR1.Numerador * RefR2.Numerador, RefR1.Denominador * RefR2.Denominador}; return R; }//Fin de Multiplicacion( ) Racional Division( const Racional &RefR1, const Racional &RefR2 ) { try { if( RefR2.Numerador == 0 ) throw 1; }//Fin de try( ) catch( int e ) { cout << endl; cout << "No es posible hacer la division. Enter para continuar "; cin.ignore( ); cin.get( ); cout << endl << endl; return RefR2; }//Fin de catch( ) Racional R = { RefR1.Numerador * RefR2.Denominador, RefR1.Denominador * RefR2.Numerador}; return R; }//Fin de Division( ) Racional operator+( const Racional &RefR1, const Racional &RefR2 ) { Racional R; R.Denominador = RefR1.Denominador * RefR2.Denominador; R.Numerador = ( RefR2.Denominador * RefR1.Numerador ) + ( RefR1.Denominador * RefR2.Numerador ); return R; /* El cuerpo de esta función también pudo haber sido: Racional R = { ( RefR2.Denominador * RefR1.Numerador ) + ( RefR1.Denominador * RefR2.Numerador ), RefR1.Denominador * RefR2.Denominador }; return R; */ }//Fin de operator+( ) Racional operator-( const Racional &RefR1, const Racional &RefR2 ) { Racional R = { ( RefR2.Denominador * RefR1.Numerador ) - ( RefR1.Denominador * RefR2.Numerador ), RefR1.Denominador * RefR2.Denominador }; return R; }//Fin de operator-( )



Racional operator*( const Racional &RefR1, const Racional &RefR2 ) { Racional R = { RefR1.Numerador * RefR2.Numerador, RefR1.Denominador * RefR2.Denominador}; return R; }//Fin de opeator*( ) Racional operator/( const Racional &RefR1, const Racional &RefR2 ) { try { if( RefR2.Numerador == 0 ) throw 1; }//Fin de try( ) catch( int e ) { cout << endl; cout << "No es posible hacer la division. Enter para continuar "; cin.ignore( ); cin.get( ); cout << endl << endl; return RefR2; }//Fin de catch( ) Racional R = { RefR1.Numerador * RefR2.Denominador, RefR1.Denominador * RefR2.Numerador}; return R; }//Fin de operator/( ) void Imprimir( const Racional &RefR, const Racional &RefR1, const Racional &RefR2, char Simbolo ) { cout << RefR1.Numerador << '/' << RefR1.Denominador << " " << Simbolo << " " << RefR2.Numerador << '/' << RefR2.Denominador << " = " << RefR.Numerador << '/' << RefR.Denominador << endl << endl; }//Fin de Imprimir( )



DEFINICION DEL PROBLEMA [PROYECTO 01C.CPP] Continuar mejorarando el programa PROYECTO 01A.CPP sbrecargando los operatores >, >=, <, <=, ==, !=,. SALIDA:

La misma salida que la del programa PROYECTO 01A.CPP, más la salida resultado de las comparaciones:

RELACIONES POSIBLES ENTRE DOS RACIONALES

DATOS DEL NUMERO RACIONAL Dame el numerador : 1 Dame el denominador: 2 DATOS DEL NUMERO RACIONAL Dame el numerador : -1 Dame el denominador: -3 RELACIONES POSIBLES ENTRE DOS RACIONALES 1/2 es mayor que 1/3 1/2 es mayor o igual que 1/3 1/2 es distinto que 1/3 Deseas continuar S/N: n ANALISIS DEL PROBLEMA Las tareas son las del programa PROYECTO 01A.CPP, solo se agregan las siguientes funciones sobrecargadas:

Funciones sobrecargadas que realicen las comparaciones de dos racionales. Sus prototipos son los

siguientes:

Racional operator>( const Racional &RefR1, const Racional &RefR2 ); Racional operator>=( const Racional &RefR1, const Racional &RefR2 ); Racional operator<( const Racional &RefR1, const Racional &RefR2 );

Racional operator<=( const Racional &RefR1, const Racional &RefR2 ); Racional operator==( const Racional &RefR1, const Racional &RefR2 ); Racional operator!=( const Racional &RefR1, const Racional &RefR2 );

Una función Imprimir( ) las diferentes relaciones, cuyo prototipo es el siguiente:

void Imprimir( const Racional &RefR1, const Racional &RefR2 );



CODIFICACION DEL PROBLEMA /* Nombre del programa: PROYECTO 01C.CPP*/

using namespace std; #include <iostream> //Para cout y cin #include <cctype> //Para to upper( ) #include <string> //Para la clase string struct Racional {

int Numerador; int Denominador; };//Fin de la estructura Racional int Menu( void ); void Normalizar( Racional &RefR ); int MCD( int Dividendo, int Divisor ); void Simplificar( Racional &RefR ); Racional LeerRacional( void ); Racional Suma( const Racional &RefR1, const Racional &RefR2 ); Racional Resta( const Racional &RefR1, const Racional &RefR2 ); Racional Multiplicacion( const Racional &RefR1, const Racional &RefR2 ); Racional Division( const Racional &RefR1, const Racional &RefR2 ); Racional operator+( const Racional &RefR1, const Racional &RefR2 ); Racional operator-( const Racional &RefR1, const Racional &RefR2 ); Racional operator*( const Racional &RefR1, const Racional &RefR2 ); Racional operator/( const Racional &RefR1, const Racional &RefR2 ); bool operator>( const Racional &RefR1, const Racional &RefR2 ); bool operator>=( const Racional &RefR1, const Racional &RefR2 ); bool operator<( const Racional &RefR1, const Racional &RefR2 ); bool operator<=( const Racional &RefR1, const Racional &RefR2 ); bool operator==( const Racional &RefR1, const Racional &RefR2 ); bool operator!=( const Racional &RefR1, const Racional &RefR2 ); void Imprimir( const Racional &RefR1, const Racional &RefR2 ); void Imprimir( const Racional &RefR, const Racional &RefR1, const Racional &RefR2, char Simbolo ); int main( void )

{ system( “cls” ); Racional R, R1, R2; int Opcion; char Respuesta, Simbolo; string OperacionRealizada; /*do { Opcion = Menu( ); if( Opcion != 5 ) { R1 = LeerRacional( ); R2 = LeerRacional( ); }

switch( Opcion ) { case 1: R = R1 + R2; Simbolo = '+'; OperacionRealizada= "SUMA"; break;



case 2: R = R1 - R2; Simbolo = '-'; OperacionRealizada = "RESTA"; break; case 3: R = R1 * R2; Simbolo = '*'; OperacionRealizada = "MULTIPLICACION"; break; case 4: R = R1 / R2; Simbolo = '/'; OperacionRealizada = "DIVISION"; break; case 5: break; }//Fin del switch( ) if( ( R2.Numerador == 0 && Opcion == 4 ) || ( Opcion == 5 ) ) { cout << endl << endl; }//Fin del if else { Simplificar( R ); cout << endl << "EL RESULTADO DE LA " << OperacionRealizada << " ES" << endl; Imprimir( R, R1, R2, Simbolo ); }//Fin del else cout << "Deseas continuar S/N: "; cin >> Respuesta; }while( Respuesta = toupper( Respuesta ) == 'S' ); */ do { system( “cls” ); cout << "\t\tPRUEBA DE LAS RELACIONES" << endl << endl; R1 = LeerRacional( ); R2 = LeerRacional( ); Imprimir( R1, R2 ); cout << "Deseas continuar S/N: "; cin >> Respuesta; }while( Respuesta = toupper( Respuesta ) == 'S' ); return 0; }//Fin del main( ) int Menu( void ) { int Opcion; bool Bandera = true;



while( Bandera == true ) { system( “cls” ); cout << "SELECCIONA UNA OPCION" << endl; cout << "1.- Suma de racionales" << endl << "2.- Resta de racionales" << endl << "3.- Multiplicacion de racionales" << endl << "4.- Division de racionales" << endl << "5.- Salir" << endl << endl; cout << "Dame tu opcion: "; cin >> Opcion; try { if( Opcion < 1 || Opcion > 5 ) throw Opcion; else Bandera = false; }// Fin de try( ) catch( int e ) { cout << endl; cout << "Opcion equivocada. Intentelo nuevamente. " << "Enter para continuar."; cin.ignore( ); cin.get( ); cout << endl << endl; }//Fin de catch( ) }// fin del while return Opcion; }//Fin de Menu( ) void Normalizar( Racional &RefR ) { RefR.Numerador = -RefR.Numerador; RefR.Denominador = -RefR.Denominador; }//Fin de Normalizar( ) int MCD( int Dividendo, int Divisor ) { int Residuo; while( Dividendo % Divisor != 0 ) { Residuo = Dividendo % Divisor; Dividendo = Divisor; Divisor = Residuo; }//Fin del while return Divisor; }//Fin de MCD( ) void Simplificar( Racional &RefR ) { int mcd; Racional R; R = RefR; if( R.Numerador < 0 ) R.Numerador = -R.Numerador; if( R.Denominador < 0 ) R.Denominador = -R.Denominador;



mcd = MCD( R.Numerador, R.Denominador ); RefR.Numerador = RefR.Numerador / mcd; RefR.Denominador = RefR.Denominador / mcd; if( RefR.Denominador < 0 ) Normalizar( RefR ); }//Fin de Simplificar( ) Racional LeerRacional( void ) { Racional R; bool Bandera = true; int Den; cout << endl; cout << "DATOS DEL NUMERO RACIONAL" << endl; cout << "Dame el numerador: "; cin >> R.Numerador; while( Bandera == true ) { cout << "Dame el denominador: "; cin >> Den; try { if( Den == 0 ) throw Den; else Bandera = false; }//Fin de try( ) catch( int e ) { cout << endl; cout << "El denominador debe ser distinto de cero." << endl << "Intentelo nuevamente. Enter para continuar."; cin.ignore( ); cin.get( ); cout << endl << endl; }//Fin del catch( ) }// Fin del while R.Denominador = Den; if( R.Denominador < 0 ) Normalizar( R ); return R; }//Fin de LeerRacional( ) Racional Suma( const Racional &RefR1, const Racional &RefR2 ) { Racional R; R.Denominador = RefR1.Denominador * RefR2.Denominador; R.Numerador = ( RefR2.Denominador * RefR1.Numerador ) + ( RefR1.Denominador * RefR2.Numerador ); return R; /* El cuerpo de esta función también pudo haber sido: Racional R = { ( RefR2.Denominador * RefR1.Numerador ) + ( RefR1.Denominador * RefR2.Numerador ), RefR1.Denominador * RefR2.Denominador }; return R; */

}//Fin de Suma( )



Racional Resta( const Racional &RefR1, const Racional &RefR2 ) { Racional R = { ( RefR2.Denominador * RefR1.Numerador ) - ( RefR1.Denominador * RefR2.Numerador ), RefR1.Denominador * RefR2.Denominador }; return R; }//Fin de Resta( ) Racional Multiplicacion( const Racional &RefR1, const Racional &RefR2 ) { Racional R = { RefR1.Numerador * RefR2.Numerador, RefR1.Denominador * RefR2.Denominador}; return R; }//Fin de Multiplicacion( ) Racional Division( const Racional &RefR1, const Racional &RefR2 ) { try { if( RefR2.Numerador == 0 ) throw 1; }//Fin de try( ) catch( int e ) { cout << endl; cout << "No es posible hacer la division. Enter para continuar "; cin.ignore( ); cin.get( ); cout << endl << endl; return RefR2; }//Fin de catch( ) Racional R = { RefR1.Numerador * RefR2.Denominador, RefR1.Denominador * RefR2.Numerador}; return R; }//Fin de Division( ) Racional operator+( const Racional &RefR1, const Racional &RefR2 ) { Racional R; R.Denominador = RefR1.Denominador * RefR2.Denominador; R.Numerador = ( RefR2.Denominador * RefR1.Numerador ) + ( RefR1.Denominador * RefR2.Numerador ); return R; /* El cuerpo de esta función también pudo haber sido: Racional R = { ( RefR2.Denominador * RefR1.Numerador ) + ( RefR1.Denominador * RefR2.Numerador ), RefR1.Denominador * RefR2.Denominador }; return R; */ }//Fin de operator+( ) Racional operator-( const Racional &RefR1, const Racional &RefR2 ) { Racional R = { ( RefR2.Denominador * RefR1.Numerador ) - ( RefR1.Denominador * RefR2.Numerador ), RefR1.Denominador * RefR2.Denominador }; return R; }//Fin de operator-( )



Racional operator*( const Racional &RefR1, const Racional &RefR2 ) { Racional R = { RefR1.Numerador * RefR2.Numerador, RefR1.Denominador * RefR2.Denominador}; return R; }//Fin de opeator*( ) Racional operator/( const Racional &RefR1, const Racional &RefR2 ) { try { if( RefR2.Numerador == 0 ) throw 1; }//Fin de try( ) catch( int e ) { cout << endl; cout << "No es posible hacer la division. Enter para continuar "; cin.ignore( ); cin.get( ); cout << endl << endl; return RefR2; }//Fin de catch( ) Racional R = { RefR1.Numerador * RefR2.Denominador, RefR1.Denominador * RefR2.Numerador}; return R; }//Fin de operator/( ) bool operator>( const Racional &RefR1, const Racional &RefR2 ) { return ( RefR1.Numerador * RefR2.Denominador) > ( RefR1.Denominador * RefR2.Numerador ); }//Fin de operator>( ) bool operator>=( const Racional &RefR1, const Racional &RefR2 ) { return ( RefR1.Numerador * RefR2.Denominador) >= ( RefR1.Denominador * RefR2.Numerador ); }//Fin de operator>=( ) bool operator<( const Racional &RefR1, const Racional &RefR2 ) { return ( RefR1.Numerador * RefR2.Denominador) < ( RefR1.Denominador * RefR2.Numerador ); }//Fin de operator<( ) bool operator<=( const Racional &RefR1, const Racional &RefR2 ) { return ( RefR1.Numerador * RefR2.Denominador) <= ( RefR1.Denominador * RefR2.Numerador ); }//Fin de operator<=( ) bool operator==( const Racional &RefR1, const Racional &RefR2 ) { return ( RefR1.Numerador * RefR2.Denominador) == ( RefR1.Denominador * RefR2.Numerador ); }//Fin de operator==( ) bool operator!=( const Racional &RefR1, const Racional &RefR2 ) { return ( RefR1.Numerador * RefR2.Denominador) != ( RefR1.Denominador * RefR2.Numerador ); }//Fin de operator!=( )



void Imprimir( const Racional &RefR1, const Racional &RefR2 ) { cout << endl; cout << "RELACIONES POSIBLES ENTRE DOS RACIONALES" << endl; if( RefR1 > RefR2 ) { cout << RefR1.Numerador << '/' << RefR1.Denominador << " es mayor que " << RefR2.Numerador << '/' << RefR2.Denominador << endl; }//Fin del if if( RefR1 >= RefR2 ) { cout << RefR1.Numerador << '/' << RefR1.Denominador << " es mayor o igual que " << RefR2.Numerador << '/' << RefR2.Denominador << endl; }//Fin del if if( RefR1 < RefR2 ) { cout << RefR1.Numerador << '/' << RefR1.Denominador << " es menor que " << RefR2.Numerador << '/' << RefR2.Denominador << endl; }//Fin del if if( RefR1 <= RefR2 ) { cout << RefR1.Numerador << '/' << RefR1.Denominador << " es menor o igual que " << RefR2.Numerador << '/' << RefR2.Denominador << endl; }//Fin del if if( RefR1 != RefR2 ) { cout << RefR1.Numerador << '/' << RefR1.Denominador << " es distinto que " << RefR2.Numerador << '/' << RefR2.Denominador << endl; }//Fin del if if( RefR1 == RefR2 ) { cout << RefR1.Numerador << '/' << RefR1.Denominador << " es igual que " << RefR2.Numerador << '/' << RefR2.Denominador << endl; }//Fin del if cout << endl; }//Fin de Imprimir( ) void Imprimir( const Racional &RefR, const Racional &RefR1, const Racional &RefR2, char Simbolo ) { cout << RefR1.Numerador << '/' << RefR1.Denominador << " " << Simbolo << " " << RefR2.Numerador << '/' << RefR2.Denominador << " = " << RefR.Numerador << '/' << RefR.Denominador << endl << endl; }//Fin de Imprimir( )



DEFINICION DEL PROBLEMA [PROYECTO 01D.CPP] Continuar mejorarando el programa PROYECTO 01A.CPP sbrecargando los operatores > >, <<. SALIDA: SELECCIONA UNA OPCION 1.- Suma de racionales 2.- Resta de racionales 3.- Multiplicacion de racionales 4.- Division de racionales 5.- Salir Dame tu opcion: 6 Opcion equivocada. Intentelo nuevamente.Enter para continuar. -------------------------------------------------------------------------------- SELECCIONA UNA OPCION 1.- Suma de racionales 2.- Resta de racionales 3.- Multiplicacion de racionales 4.- Division de racionales 5.- Salir Dame tu opcion: 1 DATOS DEL NUMERO RACIONAL Dame el quebrado: 1/2 DATOS DEL NUMERO RACIONAL Dame el quebrado: 3/4 EL RESULTADO DE LA SUMA ES 1/2 + 3/4 = 5/4 Deseas continuar S/N: n ------------------------------------------------------------------------------- RELACIONES POSIBLES ENTRE DOS RACIONALES DATOS DEL NUMERO RACIONAL Dame el quebrado: 1/0 El denominador debe ser distinto de cero. Intentelo nuevamente. Enter para continuar. Dame el quebrado: 1/2 DATOS DEL NUMERO RACIONAL Dame el quebrado: 3/4 RELACIONES POSIBLES ENTRE DOS RACIONALES 1/2 es menor que 3/4 1/2 es menor o igual que 3/4 1/2 es distinto que 3/4 Deseas continuar S/N: n



ANALISIS DEL PROBLEMA Las tareas son las del programa PROYECTO 01B.CPP y, solo se agregan las siguientes funciones sobrecargadas:

Funciones sobrecargadas que realicen la suma, resta, multiplicación y división de dos racionales.

Sus prototipos son los siguientes:

istream &operator>>( istream &Leer, Racional &RefR ); ostream &operator<<( ostream &Escribir, Racional &RefR );

Se mejora la función de Imprimir( ) para que utilice al operador sobrecargado operator<<.

CODIFICACION DEL PROBLEMA /* Nombre del programa: PROYECTO 01D.CPP */

using namespace std; #include <iostream> //Para cout y cin #include <cctype> //Para to upper( ) #include <string> //Para la clase string struct Racional { int Numerador; int Denominador; };//Fin de la estructura Racional int Menu( void ); int MCD( int Dividendo, int Divisor ); void Simplificar( Racional &RefR ); Racional LeerRacional( void ); Racional Suma( const Racional &RefR1, const Racional &RefR2 ); Racional Resta( const Racional &RefR1, const Racional &RefR2 ); Racional Multiplicacion( const Racional &RefR1, const Racional &RefR2 ); Racional Division( const Racional &RefR1, const Racional &RefR2 ); Racional operator+( const Racional &RefR1, const Racional &RefR2 ); Racional operator-( const Racional &RefR1, const Racional &RefR2 ); Racional operator*( const Racional &RefR1, const Racional &RefR2 ); Racional operator/( const Racional &RefR1, const Racional &RefR2 ); bool operator>( const Racional &RefR1, const Racional &RefR2 ); bool operator>=( const Racional &RefR1, const Racional &RefR2 ); bool operator<( const Racional &RefR1, const Racional &RefR2 ); bool operator<=( const Racional &RefR1, const Racional &RefR2 ); bool operator==( const Racional &RefR1, const Racional &RefR2 ); bool operator!=( const Racional &RefR1, const Racional &RefR2 ); void Imprimir( const Racional &RefR1, const Racional &RefR2 ); istream &operator>>( istream &Leer, Racional &RefR ); ostream &operator<<( ostream &Escribir, Racional &RefR ); void Imprimir( Racional &RefR, Racional &RefR1, Racional &RefR2, char Simbolo ); /*void Imprimir( const Racional &RefR, const Racional &RefR1, const Racional &RefR2, char Simbolo ) { cout << RefR1.Numerador << '/' << RefR1.Denominador << " " << Simbolo << " " << RefR2.Numerador << '/' << RefR2.Denominador << " = " << RefR.Numerador << '/' << RefR.Denominador << endl << endl; }//Fin de Imprimir( )*/



int main( void ) { system( "cls" ); Racional R, R1, R2; int Opcion; char Respuesta, Simbolo; string OperacionRealizada; do { Opcion = Menu( ); if( Opcion != 5 ) cin >> R1 >> R2; switch( Opcion ) { case 1: R = R1 + R2; Simbolo = '+'; OperacionRealizada = "SUMA"; break; case 2: R = R1 - R2; Simbolo = '-'; OperacionRealizada = "RESTA"; break; case 3: R = R1 * R2; Simbolo = '*'; OperacionRealizada = "MULTIPLICACION"; break; case 4: R = R1 / R2; Simbolo = '/'; OperacionRealizada = "DIVISION"; break; case 5: break; }//Fin del switch( ) if( ( R2.Numerador == 0 && Opcion == 4 ) || ( Opcion == 5 ) ) { cout << endl << endl; }//Fin del if else { Simplificar( R ); cout << endl << "EL RESULTADO DE LA " << OperacionRealizada << " ES" << endl; Imprimir( R, R1, R2, Simbolo ); }//Fin del else cout << "Deseas continuar S/N: "; cin >> Respuesta; }while( Respuesta = toupper( Respuesta ) == 'S' );



do { system( "cls" ); cout << "\t\tPRUEBA DE LAS RELACIONES" << endl << endl; cin >> R1 >> R2; Imprimir( R1, R2 ); cout << "Deseas continuar S/N: "; cin >> Respuesta; }while( Respuesta = toupper( Respuesta ) == 'S' ); }//Fin del main( ) int Menu( void ) { int Opcion; bool Bandera = true; while( Bandera == true ) { system( "cls" ); cout << "SELECCIONA UNA OPCION" << endl; cout << "1.- Suma de racionales" << endl << "2.- Resta de racionales" << endl << "3.- Multiplicacion de racionales" << endl << "4.- Division de racionales" << endl << "5.- Salir" << endl << endl; cout << "Dame tu opcion: "; cin >> Opcion; try { if( Opcion < 1 || Opcion > 5 ) throw Opcion; else Bandera = false; }// Fin de try( ) catch( int e ) { cout << endl; cout << "Opcion equivocada. Intentelo nuevamente. " << "Enter para continuar."; cin.ignore( ); getch( ); cout << endl << endl; }//Fin de catch( ) }// fin del while return Opcion; }//Fin de Menu( ) void Normalizar( Racional &RefR ) { RefR.Numerador = -RefR.Numerador; RefR.Denominador = -RefR.Denominador; }//Fin de Normalizar( )



int MCD( int Dividendo, int Divisor ) { int Residuo; while( Dividendo % Divisor != 0 ) { Residuo = Dividendo % Divisor; Dividendo = Divisor; Divisor = Residuo; }//Fin del while return Divisor; }//Fin de MCD( ) void Simplificar( Racional &RefR ) { int mcd; Racional R; R = RefR; if( R.Numerador < 0 ) R.Numerador = -R.Numerador; if( R.Denominador < 0 ) R.Denominador = -R.Denominador; mcd = MCD( R.Numerador, R.Denominador ); RefR.Numerador = RefR.Numerador / mcd; RefR.Denominador = RefR.Denominador / mcd; if( RefR.Denominador < 0 ) Normalizar( RefR ); }//Fin de Simplificar( ) Racional LeerRacional( void ) { Racional R; bool Bandera = true; int Den; cout << endl; cout << "DATOS DEL NUMERO RACIONAL" << endl; cout << "Dame el numerador: "; cin >> R.Numerador; while( Bandera == true ) { cout << "Dame el denominador: "; cin >> Den; try { if( Den == 0 ) throw Den; else Bandera = false; }//Fin de try catch( int e ) { cout << endl; cout << "El denominador debe ser distinto de cero." << endl << "Intentelo nuevamente. Enter para continuar."; cin.ignore( ); getch( ); cout << endl << endl; }//Fin del catch( )



}// Fin del while R.Denominador = Den; if( R.Denominador < 0 ) Normalizar( R ); return R; }//Fin de LeerRacional( ) Racional Suma( const Racional &RefR1, const Racional &RefR2 ) { Racional R; R.Denominador = RefR1.Denominador * RefR2.Denominador; R.Numerador = ( RefR2.Denominador * RefR1.Numerador ) + ( RefR1.Denominador * RefR2.Numerador ); return R; /* El cuerpo de esta función también pudo haber sido: Racional R = { ( RefR2.Denominador * RefR1.Numerador ) + ( RefR1.Denominador * RefR2.Numerador ), RefR1.Denominador * RefR2.Denominador }; return R; */ }//Fin de Suma( ) Racional Resta( const Racional &RefR1, const Racional &RefR2 ) { Racional R = { ( RefR2.Denominador * RefR1.Numerador ) - ( RefR1.Denominador * RefR2.Numerador ), RefR1.Denominador * RefR2.Denominador }; return R; }//Fin de Resta( ) Racional Multiplicacion( const Racional &RefR1, const Racional &RefR2 ) { Racional R = { RefR1.Numerador * RefR2.Numerador, RefR1.Denominador * RefR2.Denominador}; return R; }//Fin de Multiplicacion( ) Racional Division( const Racional &RefR1, const Racional &RefR2 ) { try { if( RefR2.Numerador == 0 ) throw 1; }//Fin de try catch( int e ) { cout << endl; cout << "No es posible hacer la division. Enter para continuar "; cin.ignore( ); getch( ); cout << endl << endl; return RefR2; }//Fin de catch( ) Racional R = { RefR1.Numerador * RefR2.Denominador, RefR1.Denominador * RefR2.Numerador}; return R; }//Fin de Division( )



Racional operator+( const Racional &RefR1, const Racional &RefR2 ) { Racional R; R.Denominador = RefR1.Denominador * RefR2.Denominador; R.Numerador = ( RefR2.Denominador * RefR1.Numerador ) + ( RefR1.Denominador * RefR2.Numerador ); return R; /* El cuerpo de esta función también pudo haber sido: Racional R = { ( RefR2.Denominador * RefR1.Numerador ) + ( RefR1.Denominador * RefR2.Numerador ), RefR1.Denominador * RefR2.Denominador }; return R; */ }//Fin de operator+( ) Racional operator-( const Racional &RefR1, const Racional &RefR2 ) { Racional R = { ( RefR2.Denominador * RefR1.Numerador ) - ( RefR1.Denominador * RefR2.Numerador ), RefR1.Denominador * RefR2.Denominador }; return R; }//Fin de operator-( ) Racional operator*( const Racional &RefR1, const Racional &RefR2 ) { Racional R = { RefR1.Numerador * RefR2.Numerador, RefR1.Denominador * RefR2.Denominador}; return R; }//Fin de opeator*( ) Racional operator/( const Racional &RefR1, const Racional &RefR2 ) { try { if( RefR2.Numerador == 0 ) throw 1; }//Fin de try catch( int e ) { cout << endl; cout << "No es posible hacer la division. Enter para continuar "; cin.ignore( ); cin.get( ); cout << endl << endl; return RefR2; }//Fin de catch( ) Racional R = { RefR1.Numerador * RefR2.Denominador, RefR1.Denominador * RefR2.Numerador}; return R; }//Fin de operator/( ) bool operator>( const Racional &RefR1, const Racional &RefR2 ) { return ( RefR1.Numerador * RefR2.Denominador) > ( RefR1.Denominador * RefR2.Numerador ); }//Fin de operator>( ) bool operator>=( const Racional &RefR1, const Racional &RefR2 ) { return ( RefR1.Numerador * RefR2.Denominador) >= ( RefR1.Denominador * RefR2.Numerador ); }//Fin de operator>=( )



bool operator<( const Racional &RefR1, const Racional &RefR2 ) { return ( RefR1.Numerador * RefR2.Denominador) < ( RefR1.Denominador * RefR2.Numerador ); }//Fin de operator<( ) bool operator<=( const Racional &RefR1, const Racional &RefR2 ) { return ( RefR1.Numerador * RefR2.Denominador) <= ( RefR1.Denominador * RefR2.Numerador ); }//Fin de operator<=( ) bool operator==( const Racional &RefR1, const Racional &RefR2 ) { return ( RefR1.Numerador * RefR2.Denominador) == ( RefR1.Denominador * RefR2.Numerador ); }//Fin de operator==( ) bool operator!=( const Racional &RefR1, const Racional &RefR2 ) { return ( RefR1.Numerador * RefR2.Denominador) != ( RefR1.Denominador * RefR2.Numerador ); }//Fin de operator!=( ) void Imprimir( const Racional &RefR1, const Racional &RefR2 ) { cout << "RELACIONES POSIBLES ENTRE DOS RACIONALES" << endl; if( RefR1 > RefR2 ) { cout << RefR1.Numerador << '/' << RefR1.Denominador << " es mayor que " << RefR2.Numerador << '/' << RefR2.Denominador << endl; }//Fin del if if( RefR1 >= RefR2 ) { cout << RefR1.Numerador << '/' << RefR1.Denominador << " es mayor o igual que " << RefR2.Numerador << '/' << RefR2.Denominador << endl; }//Fin del if if( RefR1 < RefR2 ) { cout << RefR1.Numerador << '/' << RefR1.Denominador << " es menor que " << RefR2.Numerador << '/' << RefR2.Denominador << endl; }//Fin del if if( RefR1 <= RefR2 ) { cout << RefR1.Numerador << '/' << RefR1.Denominador << " es menor o igual que " << RefR2.Numerador << '/' << RefR2.Denominador << endl; }//Fin del if if( RefR1 != RefR2 ) { cout << RefR1.Numerador << '/' << RefR1.Denominador << " es distinto que " << RefR2.Numerador << '/' << RefR2.Denominador << endl; }//Fin del if if( RefR1 == RefR2 ) { cout << RefR1.Numerador << '/' << RefR1.Denominador << " es igual que " << RefR2.Numerador << '/' << RefR2.Denominador << endl; }//Fin del if cout << endl; }//Fin de Imprimir( )



istream &operator>>( istream &Leer, Racional &RefR ) { bool Bandera = true; int Den; char Diagonal; cout << endl; cout << "DATOS DEL NUMERO RACIONAL" << endl; while( Bandera == true ) { cout << "Dame el quebrado: "; Leer >> RefR.Numerador >> Diagonal >> Den; try { if( Den == 0 ) throw Den; else Bandera = false; }//Fin de try catch( int e ) { cout << endl; cout << "El denominador debe ser distinto de cero." << endl << "Intentelo nuevamente. Enter para continuar."; cin.ignore( ); cin.get( ); cout << endl << endl; }//Fin del catch( ) }// Fin del while cout << endl; RefR.Denominador = Den; if( RefR.Denominador < 0 ) Normalizar( RefR ); return Leer; }//Fin de operator>>( ) ostream &operator<<( ostream &Escribir, Racional &RefR ) { Escribir << RefR.Numerador << '/' << RefR.Denominador;

return Escribir; }//Fin del operator<<( ) void Imprimir( Racional &RefR, Racional &RefR1, Racional &RefR2, char Simbolo ) { cout << RefR1 << " " << Simbolo << " " << RefR2 << " = " << RefR << endl << endl; }//Fin de Imprimir( ) /*void Imprimir( const Racional &RefR, const Racional &RefR1, const Racional &RefR2, char Simbolo ) { cout << RefR1.Numerador << '/' << RefR1.Denominador << " " << Simbolo << " " << RefR2.Numerador << '/' << RefR2.Denominador << " = " << RefR.Numerador << '/' << RefR.Denominador << endl << endl; }//Fin de Imprimir( )*/



EFINICION DEL PROBLEMA [PROYECTO 02A.CPP] Modelar la estructura Complejo formado por los campos Real e Imaginario.

Para los complejos U = a + bi y V = C + di U + V = ( a + c ) + ( b + d )i U - V = ( a - c ) + ( b - d )i U * V = ( ac - bd ) + ( ad + bc )i U / V = ( ac + bd ) / ( c^2 + d^2 ) + ( bc - ad ) / ( c^2 + d^2 )i SALIDA: SELECCIONA UNA OPCION 1.- Suma de complejos 2.- Resta de complejos 3.- Multiplicacion de complejos Menu( ) 4.- Division de complejos 5.- Salir Dame tu opcion: 1 ValidarOpcion( ) DATOS DEL NUMERO COMPLEJO Dame la parte real : 1 Leer( ) Dame la parte imaginaria : 1 DATOS DEL NUMERO COMPLEJO Dame la parte real : 2 Dame la parte imaginaria : 2 Suma( ) EL RESULTADO DE LA SUMA ES Resta( ) ( 1, 1 ) + ( 2, 2 ) = ( 3, 3 ) Multiplicacion( ) Imprimir( ) ValidarDenominador( ) Division( ) Deseas continuar S/N : s ---------------------------------- SELECCIONA UNA OPCION 1.- Suma de complejos 2.- Resta de complejos 3.- Multiplicacion de complejos 4.- Division de complejos 5.- Salir Dame tu opcion: 4 DATOS DEL NUMERO COMPLEJO Dame la parte real : : 1 Dame la parte imaginaria : 1 DATOS DEL NUMERO COMPLEJO Dame la parte real : 0 Dame la parte imaginaria : 0 El segundo complejo es cero La division no puede realizarce. ENTER para continuar. Deseas continuar S/N: n




Una función Menu( ) que muestre las opciones disponibles. Su prototipo es el siguiente:

int Menu( void );

o Dentro de la función Menu( ), se llama a la función ValidarOpcion( ), que devuelve falso o verdadero, dependiendo de si la opción seleccionada es falsa o verdadero. Su prototipo es el siguiente:

bool ValidarOpcion( const int Opcion );

Una función Leer( ) que lee los datos del número complejo (parte real y parte imaginaria). Su

prototipo es el siguiente:

Complejo LeerComplejo( void );

Funciones para realizar las operaciones de suma, resta, multiplicacion y division. Sus prototipos son los siguientes:

Complejo Suma( const Complejo &RefC1, const Complejo &RefC2 ); Complejo Resta( const Complejo &RefC1, const Complejo &RefC2 );

Complejo Multiplicacion( const Complejo &RefC1, const Complejo &RefC2 ); Complejo Division( const Complejo &RefC1, const Complejo &RefC2 );

o Dentro de la función Division( ) se llama a la función ValidarDenominador( ) para

garantizar que el segundo complejo no es el complejo cero.Su prototipo es el siguiente:

bool ValidarDenominador( const Complejo &RefC );

Una función Imprimir( ) que imprime el resultado de la operación realizada, los operandos y el operador. Su prototipo es el siguiente:

void Imprimir( const ComplejoRef C, const Complejo &RefC1, const Complejo &RefC2,

const char Simbolo );




/* Nombre del programa: PROYECTO 02A.CPP */ using namespace std; #include <iostream> //Para cout y cin #include <cctype> //Para to upper( ) #include <cmath> //Para pow( ) #include <string> //Para utilizar la clase string struct Complejo { double Real; double Imaginario; };//Fin de la estructura Racional int Menu( void ); Complejo LeerComplejo( void ); Complejo Suma( const Complejo &RefC1, const Complejo &RefC2 ); Complejo Resta( const Complejo &RefC1, const Complejo &RefC2 ); Complejo Multiplicacion( const Complejo &RefC1, const Complejo &RefC2 ); Complejo Division( const Complejo &RefC1, const Complejo &RefC2 ); void Imprimir( const Complejo RefC, const Complejo &RefC1, const Complejo &RefC2, const char Simbolo, const string OperacionRealizada ); int main( void ) { system( "cls" ); Complejo C, C1, C2; int Opcion; char Respuesta, Operacion; string OperacionRealizada; do { Opcion = Menu( ); if( Opcion != 5 ) { C1 = LeerComplejo( ); C2 = LeerComplejo( ); } switch( Opcion ) { case 1: C = Suma( C1, C2 ); Operacion = '+'; OperacionRealizada = "SUMA"; break; case 2: C = Resta( C1, C2 ); Operacion = '-'; OperacionRealizada = "RESTA"; break; case 3: C = Multiplicacion( C1, C2 ); Operacion = '*'; OperacionRealizada = "MULTIPLICACION"; break;



case 4: C = Division( C1, C2 ); Operacion = '/'; OperacionRealizada = "DIVISION"; break; case 5: break; }//Fin del switch( ) if( Opcion == 4 && ( C2.Real == 0 && C2.Imaginario == 0 ) || Opcion == 5 ) cout << endl; else { cout << endl; cout << "EL RESULTADO DE LA " << OperacionRealizada << " ES" << endl; Imprimir( C, C1, C2, Operacion, OperacionRealizada ); }//Fin del else cout << "Deseas continuar S/N: "; cin >> Respuesta; }while( Respuesta = toupper( Respuesta ) == 'S' ); return 0; }//Fin del main( ) int Menu( void ) { int Opcion; bool Bandera = true; while( Bandera == true ) { system( "cls" ); cout << "SELECCIONA UNA OPCION" << endl; cout << "1.- Suma de complejos" << endl << "2.- Resta de complejos" << endl << "3.- Multiplicacion de complejos" << endl << "4.- Division de complejos" << endl << "5.- Salir" << endl << endl; cout << "Dame tu opcion: "; cin >> Opcion; try { if( Opcion < 1 || Opcion > 5 ) throw Opcion; else Bandera = false; }// Fin de try catch( int e ) { cout << endl; cout << "Opcion equivocada. Intentelo nuevamente. " << "Enter para continuar."; cin.ignore( ); cin.get( ); cout << endl << endl; }//Fin de catch( ) }//Fin del while return Opcion; }//Fin de Menu( )



Complejo LeerComplejo( void ) { Complejo C; cout << endl; cout << "DATOS DEL NUMERO COMPLEJO" << endl; cout << "Dame la parte real : "; cin >> C.Real; cout << "Dame la parte imaginaria : "; cin >> C.Imaginario; return C; }//Fin de LeerRacional( ) Complejo Suma( const Complejo &RefC1, const Complejo &RefC2 ) { Complejo C = { RefC1.Real + RefC2.Real, RefC1.Imaginario + RefC2.Imaginario }; return C; }//Fin de Suma( ) Complejo Resta( const Complejo &RefC1, const Complejo &RefC2 ) { Complejo C = { RefC1.Real - RefC2.Real, RefC1.Imaginario - RefC2.Imaginario }; return C; }//Fin de Resta( ) Complejo Multiplicacion( const Complejo &RefC1, const Complejo &RefC2 ) { Complejo C; C.Real = ( RefC1.Real * RefC2.Real - RefC1.Imaginario * RefC2.Imaginario ); C.Imaginario = ( RefC1.Real * RefC2.Imaginario + RefC1.Imaginario * RefC2.Real ); return C; }//Fin de Multiplicacion( ) Complejo Division( const Complejo &RefC1, const Complejo &RefC2 ) { Complejo C = { 0, 1 }; bool Bandera = true; float Denominador; try { if( RefC2.Real == 0 && RefC2.Imaginario == 0 ) throw 1; }//Fin de try catch( int e ) { cout << endl << "El segundo complejo es cero" << endl << "La division no puede realizarce. ENTER para continuar. "; cin.ignore( ); cin.get( ); Bandera = false; cout << endl; }//Fin de catch( )



if( Bandera == true ) { Denominador = pow ( RefC2.Real, 2.0 ) + pow( RefC2.Imaginario, 2.0 ); C.Real = ( ( RefC1.Real * RefC2.Real ) + ( RefC1.Imaginario * RefC2.Imaginario ) ) / Denominador; C.Imaginario = ( ( RefC1.Imaginario * RefC2.Real ) - ( RefC1.Real * RefC2.Imaginario ) ) / Denominador; }//Fin del if return C; }//Fin de Division( ) void Imprimir( const Complejo RefC, const Complejo &RefC1, const Complejo &RefC2, const char Simbolo, const string OperacionRealizada ) { cout << "( " << RefC1.Real << ", " << RefC1.Imaginario << " ) " << Simbolo << " " << "( " << RefC2.Real << ", " << RefC2.Imaginario << " ) " << " = " << "( " << RefC.Real << ", " << RefC.Imaginario << " ) " << endl << endl; }//Fin de Imprimir( )



DEFINICION DEL PROBLEMA [PROYECTO 02B.CPP] Modelar la estructura Complejo formado por los campos Real e Imaginario. Sobrecargar los operadores >>, <<, +, -, * y /. Para los complejos U = a + bi y V = C + di U + V = ( a + c ) + ( b + d )i U - V = ( a - c ) + ( b - d )i U * V = ( ac - bd ) + ( ad + bc )i U / V = ( ac + bd ) / ( c^2 + d^2 ) + ( bc - ad ) / ( c^2 + d^2 )i SALIDA: SELECCIONA UNA OPCION 1.- Suma de complejos 2.- Resta de complejos 3.- Multiplicacion de complejos Menu( ) 4.- Division de complejos 5.- Salir Dame tu opcion: 1 ValidarOpcion( ) DAME UN NUMERO COMPLEJO a+bi: 1+1i DAME UN NUMERO COMPLEJO a+bi: 2+2i Leer( ) Suma( ) EL RESULTADO DE LA SUMA ES Resta( ) (1+1i)+(2+2i) = (3+3i) Multiplicacion( ) Imprimir( ) ValidarDenominador( ) Division( )

Deseas continuar S/N: s ---------------------------------- SELECCIONA UNA OPCION 1.- Suma de complejos 2.- Resta de complejos 3.- Multiplicacion de complejos 4.- Division de complejos 5.- Salir Dame tu opcion: 4 DAME UN NUMERO COMPLEJO a+bi: 1+1i DAME UN NUMERO COMPLEJO a+bi: 0+0i El segundo complejo es cero La division no puede realizarce. ENTER para continuar. Deseas continuar S/N: n




Una función Menu( ) que muestre las opciones disponibles. Su prototipo es el siguiente:

int Menu( void );

o Dentro de la función Menu( ), se llama a la función ValidarOpcion( ), que devuelve falso o verdadero, dependiendo de si la opción seleccionada es falsa o verdadero. Su prototipo es el siguiente:

bool ValidarOpcion( const int Opcion );

Una función sobrecargada operator>>( ) que lee los datos del número complejo en el formato a+bi.

Su prototipo es el siguiente:

istream &operator>>( istream &Leer, Complejo & RefC )

Funciones para realizar las operaciones de suma, resta, multiplicacion y division. Sus prototipos son los siguientes:

Complejo operator+( const Complejo &RefC1, const Complejo &RefC2 ); Complejo operator-( const Complejo &RefC1, const Complejo &RefC2 ); Complejo operator*( const Complejo &RefC1, const Complejo &RefC2 ); Complejo operator/( const Complejo &RefC1, const Complejo &RefC2 );

o Dentro de la función sobrecargada operator/( ) se llama a la función

ValidarDenominador( ) para garantizar que el segundo complejo no es el complejo cero.Su prototipo es el siguiente:

bool ValidarDenominador( const Complejo &RefC );

Una función Imprimir( ) que imprime el resultado de la operación realizada, los operandos y el

operador. Su prototipo es el siguiente:

void Imprimir(ComplejoRef C, Complejo &RefC1, Complejo &RefC2, const char Simbolo, const string OperacionRealizada );

Dentro de la función Imprimir, se llama a la función sobrecargada operator<<( ) cuyo prototipo es

el siguiente:

ostream &operator<<( ostream &Escribir, Complejo &RefC )




/* Nombre del programa: PROYECTO 02B.CPP */ using namespace std; #include <iostream> //Para cout y cin #include <cctype> //Para to upper( ) #include <cmath> //Para pow( ) #include <string> //Para utilizar la clase string struct Complejo { double Real; double Imaginario; };//Fin de la estructura Racional int Menu( void ); istream &operator>>( istream &Leer, Complejo &RefC ); Complejo operator+( const Complejo &RefC1, const Complejo &RefC2 ); Complejo operator-( const Complejo &RefC1, const Complejo &RefC2 ); Complejo operator*( const Complejo &RefC1, const Complejo &RefC2 ); Complejo operator/( const Complejo &RefC1, const Complejo &RefC2 ); void Imprimir( Complejo RefC, Complejo &RefC1, Complejo &RefC2, const char Simbolo, const string OperacionRealizada ); ostream &operator<<( ostream &Escribir, Complejo &RefC ); int main( void ) { system( "cls" ); Complejo C, C1, C2; int Opcion; char Respuesta, Operacion; string OperacionRealizada; do { Opcion = Menu( ); if( Opcion != 5 ) cin >> C1 >> C2; switch( Opcion ) { case 1: C = C1 + C2; Operacion = '+'; OperacionRealizada = "SUMA"; break; case 2: C = C1 - C2; Operacion = '-'; OperacionRealizada = "RESTA"; break; case 3: C = C1 * C2; Operacion = '*'; OperacionRealizada = "MULTIPLICACION"; break;



case 4: C = C1 / C2; Operacion = '/'; OperacionRealizada = "DIVISION"; break; case 5: break; }//Fin del switch( ) if( Opcion == 4 && ( C2.Real == 0 && C2.Imaginario == 0 ) || Opcion == 5 ) cout << endl; else { cout << endl; cout << "EL RESULTADO DE LA " << OperacionRealizada << " ES" << endl; Imprimir( C, C1, C2, Operacion, OperacionRealizada ); }//Fin del else cout << "Deseas continuar S/N: "; cin >> Respuesta; }while( Respuesta = toupper( Respuesta ) == 'S' ); return 0; }//Fin del main( ) int Menu( void ) { int Opcion; bool Bandera = true; while( Bandera == true ) { system( "cls" ); cout << "SELECCIONA UNA OPCION" << endl; cout << "1.- Suma de complejos" << endl << "2.- Resta de complejos" << endl << "3.- Multiplicacion de complejos" << endl << "4.- Division de complejos" << endl << "5.- Salir" << endl << endl; cout << "Dame tu opcion: "; cin >> Opcion; try { if( Opcion < 1 || Opcion > 5 ) throw Opcion; else Bandera = false; }// Fin de try catch( int e ) { cout << endl; cout << "Opcion equivocada. Intentelo nuevamente. " << "Enter para continuar."; cin.ignore( ); cin.get( ); cout << endl << endl; }//Fin de catch( ) }//Fin del while return Opcion; }//Fin de Menu( )



istream &operator>>( istream &Leer, Complejo &RefC ) { char Caracter; cout << "DAME UN NUMERO COMPLEJO a+bi: "; Leer >> RefC.Real >> Caracter >> RefC.Imaginario >> Caracter; return Leer; }//Fin de operator>>( ) Complejo operator+( const Complejo &RefC1, const Complejo &RefC2 ) { Complejo C = { RefC1.Real + RefC2.Real, RefC1.Imaginario + RefC2.Imaginario }; return C; }//Fin de operator+( ) Complejo operator-( const Complejo &RefC1, const Complejo &RefC2 ) { Complejo C = { RefC1.Real - RefC2.Real, RefC1.Imaginario - RefC2.Imaginario }; return C; }//Fin de operator-( ) Complejo operator*( const Complejo &RefC1, const Complejo &RefC2 ) { Complejo C; C.Real = ( RefC1.Real * RefC2.Real - RefC1.Imaginario * RefC2.Imaginario ); C.Imaginario = ( RefC1.Real * RefC2.Imaginario + RefC1.Imaginario * RefC2.Real ); return C; }//Fin de operator*( ) Complejo operator/( const Complejo &RefC1, const Complejo &RefC2 ) { Complejo C = { 0, 1 }; bool Bandera = true; float Denominador; try { if( RefC2.Real == 0 && RefC2.Imaginario == 0 ) throw 1; }//Fin de try catch( int e ) { cout << endl << "El segundo complejo es cero" << endl << "La division no puede realizarce. ENTER para continuar. "; cin.ignore( ); cin.get( ); Bandera = false; cout << endl; }//Fin de catch( ) if( Bandera == true ) { Denominador = pow ( RefC2.Real, 2.0 ) + pow( RefC2.Imaginario, 2.0 ); C.Real = ( ( RefC1.Real * RefC2.Real ) + ( RefC1.Imaginario * RefC2.Imaginario ) ) / Denominador; C.Imaginario = ( ( RefC1.Imaginario * RefC2.Real ) - ( RefC1.Real * RefC2.Imaginario ) ) / Denominador; }//Fin del if return C; }//Fin de operator/( )



void Imprimir( Complejo RefC, Complejo &RefC1, Complejo &RefC2, const char Simbolo, const string OperacionRealizada ) { cout << RefC1 << Simbolo << RefC2 << " = " << RefC << endl << endl; }//Fin de Imprimir( ) ostream &operator<<( ostream &Escribir, Complejo &RefC ) { Escribir << "(" << RefC.Real << '+' << RefC.Imaginario << "i)"; }//Fin de operator<<( )



DEFINICION DEL PROBLEMA [PROYECTO 03A.CPP] Elaborar una estructura que representa a un directorio telefónico. Sus campos son los siguientes:

Nombre Completo, Número telefónico, un apuntador

SALIDA Juan Pérez Jolote (555) 888-2323 Andrés Manuel López Obrador (555) 678-1234 Plutarco Elías Calles (555) 123-4567 ANALISIS DEL PROBLEMA

Se definirá la estructura. Se declararán tres variables del tipo de la estructura inicializándolas. En forma directa se creará un apuntador que apunta a la primera variable, el apuntador de cada variable apuntará a la siguiente estructura. El apuntador de la última estructura contendrá el apuntador NULL. Se imprimirán las tres variables utilizando el campo apuntador. Gráficamente la solución es la siguiente:

AptPrimero DT1 DT2 DT3

• • NULL •




/* Nombre del programa: PROYECTO 03A.CPP */ using namespace std; #include <iostream> //Para cout y cin #include <iomanip> //Para setiosflags( ) #include <string> //Para getline( ) y la clase string struct DirTel { string Nombre; string NumTel; DirTel *AptSiguiente; }; //Fin de DirTel int main( void ) { system( "cls" ); DirTel DT1 = { "Juan Pérez Jolote", " (555) 888-2323" }; DirTel DT2 = { "Andrés Manuel López Obrador", " (555) 678-1234" }; DirTel DT3 = { "Plutarco Elias Calles", " (555) 123-4567" }; DirTel *AptPrimero; AptPrimero = &DT1; DT1.AptSiguiente = &DT2; DT2.AptSiguiente = &DT3; DT3.AptSiguiente = NULL; cout << setiosflags( ios::left ); cout << setw( 30 ) << AptPrimero -> Nombre << setw( 20) << AptPrimero -> NumTel << endl << setw( 30 ) << DT1.AptSiguiente -> Nombre << setw( 20 ) << DT1.AptSiguiente -> NumTel << endl << setw( 30 ) << DT2.AptSiguiente -> Nombre << setw( 20 ) << DT2.AptSiguiente -> NumTel << endl << endl; cin.ignore( ); cin.get( ); return 0; }//Fin de main( )



DEFINIFICION DEL PROBLEMA [PROYECTO 03B.CPP] Se trata del mismo programa PROYECTO 03A.CPP, ahora se elaborarán las dos tareas Leer( ) e Imprimir( ) en vez de inicializar los datos de las estructuras. Es decir, se dará una solución general al problema. SALIDA

INTRODUZCA LOS DATOS DE SU DIRECTORIO TELEFONICO Introduzca un nombre : Juan Pérez Jolote

Introduzca el número telefónico : (555) 888-2323 Introduzca un nombre : Andrés Manuel López Obrador Leer( ) Introduzca el número telefónico : (555) 678-1234 Introduzca un nombre : Plutarco Elías Calles Introduzca el número telefónico : (555) 123-4567

IMPRESION DEL DIRECTORIO TELEFONICO

Juan Pérez Jolote (555) 888-2323 Andrés Manuel López Obrador (555) 678-1234 Imprimir( ) Plutarco Elías Calles (555) 123-4567 ANALISIS DEL PROBLEMA

Se crean dos funciones: Leer( ) e Imprimir( ) cuyos prototipos son los siguientes:

void Leer( DirTel *AptRegistro ); void Imprimir( const DirTel *AptRegistro );

La idea básica es que en cada llamada a la función correspondiente se actualice el apuntador, para enviar la dirección correspondiente al siguiente registro, misma que se logra de la manera siguiente:

AptActual = AptActual -> AptSiguiente;



CODIFICACION DEL PROGRAMA /* Nombre del programa: PROYECTO 03B.CPP */

using namespace std; #include <iostream> //Para cout y cin #include <iomanip> //Para setiosflags( ) #include <string> //Para getline( ) y la clase string struct DirTel { string Nombre; string NumTel; DirTel *AptSiguiente; }; //Fin de DirTel{ } void Leer( DirTel *AptRegistro ); void Imprimir( const DirTel *AptRegistro ); int main( void ) { system( “cls” ); const int NUMREGS = 3; //Número máximo de registros DirTel *AptLista, *AptActual; AptLista = new DirTel; AptActual = AptLista; cout << "INTRODUZCA LOS DATOS DE SU DIRECTORIO TELEFONICO" << endl; for( int i = 0; i < NUMREGS - 1; i++ ) { Leer( AptActual ); AptActual -> AptSiguiente = new DirTel; AptActual = AptActual -> AptSiguiente; }//Fin del for Leer( AptActual ); AptActual -> AptSiguiente = NULL; cout << endl << "IMPRESION DEL DIRECTORIO TELEFONICO" << endl; AptActual = AptLista; while( AptActual != NULL ) { Imprimir( AptActual ); AptActual = AptActual -> AptSiguiente; }//Fin del while cin.get( ); return 0; }//Fin de main( ) void Leer( DirTel *AptRegistro ) { cout << endl << "Introduzca un nombre : "; getline( cin, AptRegistro -> Nombre ); cout << "Introduzca el número telefónico : "; getline( cin, AptRegistro -> NumTel ); }//Fin de Leer( ) void Imprimir( const DirTel *AptRegistro ) { cout << setiosflags( ios::left ) << setw( 30 ) << AptRegistro -> Nombre << setw( 20 ) << AptRegistro -> NumTel << endl; }//Fin de Imprimir( )



DEFINICION DEL PROBLEMA [PROYECTO 03C.CPP] Es el mismo problema PROYECTO 03B.CPP, en su versión de arreglo en vez de una lista ligada. Se muestran diferentes funciones que manejan la salida. SALIDA

Introduzca un nombre : Juan Perez Jolote Introduzca el numero telefonico : (555) 888-2323 Introduzca un nombre : Andres Manuel Lopez Obrador Introduzca el numero telefonico : (555) 678-1234 Introduzca un nombre : Plutarco Elias Calles Introduzca el numero telefonico : (555) 123-4567 DATOS DEL EMPLEADO Juan Perez Jolote (555) 888-2323 Andres Manuel Lopez Obrador (555) 678-1234 Plutarco Elias Calles (555) 123-4567 DATOS DEL EMPLEADO Juan Perez Jolote (555) 888-2323 Andres Manuel Lopez Obrador (555) 678-1234 Plutarco Elias Calles (555) 123-4567 DATOS DEL EMPLEADO Juan Perez Jolote (555) 888-2323 Andres Manuel Lopez Obrador (555) 678-1234 Plutarco Elias Calles (555) 123-4567 ANALISIS DEL PROBLEMA

La lectura se hace mediante la función Leer( ) cuyo prototipo es el siguiente:

void Leer( DirTel ArreDirTel[ ], int TamArre );

En este caso se proponen tres formas diferentes de Imprimir( ), sus prototipos son los siguientes:

void Imprimir( const DirTel ArreDirTel[ ], int TamArre ); void Imprimir2( const DirTel *AptPrimero, int TamArre );

void Imprimir3( const DirTel *AptPrimero, int TamArre );




/* Nombre del programa: PROYECTO 03C.CPP */ using namespace std; #include <iostream> //Para cout y cin #include <iomanip> //Para setiosflags( ) struct DirTel { string Nombre; string NumTel; DirTel *AptSiguiente; }; void Leer( DirTel ArreDirTel[ ], int TamArre ); void Imprimir1( const DirTel ArreDirTel[ ], int TamArre ); void Imprimir2( const DirTel *AptPrimero, int TamArre ); void Imprimir3( const DirTel *AptPrimero, int TamArre ); int main( void ) { system( “cls” ); const int TAM_ARRE = 3; DirTel ArreDirTel[ TAM_ARRE ]; Leer( ArreDirTel, TAM_ARRE ); cout << setiosflags( ios::left ); Imprimir1( ArreDirTel, TAM_ARRE ); Imprimir2( ArreDirTel, TAM_ARRE ); Imprimir3( ArreDirTel, TAM_ARRE ); cin.ignore( ); cin.get( ); return 0; }//Fin del main( ) void Leer( DirTel ArreDirTel[ ], int TamArre ) { int i; for( i = 0; i < TamArre; i++ ) { cout << "Introduzca un nombre : "; getline( cin, ArreDirTel[ i ].Nombre ); cout << "Introduzca el numero telefonico : "; getline( cin, ArreDirTel[ i ].NumTel ); ArreDirTel[ i ].AptSiguiente = &ArreDirTel[ i + 1 ]; cout << endl; }//Fin del for ArreDirTel[ i - 1 ].AptSiguiente = NULL; cout << endl; }//Fin de Leer( ) void Imprimir1( const DirTel ArreDirTel[ ], int TamArre ) { int i; cout << "DATOS DEL EMPLEADO" << endl; for( i = 0; i < TamArre; i++ ) { cout << setw( 30 ) << ArreDirTel[ i ].Nombre << setw( 20 ) << ArreDirTel[ i ].NumTel << endl; }//Fin del for cout << endl; }//Fin de Imprimir1( )



void Imprimir2( const DirTel *AptPrimero, int TamArre ) { int i; cout << "DATOS DEL EMPLEADO" << endl; cout << setw( 30 ) << ( *AptPrimero ).Nombre << setw( 20 ) << ( *AptPrimero ).NumTel << endl; for( i = 0; i < TamArre - 1; i++ ) { cout << setw( 30 ) << (*(((*(AptPrimero + i )).AptSiguiente))).Nombre << setw( 20 ) << ((*(AptPrimero + i )).AptSiguiente)->NumTel << endl ; }//Fin del for cout << endl; } //Fin de Imprimir2( ) void Imprimir3( const DirTel *AptPrimero, int TamArre ) { int i; cout << "DATOS DEL EMPLEADO" << endl; while( AptPrimero != NULL ) { cout << setw( 30 ) << ( *AptPrimero ).Nombre << setw( 20 ) << ( *AptPrimero ).NumTel << endl; AptPrimero = ( *AptPrimero ).AptSiguiente; }//Fin del for cout << endl; } //Fin de Imprimir3( )

Programas con union



union

Programas con union


Uniones

Esta sección presenta la union. Como se verá, ésta es muy similar a una estructura en muchos aspectos pero con una

diferencia importante. La union se utiliza para almacenar tipos de datos diferentes en la misma zona de memoria. Su formato es el siguiente:

union Etiqueta { tipo IdentificadorMiembro1; tipo IdentificadorMiembro2; . . . tipo IdentificadorMiembroN; };

Como se puede ver, la declaración de una union tiene la misma forma que la declaración de una estructura. La

diferencia se encuentra en la palabra reservada union. Todas las reglas vistas hasta este momento para las estructuras son igualmente aplicables a las uniones. La cantidad

de memoria que requiere una variable de tipo union es la cantidad de memoria que necesita el miembro más grande de la union. Todos los miembros se almacenan en la misma zona de memoria (pero no todos al mismo tiempo), es decir en la misma dirección

Suponga que tiene un programa que gestiona dos fechas especiales. Para los empleados en actividad, el programa escribe los días que el empleado ha trabajado. Para los empleados que ya no trabajan para la compañía la fecha se refiere al último día que trabajó para la compañía. Escriba una estructura que muestre esta situación y posteriormente optimice la estructura mediante una union.

struct FechaEmp { int DiasTrabajados; struct UltimaFecha {

int Dia; int Mes; int Anhio;

} UltimoDia; //Fin de la subestructura ultimaFecha }; //Fin de la superestructura fechaEmp union FechaEmp { int DiasTrabajados; struct UltimaFecha {

int Dia; int Mes; int Anhio;

} UltimoDia; //Fin de la subestructura UltimaFecha }; //Fin de la union FechaEmp.

Programas con union


DEFINICION DEL PROBLEMA [UNION 01.CPP] Crear una estructura de union con los campos ValorEntero y ValorReal. Mostrar el tamaño de la union y verificar que ambos campos (ValorEntero, ValorReal) ocupan la misma posicion (dirección). Por simplicidad, no se crean funciones. SALIDA

Tamaño de la union: 4 bytes

El valor entero es 123 Dirección de comienzo: 0x16c72b24 El valor real es 123.45 Dirección de comienzo: 0x16c72b24


Simplemente se crea una estructura union y mediante el operador sizeof( ) se determinan el tamaño de la union, se inicializan los campos y se muestran las direcciones de ambos campos. Se observa que comparten la misma área ( dirección).

CODIFICACION DEL PROBLEMA /* Nombre del programa: UNION 01.CPP */

using namespace std; #include <iostream.h> //Para cout y cin #include <conio.h> //Para clrscr( ) y getch( ) union EnteroReal { int ValorEntero; float ValorReal; }; int main( void ) { system( “cls” ); EnteroReal ValorEnteroReal; cout << "Tamaño de la union: " << sizeof( EnteroReal ) << " bytes" << endl << endl; ValorEnteroReal.ValorEntero = 123; cout << "El valor entero es " << ValorEnteroReal.ValorEntero << endl; cout << "Dirección de comienzo: " << &ValorEnteroReal.ValorEntero << endl << endl; ValorEnteroReal.ValorReal = 123.45; cout << "El valor real es " << ValorEnteroReal.ValorReal << endl; cout << "Dirección de comienzo: " << &ValorEnteroReal.ValorReal << endl << endl; cin.get( ); retun 0; }//Fin de main( )

Programas con union


DEFINICION DEL PROBLEMA [UNION 02.CPP] Elaborar un programa que muestre el tamaño de los tipos de datos int, float y double. El tamaño de una estructura y el tamaño de una union. Definir variables del tipo de la estructura y de la unión, inicializar sus campos y ver que comparten la misma dirección. SALIDA

Longitud int = 4 bytes Longitud float = 4 bytes Longitud double = 8 bytes Longitud estructura = 16 Longitud Union = 8 DATOS Y DIRECCIONES DE REGISTROS Dato entero = 123 Direcci¾n Dato entero = 0x0012ff64 Dato flotante = 3.14 Direcci¾n Dato flotante = 0x0012ff68 Dato doble = 3.1416 Direcci¾n Dato doble = 0x0012ff6c DATOS Y DIRECCIONES MEDIANTE UNION Dato entero = 123 Direcci¾n Dato entero = 0x0012ff7c Dato flotante = 3.14 Direcci¾n Dato flotante = 0x0012ff7c Dato doble = 3.1416 Direcci¾n Dato doble = 0x0012ff7c Nota: Los valores que obtenga para int, float y double, dependerán de su computadora, es decir, pueden no

coincidir con estos valores. Definitivamente las direcciones, aunque comparten la misma área serán distintas a las aquí mostradas.

ANALISIS DEL PROBLEMA Al igual que el programa UNION 01.CPP, se utilizará el operador sizeof( ).

Programas con union



/* Nombre del programa: UNION 02.CPP */ using namespace std; #include <iostream> //Para cout y cin struct DatosEstructura { int DatoEntero1; float DatoFlotante1; double DatoDoble1; }; union DatosUnion { int DatoEntero2; float DatoFlotante2; double DatoDoble2; }; int main ( void ) { system( “cls” ); cout << "Longitud int = " << sizeof( int ) << " bytes\n"; cout << "Longitud float = " << sizeof( float ) << " bytes\n"; cout << "Longitud double = " << sizeof( double ) << " bytes\n\n"; cout << "Longitud estructura = " << sizeof( DatosEstructura ) <<"\n"; cout << "Longitud Union = " << sizeof( DatosUnion ) << "\n\n"; DatosEstructura Estructura; cout << "DATOS Y DIRECCIONES DE REGISTROS" << endl; Estructura.DatoEntero1 = 123; cout << "Dato entero = " << Estructura.DatoEntero1 << "\n" << "Dirección Dato entero = " << &Estructura.DatoEntero1 << "\n\n"; Estructura.DatoFlotante1 = 3.14; cout << "Dato flotante = " << Estructura.DatoFlotante1 << "\n" << "Dirección Dato flotante = " << &Estructura.DatoFlotante1 << "\n\n"; Estructura.DatoDoble1 = 3.1416; cout << "Dato doble = " << Estructura.DatoDoble1 << "\n" << "Dirección Dato doble = " << &Estructura.DatoDoble1 << "\n\n"; DatosUnion EstructuraUnion; cout << "DATOS Y DIRECCIONES MEDIANTE UNION" << endl; EstructuraUnion.DatoEntero2 = 123; cout << "Dato entero = " << EstructuraUnion.DatoEntero2 << "\n" << "Dirección Dato entero = " << &EstructuraUnion.DatoEntero2 << "\n\n"; EstructuraUnion.DatoFlotante2 = 3.14; cout << "Dato flotante = " << EstructuraUnion.DatoFlotante2 << "\n" << "Dirección Dato flotante = " << &EstructuraUnion.DatoFlotante2 << "\n\n"; EstructuraUnion.DatoDoble2 = 3.1416; cout << "Dato doble = " << EstructuraUnion.DatoDoble2 << "\n" << "Dirección Dato doble = " << &EstructuraUnion.DatoDoble2 << "\n\n"; cin.get( ); return 0; }//Fin de main( )

Programas con union


DEFINICION DEL PROBLEMA [UNION 03.CPP] El siguiente programa utiliza el operador sizeof( ) para visualizar la cantidad de Memoria usada por diferentes uniones. SALIDA

El tamaño de FechaEmpleados = 6 bytes El tamaño de Numeros = 8 bytes ANALISIS DEL PROBLEMA

La idea sigue siendo la misma, utilizar el operador sizeof( ), aunque en este ejemplo se aplica a la variable del tipo de la estructura, en vez de a la misma estructura.


/* Nombre del programa: UNION 03.CPP */ using namespace std; #include <iostream> //Para cout y cin union FechaEmpleados { int DiasTrabajados; struct Fecha { int Dia; int Mes; int Annio; }FechaEmpleado; //Fin de la estructura fecha{ } }; //Fin de la unión FechaEmpleados{ } union Numeros { int A; float B; long C; double D; // Mayor número de bytes requeridos = 8 }; //Fin de la union Numeros{ } void main( void ) { system( “cls” ); FechaEmpleados InfoEmpleado; Numeros Valores; cout << "El tamaño de FechaEmpleados = " << sizeof( InfoEmpleado ) << " bytes" << endl; cout << "El tamaño de Numeros = " << sizeof( Valores ) << " bytes" << endl; cin.get( ); }//Fin de main( )

Programas con union


Dentro de la biblioteca dos.h existen las siguientes estructuras y la union de las mismas:

struct WORDREGS { unsigned int ax, bx, cx, dx, si, di, cflag, flags; } ; struct BYTEREGS { unsigned char al, ah, bl, bh, cl, ch, dl, dh ; }; union REGS { struct WORDREGS x; struct BYTEREGS h; };

Como c almacena las variables de la union REGS

Cuando su programa accesa los registros de propósito general de su PC (AX, BX, CX y DX), la PC le permite referirse a un registro en un formato de 16 bits (word) o puede referirse a los bytes altos y bajos (AL, AH, BL, BH, CL, CH, DL y DH). Ya que se refiere al mismo registro, tiene dos posibilidades de ver la misma localización de memoria. Utilizando union, su programa tiene dos modos de acceder los registros de propósito general. La figura anterior muestra esta idea. Los programas siguientes, le permite ver la versión del DOS de su sistema operativo utilizando una palabra o un byte.

bx

ax

cx

dx 16 bytes

al ah

bl bh

cl ch

si

dl dh

di

cflag

flags

Programas con union


DEFINICION DEL PROBLEMA [UNION 04.CPP] El siguiente programa le permite ver la versión dos de su sistema operativo. Utilizando los dos bytes de un registro. SALIDA ANALISIS DEL PROBLEMA

La idea es utilizar la estructura REGS ya definida en el compilador y los dos bytes de el registro. CODIFICACION DEL PROBLEMA

/* Nombre del programa: UNION 04.CPP */ #include <iostream.h> //Para cout y cin #include <dos.h> //Para REGS e intdos( ) #include <conio.h> //Para clrscr( ) y getch( ) void main( void) { clrscr( ); union REGS RegEn, RegSal; RegEn.x.ax = 0x3000; intdos(&RegEn, &RegSal); cout << "Version actual de DOS: " << (RegSal.x.ax & 0xFF) << "." << (RegSal.x.ax >> 8); getch( ); }//Fin de main( )

Salida: Versión actual de DOS: 5.0

Programas con union


DEFINICION DEL PROBLEMA [UNION 05.CPP] El siguiente programa le permite ver la versión dos de su sistema operativo. Utilizando el byte mas alto de un registro. SALIDA ANALISIS DEL PROBLEMA

La idea es utilizar la estructura REGS ya definida en el compilador y el byte mas alto del registro. CODIFICACION DEL PROBLEMA

/* Nombre del programa: UNION 05.CPP * #include <iostream.h> //Para cout y cin #include <dos.h> //Para REGS e intdos( ) #include <conio.h> //Para clrscr( ) y getch( ) void main( void ) { clrscr( ); union REGS RegEn, RegSal; RegEn.h.ah = 0x30; RegEn.h.al = 0; intdos(&RegEn, &RegSal); cout << "Version actual de DOS: " << ( int )RegSal.h.al << "." << ( int )RegSal.h.ah << endl; getch( ); }//Fin de main( )

Salida: Versión actual de DOS: 5.0

Programas con union


Acerca de la función intdos( ) Syntax #include <dos.h> int intdos(union REGS *inregs, union REGS *outregs); Description General DOS interrupt interface. intdos executes DOS interrupt 0x21 to invoke a specified DOS function. The value of inregs -> h.ah specifies the DOS function to be invoked. After the interrupt 0x21 returns, intdos copies the current register values to outregs, copies the status of the carry flag to the x.cflag field in outregs, and copies the value of the 8086 flags register to the x.flags field in outregs. If the carry flag is set, it indicates that an error has occurred. Note: inregs can point to the same structure that outregs points to. Return Value intdos returns the value of AX after completion of the DOS function call. If the carry flag is set (outregs -> x.cflag != 0), indicating an error, it sets the global variable _doserrno to the error code. Note that when the carry flag is not set (outregs -> x.cflag = 0), you may or may not have an error. To be certain, always check _doserrno.

Ejemplo

#include <stdio.h> #include <dos.h> /* deletes file name; returns 0 on success, nonzero on failure */ int delete_file(char near *filename)

{ union REGS regs; int ret; regs.h.ah = 0x41;

/* delete file */ regs.x.dx = (unsigned) filename; ret = intdos(&regs, &regs); /* if carry flag is set, there was an error */ return(regs.x.cflag ? ret : 0);

} int main(void)

{ int err; err = delete_file("NOTEXIST.$$$"); if (!err) printf("Able to delete NOTEXIST.$$$\n"); else printf("Not Able to delete NOTEXIST.$$$\n"); return 0; }

Documents

SOLUCION DE PROBLEMAS QUE UTILIZAN enumazul2.bnct.ipn.mx/academia/problemarios/guia_ets_enum_typedef_struct... · Programas con enum Página 4 Ing.Isis Espinosa Salazar DEFINICION