Make your own free website on Tripod.com

Tipos numéricos: Operadores,

expresiones y ecuaciones

 

 

Al igual que en Pascal, Basic y otros lenguajes, contamos con una serie de operadores para realizar sumas, restas, multiplicaciones y otras operaciones no tan habituales. Vamos a empezar por las cuatro elementales:

Operador  Operación

--------        ---------------

+              Suma

-               Resta

*               Multiplicación

/               División

%             Residual

¿Qué ocurre en casos como el de 10/3? Si 10 y 3 son números enteros, ¿qué ocurre con su división? El resultado sería 3, la parte entera de la división. Será 3.3333 cuando ambos números sean reales. Si queremos saber el resto de la división, deberemos usar el operador %, el resultado sería 3.333333, un número real. Si queremos la parte entera de la división, deberemos utilizar “div”. Finalmente, “mod” nos indica cual es el resto de la división. El signo - se puede usar también para indicar negación. Allá van unos ejemplos:

 

#include <iostream>

 

using namespace std;

 

main()

 

int e1   = 10;

int e2   =  4;

float r1 = 10.0;

float r2 =  4.0;

 

{

cout<< “  La suma de los enteros es: “ <<e1+e2 << endl;

cout<< “  Su producto: “ << e1*e2 << endl;

cout<< “  Su resta: “ << e1-e2 << endl;

cout<< “  Su división: “ << e1/e2 << endl;

cout<< “  El resto de la división: “ <<e1%e2 << endl;

cout<< “  La suma de los reales es: ” <<r1+r2 << endl;

cout<< “  Su producto  ” << r1*r2 << endl;

cout<< “  Su resta: ” <<r1-r2 << endl;

cout<< “  Su división: ” <<r1/r2 << endl;

cout<< “  Un real entre un entero, como real: “ << r1/e2 << endl;

cout<< “  Un entero entre un real, como real: ” <<e1/r2<< endl;

}

 

Cuidado quien venga de Pascal, porque en C el operador + (suma) NO se puede utilizar también para concatenar cadenas de texto. Tendremos que utilizar funciones específicas (en este caso “strcat”). Tampoco podemos asignar valores directamente, haciendo cosas como “texto2 = texto1”, sino que deberemos usar otra función (“strcpy”). Todo esto lo veremos más adelante, en un tema dedicado sólo a las cadenas de texto.

En Turbo Pascal (no en cualquier versión de Pascal), tenemos también formas abreviadas de incrementar una variable: inc(a); en vez de a := a+1; Algo parecido existe en C, aunque con otra notación: a++; es lo mismo que a = a+1; a--; es lo mismo que a = a-1;

Pero estoy tiene más misterio todavía del que puede parecer en un primer vistazo: podemos distinguir entre “preincremento” y “postincremento”. En C es posible hacer asignaciones como b = a++; Así, si “a” valía 2, lo que esta instrucción hace es dar a “b” el valor de “a” y aumentar el valor de “a”. Por tanto, al final tenemos que b=2 y a=3 (postincremento: se incrementa “a” tras asignar su valor). En cambio, si escribimos b = ++a; y “a” valía 2, primeru aumentamos “a” y luego los asignamos a “b” (preincremento), de modo que a=3 y b=3.

Por supuesto, también tenemos postdecremento (a--) y predecremento (--a).

Y ya que estamos embalados con las asignaciones, hay que comentar que en C es posible hacer asignaciones múltiples: a = b = c = 1; Pero aún hay más. Tenemos incluso formas reducidas de escribir cosas como “a = a+5”. Allá van:

   a += b;                   es lo mismo que    a = a+b;

   a -= b ;                  es lo mismo que    a = a-b;

   a *= b ;                  es lo mismo que    a = a*b;

   a /= b ;                   es lo mismo que    a = a/b;

  a %= b ;                 es lo mismo que    a = a%b;    

 

Tipo coerción y Tipo Casting

 

Los valores enteros y reales se guardan en lugares distintos en la computadora. ¿Qué sucede si mezclamos valores enteros con reales en una expresión aritmética o en la instrucción asignada?

 

Si hacemos la siguiente declaración para la instrucción asignada o ecuación

 

int numEntero;

float numReal;

 

entonces numEntero puede guardar sólo valores enteros, y numReal puede guardar sólo valores reales. La instrucción

 

numReal = 12;

es convertida y guardada como 12.0 y no como número entero en la variable numeral. Esta conversion del valor de un tipo de dato a otro tipo se conoce como type coertion.

La instrucción

NumEntero = 5.7

También produce tipo coerción guardando como valor asignado el 5.

Con el propósito de que nuestro programa esté claro y libre de errores, podemos usar de forma explícita el type casting (o type conversion). La operación cast consiste en escribir el nombre del tipo y luego, entre paréntesis, la expresión a ser convertida:

numReal = float (3 * numEntero + 2);

numEntero = int (5.2 / numReal – otroReal);

 

Ambas instrucciones

numEntero = numReall + 5.2;

numEntero = int (numReal + 5.2;

produce el mismo resultado. La diferencia estriba en la claridad.

Al igual que en la instrucción asignada o ecuación, también es posible mezclar tipos de datos en una expresión aritmética. Dada la declaración

int sum;

int count;

float average;

y suponiendo que sum y count contengan 40 y 60 respectivamente, la expression

average = sum / count;                 //  Es errónea

da como resultado 0. Sin embargo, esta otra expression

average = float (sum) / float (count);         //  Es correcta

da como resultado 0.66

 

 

//*********************************************************

//Este programa imprime una suma de varias formas

//*********************************************************

#include <iostream>

 

using namespace std;

 

int main ()

{

// Declaración de variables

            int entero;

            float real;

            float total;

 

// Contenido de las variables

            entero = 12;

            real = 5.50;

            total = entero + real;

 

//Impresión del programa

            cout <<"Este es el TOTAL: "<<total <<endl <<endl<<endl;

 

// Otra forma de impresión sin manipuladores

            cout <<"Otra forma de hacerlo:"<<endl<<endl;

            cout <<entero <<endl;

            cout <<’  ‘<<real <<endl;

            cout <<"---" <<endl;

            cout <<total<<endl<<endl;

 

            return 0;

}

 

// *********************************************************************

// Programa de división

//**********************************************************************

 

#include <iostream>

using namespace std;

int main()

 

{

            int a = 18;

            int b = 5;

                       

            cout <<"Resto de la division es " <<a % b <<endl;   // El símbolo % es un

// operador de división

            return 0;

}

 

 

// *********************************************************************

// Programa de suma

//**********************************************************************

#include <iostream>

using namespace std;

int main()

{

            int a = 2;

            int b = 3;

            int c;

 

            c = a + b;

                       

            cout <<"El resultado es " << c <<endl;

            return 0;

}

 

// ******************************************************************

// Programa SumProd

// Este programa computa la suma y el producto de dos números enteros

//*******************************************************************

#include <iostream>

 

using namespace std;

 

const int ENT1 = 20;

const int ENT2 = 5;

 

int main()

 

{

            cout      << “La suma de “ << ENT1 << “  y  “ << ENT2

                        << “ es “ << ENT1 + ENT2 << endl;

            cout      << “El producto es  “ <<ENT1 * ENT2 <<endl;

 

            return 0;

}

 

// *********************************************************************

// Otro  programa de suma

//**********************************************************************

 

#include <iostream>

using namespace std;

int main()

 

{

            int numeroEntero;

            float numeroReal;

            float total;

 

            numeroEntero = 75;

numeroReal = 13.84;

total = numeroEntero + numeroReal;

 

            cout << "Este es un numero entero: " << numeroEntero <<endl;

            cout << "Este es un numero real:   " <<numeroReal <<endl;

            cout <<"                          -----" <<endl;

            cout << "El total es               " <<total <<endl;

 

}

 

Solución de un problema. Estudio de un caso

 

Problema. Tienes que hacer el siguiente proyecto de la clase de arte: Pintar un cuadro al óleo. Dado el tamaño de la pintura, debes determinar la cantidad de madera para el marco, lo largo de la tela o lona y el costo de materiales que hay que comprar.

 

Input. Cuatro números reales: el largo y ancho de la pintura, el costo por pulgada de la madera y el costo por pie cuadrado de la tela o lona.

 

Output. Mensajes de aviso, los datos entrados, el largo de la madera, las dimensiones de la tela, el costo de la madera y el costo total de los materiales.

 

Discusión. El largo de la madera es dos veces la suma del largo y ancho de la pintura. El costo de la madera se establecerá en pulgadas. El área de la tela se establecerá en pulgadas. Mientras que el costo de la tela será a base de pies cuadrados. Para convertir las pulgadas cuadradas en pies cuadrados se divide el número de pulgadas cuadradas en un pie cuadrado se dividen las pulgadas cuadradas de la tela por 144 (que son las pulgadas cuadradas por pie). De acuerdo a maestro, a la dimensión de la pintura hay que añadir 5 pulgadas a la tela para clavarla a la parte posterior del marco.

 

Asunciones. El input de los valores son positivos.

 

Variables

Nombre

Tipo Dato

Descripción

largo      

ancho

costoMadera

costoTela                             

largoMadera

anchoTela

largoTela

areaTelaPulg

areaTelaPies

totalCostoTela

totalCostoMadera

costoTotal

float

float

float

float

float

float

float

float

float

float

float

float

Largo de la pintura en pulgadas

Ancho de la pintura en en pulgadas

Costo madera por pulgada en dólares

Costo leta o lona por pie cuadrado

Largo de la madera

Ancho de la tela

Largo de la tela

Area de la tela en pulgadas cuadradas

Area de la tela en pies cuadrados

Total del costo de la tela

Total del costo de la madera

Total del costo de todos los materiales

 

 

Constantes

Nombre

Tipo Dato

Valor

Descripción

PULG_CUAD_POR_ PIE_CUAD

float

 

144.0

Número de pulgadas cuadradas en un pie cuadrado

 

 

Estructura modular del chart

 

 

 

 

 

 

 

 


Algoritmos y Flujogramas

 

Finalizada la estructura modular, se crean los algoritmos y flujogramas. El algoritmo responde a la pregunta de ¿cómo puede este módulo completar su función? Al dibujar el flujograma  se responde a la pregunta de ¿cómo presentar gráficamente el algoritmo? Con los algoritmos y flujogramas se buscan y corrigen los errores lógicos.

 

Algoritmo y Flujograma del Módulo Cuadro de Pintar

Algoritmo

Flujograma

Anotación

Test

 

Módulo de control o principal

 

 

 

1.            PROCESAR READ

 

 

 

2.            PROCESAR CALC

 

 

 

3.            PROCESAR PRINT

 

 

4.            FIN

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


Incluir los archivos de cabecera

Declarar las constantes y las variables

 

 

Entrar el largo y el ancho del cuadro. Entrar costos madera y tela

 

Calcular dimensiones y costos

 

 

Imprimir dimensiones y costos

 

1.         Star

 

 

 

 

2.         Ir a Read

 

 

 

3.         Ir a Calc

 

 

4.         Ir a Print

Documentación Interna

Documentación Externa

1.                                          Anotar al principio: Computar tamaño del cuadro y costos de la tela y madera

2.                                          Incluir anotaciones.

Lo mismo que en el número 1 de la Documentación Interna.

 

 

Algoritmo y Flujograma del Módulo READ

Algoritmo

Flujograma

Anotación

Test

Read Module

 

 

1.                                          ENTRAR largo y ancho cuadro, y costo mader y tela

 

 

2.                                          EXIT

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


Estipular y entrar el largo y el ancho del cuadro de pintura, los costos de la madera y de la tela

 

 

 

 

 

Documentación Interna

Documentación Externa

Lo mismo que aparece en Anotaciones

Explicar los datos de entrada

 

 

Algoritmo y Flujograma del Módulo CALC

Algoritmo

Flujograma

Anotación

Test

Calc Module

(2000)

 

1.        Ecuaciones:

largoMadera = (largo * ancho) * 2;

anchoTela = ancho + 5;

largoTela = largo + 5;

areaTelaPulg = anchoTela * largoTela;

areaTelaPies=areaTelaPulg/PULGCUADPORPIECUAD;

totalCostoMadera = largoMadera * costoMadera;

totalCostoTela = areaTelaPies * costoTela;

costoTotal = totalCostoMadera + totalCostoTela

 

2.        EXIT

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 


Probar las fórmulas en Excel

Documentación Interna

Documentación Externa

Anotar al principio: Computar dimensuiones y costos

Especificar la ecuación

 

 

Algoritmo y Flujograma del Módulo PRINT

Algoritmo

Flujograma

Anotación

Test

Print Module

(3000)

 

 

3.        IMPRIMIR Dimensiones del cuadro y costos

 

4.        EXIT

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Imprimir cada variable en una línea separada en una etiqueta (Se especifica el qué y donde se imprime la información, no el cómo)

 

 

Imprimir lo requerido

Documentación Interna

Documentación Externa

Anotar al principio: Este módulo requiere output

Especificar el output

 

 

Entrada de datos y cómputo del caso en Excel

 

 

 

 

 

Escribir el programa en C++

 

//**********************************************************************************

// Programa del cuadro de pintura.

// Este programa computa las dimensiones y el costo de materiales para hacer un

// cuadro de pintura. El usuario entra el largo y el ancho del cuadro y el costo

// de la madera (en pulgadas) y de la tela (por pie cuadrado).

//***********************************************************************************

#include <iostream>

#include <iomanip>                  //Para setprecision

 

using namespace std;

 

const float PULG_CUAD_POR_PIE_CUAD=144.0;  // Pulgadas cuadradas por pie cuadrado (12*12)

 

int main ()

{

 

// Declarar variables

            float largo;                                // Largo de la pintura en pulgadas

            float ancho;                               // Ancho de la pintura en en pulgadas

            float costoMadera;                   // Costo madera por pulgada en dólares

            float costoTela;                         // Costo tela o lona por pe cuadrado

            float largoMadera;                    // Cantidad de madera a comprar

            float anchoTela;                        // Ancho de la tela

            float largoTela;                          // Largo Tela

            float areaTelaPulg;                    // Area de la tela en pulgadas cuadradas

            float areaTelaPies;                    // Area de la tela en pulgadas cuadradas

            float totalCostoTela;                 // Total del costo de la tela

            float totalCostoMadera;            // Total del costo de la madera

            float costoTotal;                        // Total del costo de todos los materiales

 

            cout << fixed <<showpoint;      // Calibrar el número real

                                                            // Formato del Output

 

// Estipular y entrar el largo y el ancho del cuadro de pintura

 

            cout << "Entra el largo y el ancho de la pintura (Deja un espacio en blanco " <<endl;

            cout << "entre ambas entradas. Presiona ENTER al terminar las entradas): " << endl;

            cin  >> largo >> ancho;

 

// Estipular y entrar el costo de la madera

 

            cout << "Entra el costo de la madera para el marco por pulgada en dólares:"

                        <<endl;

           

            cin >> costoMadera;

 

// Estipular y entrar el costo de la tela

 

            cout << "Entra el costo por pie cuadrado de la tela en dólares:"

                        <<endl;

            cin >> costoTela;

 

// Computar dimensiones y costos

 

            largoMadera = (largo * ancho) * 2;

            anchoTela = ancho + 5;            // Se añaden 5" a la tela

            largoTela = largo + 5;

            areaTelaPulg = anchoTela * largoTela;

            areaTelaPies = areaTelaPulg / PULG_CUAD_POR_PIE_CUAD;

            totalCostoMadera = largoMadera * costoMadera;

            totalCostoTela = areaTelaPies * costoTela;

            costoTotal = totalCostoMadera + totalCostoTela;

 

// Imprimir dimensiones y costos

 

            cout << endl << setprecision (1);

            cout << "Para hacer el proyecto de un cuadro de " << largo

                        << " pulgadas de largo y " <<endl;

            cout << ancho << " pulgas de ancho."<<endl;

            cout << "tu necesitas comprar "<< largoMadera << " pulgadas de madera"

                        <<" y"<< endl;

            cout << "la tela debe ser de  "<< largoTela << " pulgadas de largo"

                        << " y "<< anchoTela << " pulgadas de ancho."<<endl;

 

            cout      << endl << setprecision (2);

            cout      << "Dado el costo de la Madera de $"<< costoMadera << " por pulgada,"

                                    << endl;

            cout      << "y el costo de la tela de $" << costoTela

                        << " por pie cuadrado, "<< endl;

            cout      << "la madera cuesta $"<< totalCostoMadera << ',' << endl;

            cout      << "la tela costará $" << totalCostoTela << '.' << endl;

            cout      << "y el COSTO TOTAL de los materiales viene siendo $"<<costoTotal

                        << '.'  <<endl;

            return 0;

}

 

Operadores lógicos

Más adelante veremos cómo hacer comparaciones del estilo de “si A es mayor que B y B es mayor que C”. Así que vamos a anticipar cuales son los operadores de comparación en C.

Operador     Operación

---------       ---------------

  ==            Igual a

  !=             No igual a (distinto de)

  <              Menor que

  >              Mayor que

  <=            Menor o igual que

  >=             Mayor o igual que

Cuidado con el operador de igualdad: el formato será if (a= =b) ... Si no nos damos cuenta y escribimos if (a=b) estamos asignando a “a” el valor de “b” (lo veremos con más detalle en la próxima lección).

Afortunadamente, la mayoría de los compiladores nos avisan con un mensaje parecido a “Possibly incorrect assignment” (que podríamos traducir por “posiblemente esta asignación es incorrecta”) o “Possibly unintended assignment” (algo así como “es posible que no se pretendiese hacer esta asignación”). Estas condiciones se puede encadenar con “y”, “o”, etc, que se indican de la siguiente forma (también lo aplicaremos en la próxima lección)

Operador  Significado

 ---------      ------------

 

   &&         Y

   ||              O

   !              No

 

Precedencia u orden de operadores

 

         ¡           Unario +     unario -                  Precedencia más alta

            *          /                   %

            +          -

            <          <=               >      >=

            = =      ¡=

            &&

            | |

            =                                                              Precedencia más baja

 

 

Operadores en la misma línea de la lista tienen la misma precedencia u orden de prioridad. Si una expresión contiene varios operadores con la misma precedencia,  se asocian o agrupan  los operadores de izquierda hacia la derecha. Por ejemplo, la expresión

 

a / b * c

 

significa (a / b) * c, y no a / (b * c). Sin embargo, los operadores unarios (¡, unario +, unario -) se agrupan de izquierda hacia la derecha.

 

Ejercicios

 

  1. Si a y b son dos variables int cuyo contenido es 5 para a, y 2 para b, ¿qué output producen las siguientes instrucciones?

 

a.      cout << “a  = << a  << “b ==  “ << b << endl;

b.      cout << “Suma:  “ << a  + b  << endl;

c.      cout << “Suma:   “ << a + b << endl;

d.      cout << a / b  << “b ==  “ pies” << endl;

e.      cout << “Remanente:   “ << b % a - 2  << endl;

 

  1. ¿Qué imprime el siguiente programa?

 

#include <iostream>

 

using namespace std;

 

const int LBS = 10;

 

int main ( )

{

 

            int precio;

            int costo;

            char car;

 

            precio = 30;

            costo = precio * LIBS

            car = ‘A’;

            cout << “El costo es  “ << endl;

            cout << costo << endl;

            cout << El precio es  “ <<precio  << “El costo es  “ << costo << endl;

            cout << “Grado “ << car <<”  costos  “ << endl;

            cout << costo << endl;

 

            return 0;

}

 

  1. Reedita el siguiente programa para hacerlo más claro y legible.

 

//************************************************************

// Programa SumProducto

// Este programa computa la suma y el producto de dos enteros

//************************************************************

#include <iostream>

using namespace std;

const int INT1 = 20; const int INT2 = 8; int main ( )  { cout <<

“La suma de   “ << INT1 << “  y 

<< INT2 << “  es  “ << INT1 + INT2 << endl; cout

<< “El producto es  “ << INT1 * INT2 << endl; return 0;  }

 

  1. Reedita el siguiente programa de tal forma que: (a) sea el usuario quien entre los números enteros y reales; (b) la suma, la línea separadora y el toral queden alineados mediante el manipulador setw(n).

 

#include <iostream>

using namespace std;

int main()

 

{

            int numeroEntero;

            float numeroReal;

            float total;

 

            numeroEntero = 75;      // cambiar por el cin

numeroReal = 13.84;    // cambiar por el cin

total = numeroEntero + numeroReal;

 

// Alinear los números con el setw(n)

            cout << "Este es un numero entero: " << numeroEntero <<endl;

            cout << "Este es un numero real:   " <<numeroReal <<endl;

            cout <<" -----" <<endl;

            cout << "El total es " <<total <<endl;

 

}

 

  1. Crea para el programa anterior: un módulo estructural, un algoritmo y un flujograma.