contenido de la lecciÓn 7 - azul2.bnct.ipn.mxazul2.bnct.ipn.mx/c/fundamentos/archivos...

MIGUEL Á. TOLEDO MARTÍNEZ

FUNDAMENTOS – LECCIÓN 6 6-1

CONTENIDO DE LA LECCIÓN 7

OPERACIONES BÁSICAS

1. Introducción 3 2. Operadores matemáticos básicos 4

2.1. Ejemplos 6.1, 6.2, 6.3, 6.4, 6.5, 6.6 5 2.2. Incrementando el valor de una variable en uno 5

2.2.1. Ejemplos 6.7, 6.8 9 2.3. Operador de incremento usado como prefijo y como posfijo 10

2.3.1. Ejemplos 6.9, 6.10 11 2.4. Operador de decremento 12

2.4.1. Ejemplo 6.11 12 2.5. Examen breve 13 85 2.6. Operaciones de asignación 13

2.6.1. Ejemplo 6.12 13 2.7. Examen breve 14 85

3. Solución de problemas en acción: Control de inventarios 15 3.1. Problema 15 3.2. Definición del problema 15 3.3. Planeación de la solución 15 3.4. Codificación del programa 18

4. Operaciones booleanas 20 4.1. Operadores relacionales 21

4.1.1. Ejemplos 6.13, 6.14, 6.15 21 4.2. Operadores lógicos 24 4.3. Operadores lógicos al nivel de bits 25

4.3.1. Ejemplos 6.16, 6.17, 6.18, 6.19, 6.20, 6.21 261

5. Rotación de bits 33 5.1. Ejemplo 6.22 33

6. El operador sizeof() 34 6.1. Ejemplos 6.23, 6.24 34

7. Asignación de tipo (typecasting) 36 7.1. Ejemplo 6.25 36

8. Solución de problemas en acción: Lógica booleana 37 8.1. Problema 37 8.2. Definición del problema 37 8.3. Planeación de la solución 38 8.4. Codi ficación del programa 39

9. Biblioteca de manejo de caracteres 40 9.1. Ejemplos 6.26, 6.27, 6.28 41 9.2. Funciones de conversión de cadenas 44

9.2.1. Ejemplos 6.29, 6.30, 6.31, 6.32, 6.33, 6.34, 6.35 44 9.3. Funciones de búsqueda de la biblioteca de manejo de cadenas 49

9.3.1. Ejemplos 6.36, 6.37, 6.38, 6.39, 6.40, 6.41 49 9.4. Funciones de memoria de la biblioteca de manejo de cadenas 52

9.4.1. Ejemplos 6.42, 6.43, 6.44, 6.45, 6.46 53



9.5. Otras funciones de la biblioteca de manejo de cadenas 55

9.5.1. Ejemplos 6.47, 6.48 55

10. Funciones matemáticas 58 10.1.1. Ejemplo 6.49 58

11. Examen breve 16 65

12. Solución de problemas en acción: Comunicación de datos 65 12.1. Problema 652 12.2. Definición del problema 66 12.3. Planeación de la solución 66 12.4. Codificación del programa 67

13. Solución de problemas en acción: Coordenadas polares y rectangulares 68 13.1. Problema 68 13.2. Definición del problema 69 13.3. Planeación de la solución 70 13.4. Codificación del programa 71

14. Jerarquía de los operadores 71 15. Lo que necesita saber 74 16. Preguntas y problemas 77

16.1. Preguntas 77 16.2. Problemas 80

LECCIÓN 7 OPERACIONES BÁSICAS

INTRODUCCIÓN En estos momentos está preparado para escribir programas lineales. Por programa lineal se debe entender que no alteran su flujo, simplemente ejecuta una serie de enunciados secuenciales, desde el principio hasta el final. Para que sus programas realicen tareas importantes, deberá familiarizarse con algunas operaciones estándar preconstruidas disponibles en C++. Las más simples de éstas son las operaciones aritméticas estándar. Por definición, una operación aritmética genera un resultado numérico. Tales operaciones son el tema de la primera sección de esta lección. La segunda sección tiene que ver con los operadores de asignación C++. Estos tienen la función de dar un valor a una variable. Hay operadores de asignación compuestos en C++ que permiten combinar una operación aritmética con la operación de asignación. Además de las operaciones aritméticas existen operaciones lógicas disponibles en C++ que generan un resultado verdadero (true) o falso (false) Estas operaciones se cubren en la tercera sección. Para simplificar la tarea de programación, C++ emplea algunas funciones estándar. Estas le permiten implementar con facilidad muchas operaciones comunes, como raíz cuadrada, seno y coseno, etc., sin rutinas de escritura especial. Las funciones estándar se presentan en la sección cuatro.

Objetivos de la lección:

•• Saber lo que son los operadores y las expresiones aritméticas. •• Realizar las operaciones básicas en C++. •• Utilizar los operadores de asignación aritmética . •• Comprender la jerarquía de los operadores C++. •• Utilizar los operadores de incremento y decremento de C++. •• Utilizar los operadores para el manejo de bits. •• Ser capaz de utilizar las funciones de la biblioteca de manejo de caracteres (ctype.h) •• Ser capaz de utilizar las funciones de procesamiento de cadenas de la biblioteca de

manejo de cadenas (string.h) •• Ser capaz de utilizar las funciones matemáticas de la biblioteca <math.h>. •• Apreciar el poder de las bibliotecas de función como un medio para lograr la

reutilización del software. •• Utilizar el operador sizeof. •• Utilizar el manejo de tipos (typecasting)



OPERADORES MATEMÁTICOS BÁSICOS Las operaciones aritméticas en C++ incluyen las operaciones comunes de suma, resta, multiplicación y división, también operaciones de incremento/decremento. Las operaciones básicas de adición, resta, multiplicación y división pueden realizarse sobre cualquier clase de dato numérico. Recuerde que las clases de datos numéricos estándar en C++ son los enteros y punto flotante. Además, en C++ es posible realizar operaciones aritméticas sobre datos de caracteres, ya que los caracteres se representan como enteros (ASCII) dentro de la computadora.

La tabla 6.1 lista las operaciones aritméticas básicas y los símbolos que usa C++ para representar estas operaciones. Los operadores de suma (+), resta (-) y multiplicación (*) son directos y no necesitan ninguna otra explicación. Sin embargo, observe que para la multiplicación se usa un asterisco (*) en lugar del símbolo (××) para que la computadora no confunda el símbolo de multiplicación con el carácter ‘x’. Dichas operaciones pueden ser entre constantes (tal como 3*5), o entre variables (pago – compra)

Tabla 6.1. Operadores aritméticos definidos en C++

Operador Propósito Ejemplo + Más unario x = +y + 3 ; - Menos unario x = -y; + Suma total = costo + impuesto; - Resta cambio = pago – compra; * Multiplicación impuesto = costo * TASA_IMPUESTO; / División promedio = total / contador ; % Módulo (Residuo) x = 5 % 3;

El operador de división necesita una atención especial. Este operador generará un resultado de la misma clase de datos de los operandos que se utilizan en la operación. De esta manera, si divide dos enteros, obtendrá un resultado entero. Si divide uno o más valores decimales de punto flotante, obtiene un resultado decimal. Por lo tanto, 10 / 3 = 3 y 10.0 / 3 = 3.333333. Aquí, la primera es una división de enteros y genera un resultado entero. La última es una división de punto flotante y genera un resultado de punto flotante. Por último, el operador módulo o de residuo, se define sólo para operandos enteros. Obtendrá un error de compilación si trata de aplicarlo a valores de punto flotante. El operador módulo (%) simplemente genera el residuo que resulta cuando divide dos enteros. Por ejemplo, el resultado de 5 % 3 es 2, 8 % 4 es 0. Veamos un par de ejemplos que ilustran estas operaciones. En el ejemplo 6.1 se muestran algunas operaciones aritméticas entre enteros y en el 6.2, operaciones aritméticas de valores de punto flotante.



Ejemplo 6.1.

¿Qué valor resultará de cada una de las siguientes operaciones?

a. 3 * (-5) b. 4 * 5 – 10 c. 10 / 3 d. 9 % 3 e. –21 / ( -2) f. –21 % (-2) g. 4 * 5 / 2 + 5 % 2

Solución

a. 3 * (-5) es igual a –15.

b. 4 * 5 – 10 es igual a 10. Observe que la operación de multiplicación se realiza antes de la operación de substracción.

c. 10 / 3 es igual a 3. Debido a que ésta es una división de enteros. d. 9 % 3 es igual 0, porque no hay residuo. e. –21 / (-2) es igual a 10. f. -21 % (-2 ) es igual a residuo –1. g. 4 * 5 / 2 + 5 % 2 = (4*5) / 2 + 5 % 2 = (20/2) + 5 % 2 = 10 + (5 % 2) = 10 + 1 = 11. Observe que

los operadores de multiplicación, división y módulo se realizan primero, de izquierda a derecha. La operación de adición se realiza al último.

El ejemplo anterior muestra la prioridad u ordenamiento de los operadores. Cuando se realiza más de una operación en una expresión, debe conocerse el orden en el que se realizará cada una para dete rminar el resultado. C++ realiza las operaciones en el siguiente orden:

•• Primero se realizan todos los operadores dentro de paréntesis. •• Si hay paréntesis anidados (paréntesis dentro de paréntesis) primero se

realizan los operadores más internos, desde dentro hacia fuera. •• Los operadores *, / y % se realizan después, de izquierda a derecha dentro de

la expresión. •• Por último se realizan los operadores + y -, de izquierda a derecha dentro de

la expresión.

Las operaciones aritméticas de valores de punto flotante son básicamente igual a aquéllas con enteros, con la excepción de la división. Recuerde que el operador / dará como resultado un valor de punto flotante si cualquiera de sus operandos es de punto flotante. La operación módulo (%) se define sólo para enteros y generará un error de compilación si intenta aplicarlo a valores de punto flotante.

La multiplicación y división tienen la misma prioridad dentro de una expresión aritmética cuando se realizan operaciones de punto flotante. De esta manera los operadores dentro de paréntesis se realizan primero, seguido por la multiplicación y división, y estos a su vez por la adición y sustracción. Ejemplo 6.2.

Evalúe cada una de las siguientes expresiones:

a. 4.6 – 2.0 + 3.2

b. 4.6 – 2.0 * 3.2 c. 4.6 –2.0 / 2 * 3.2 d. –3.0 * ((4.3 + 2.5) * 2.0) – 1.0 e. –21.0 / -2 f. –21.0 % -2 g. 10.0 / 3 h. ((4 * 12) / (4 + 12)) i. 4 * 12 / 4 + 12

Solución

a. 4.6 – 2.0 + 3.2 = (4.6 – 2.0) + 3.2 = 2.6 + 3.2 = 5.8 b. 4.6 – 2.0 * 3.2 = 4.6 – (2.0 * 3.2) = 4.6 – 6.4 = -1.8 c. 4.6 –2.0 / 2 * 3.2 = 4.6 – ((2.0 / 2) * 3.2) = 4.6 – (1.0 * 3.2) = 4.6 – 3.2 = 1.4 d. 3.0 * ((4.3 + 2.5) * 2.0) – 1.0 = 3.0 * (6.8 * 2.0) – 1.0 = 3.0 *13.6 –1.0 = -40.8 – 1.0 = -41.8 e. –21.0 / -2 = 10.5 f. –21.0 % -2 = “Error, uso ilegal de punto flotante” porque % se define sólo para valores enteros. g. 10.0 / 3 = 3.333333 h. ((4 * 12) / (4 + 12)) = 48 / 16 = 3 i. 4 * 12 / 4 + 12 = 48 / 4 + 12 = 12 + 12 = 24

En caso de dudas se sugiere utilizar paréntesis. Veamos ahora algunos programas sencillos en el que se muestre el uso de las operaciones aritméticas. Ejemplo 6.3

El siguiente programa: MSTRMAT.CPP, utiliza cout para visualizar el resultado de algunas operaciones aritméticas básicas:

/* El siguiente programa: MSTRMAT.CPP , ilustra el uso de cout para visualizar el resultado de algunas operaciones aritméticas básicas. */ #include <iostream.h> //Para cout void main(void) { int segundosHora; float promedio; //Ejemplos en los que se manejan valores fijos.

cout << "5 + 7 = " << 5 + 7 << endl; cout << "12 - 7 = " << 12 – 7 << endl; cout << "1.2345 * 2 = " << 1.2345 * 2 << endl; cout << "15 / 3 = " << 15 / 3 << endl << endl;

//Ejemplos en los que se manejan objetos variables. segundosHora = 60 * 60; promedio = (5 + 10 + 15 + 20) / 4; cout << "El número de segundos en una hora es : " << segundosHora << endl; cout << "El promedio de 5, 10, 15 y 20 es : " << promedio << endl; cout << "El número de segundos en 48 minutos es: " << segundosHora - 12 * 60 << endl;

} //Fin de main()

Ejemplo 6.4

El siguiente programa: OPER1.CPP, también ilustra el uso de las operaciones matemáticas básicas así como de objetos variables. En este programa utilizamos el objeto cin que en la lección 7 (Introducción de datos por teclado) veremos que se utiliza para introducir datos a la computadora.

/* El siguiente programa: OPER1.CPP , ilustra el uso de operaciones matemáticas sencillas mediante el uso de objetos variables. Utilizaremos también el objeto cin para introducir datos a la computadora. */ #include <iostream.h> //Para cout y cin void main(void) { int int1, int2; long long1, long2, long3, long4, long5; float x, y, real1, real2, real3, real4; cout << endl << "Digite el primer número entero: "; cin >> int1; cout << "Digite el segundo número entero: "; cin >> int2; cout << endl; //Operaciones aritméticas con números enteros. long1 = int1 + int2; long2 = int1 - int2; long3 = int1 * int2; long4 = int1 / int2; long5 = int1 % int2; cout << int1 << " + " << int2 << " = " << long1 << endl; cout << int1 << " - " << int2 << " = " << long2 << endl; cout << int1 << " * " << int2 << " = " << long3 << endl; cout << int1 << " / " << int2 << " = " << long4 << endl; cout << int1 << " % " << int2 << " = " << long5 << endl; cout << endl << endl; cout << "Digite el primer número real : "; cin >> x; cout << "Digite el segundo número real: "; cin >> y; cout << endl; //Operaciones aritméticas con números reales. real1 = x + y; real2 = x - y; real3 = x * y; real4 = x / y; cout << x << " + " << y << " = " << real1 << endl; cout << x << " - " << y << " = " << real2 << endl; cout << x << " * " << y << " = " << real3 << endl; cout << x << " / " << y << " = " << real4 << endl; cout << endl << endl; } //Fin de main()

Ejemplo 6.5

El siguiente programa: MATVARS.CPP, realiza operaciones aritméticas utilizando las variables precio (15.00), tasaImpuesto (6%), importePagado (20.00), impuesto, cambio y total.

Ejemplo 6.6

El siguiente programa: MODULO.CPP, ilustra el uso del operador % (módulo)

/* El siguiente programa: MODULO.CPP, ilustra el uso del operador % (módulo)*/ #include <iostream.h> //Para cout void main (void) { int residuo; int resultado; resultado = 10 / 3; residuo = 10 % 3; cout << "El cociente de 10/3 es: " << resultado << ", " << "el residuo es : " << residuo << endl; } //Fin de main()

/* El siguiente programa: MATVARS.CPP, ilustra el uso de operaciones aritméticas utilizando variables. */ #include <iostream.h> //Para cout void main(void) { float precio = 15.00; // Precio del artículo float tasaImpuesto = 0.06; // 6% de tasa de impuesto float importePagado = 20.00; // Importe del dinero con que se pagó float impuesto, cambio, total; // Impuesto, cambio y total impuesto = precio * tasaImpuesto; total = precio + impuesto; cambio = importePagado - total; cout.setf(ios::fixed); cout.precision(2); cout << "Precio del artículo : $" << precio << "\tImpuesto: $" << impuesto << "\t\tTotal: $" << total << endl; cout << "Cambio del cliente : $" << cambio << endl;

}

INCREMENTANDO EL VALOR DE UNA VARIABLE EN UNO En programación es muy común el incrementar el valor de una variable en 1. Por ejemplo, suponga que su programa utiliza una variable llamada contador para contar el número de archivos impresos. Cada vez que su programa imprima un archivo, deberá agregarse uno al contenido de la variable contador. Utilizando el operador de asignación de C++ su programa puede incrementar en uno el valor actual de la variable contador. Ejemplo:

contador = contador + 1; El incremento se puede aplicar a las variables de clase entero y de punto flotante, así como a variables de clase carácter. Ya que el incremento del valor de una variable es una operación común en C++, el mismo proporciona un operador de incremento: el doble signo más (++) Ejemplo:

contador = contador + 1; contador++; Ejemplo 6.7

El siguiente programa: INCREMENTO.CPP, usa el operador de asignación para incrementar la variable contador en uno. Inicializa la variable contador en 1000 y utiliza el operador de incremento para incrementar la variable contador en uno.

/* Nombre del programa: INCREMENTO.CPP, ilustra el uso del operador de asignación para incrementar la variable contador en uno. También muestra el uso del operador de incremento ++. */ #include <iostream.h> //Para cout void main(void) { int contador = 1000; // Muestra el uso del operador de asignación para incrementar la variable // contador en uno. cout << "Valor inicial del contador: " << contador << endl; contador = contador + 1; cout << "Valor final del contador : " << contador << endl << endl; //Muestra el uso del operador de incremento para incrementar la variable //contador en uno. contador = 1000; cout << "Valor inicial del contador: " << contador << endl; contador++; cout << "Valor final del contador : " << contador << endl;

} //Fin de main()

Ejemplo 6.8 El siguiente programa: 0A100.CPP, utiliza el operador incremento para visualizar los números del 0 al 100:

Nota: En este programa se utiliza la estructura de control while, el cual permite ejecutar un bloque de

instrucciones mientras la condición sea verdadera. Para mayor detalle ver la lección 9. OPERADOR DE INCREMENTO USADO COMO PREFIJO Y COMO POSFIJO Cuando su programa usa el operador de incremento, puede colocar el operador antes o después de la variable, como se muestra a continuación:

++variable; variable++;

Ya que el primer operador aparece antes de la variable, se le llama operador de incremento prefijo. De igual modo el segundo operador se llama operador de incremento posfijo. Necesita comprender como C++ trata estos dos operadores. Considere el siguiente enunciado de asignación:

contadorActual = contador++;

Esta asignación es equivalente a:

contadorActual = contador; contador = contador + 1;

Ahora consideremos el siguiente enunciado de asignación que usa el operador de incremento prefijo:

contadorActual = ++ contador;

En este caso, el enunciado de asignación le indica a C++ que primero incremente el valor de la variable contador y luego que se lo asigne a la variable contadorActual. Utilizar el operador de incremento prefijo es equivalente a:

/* El siguiente programa: 0A100.CPP, utiliza el operador incremento para imprimir los números del 0 al 100. Se utiliza la estructura de control while que repite un bloque de instrucciones mientras la condición sea verdadera. */ #include <iostream.h> //Para cout void main (void) { int valor = 0; while (valor <= 100) { cout << valor << endl; valor++; } //Fin de while() } //Fin de main()

contador = contador +1;

contadorActual = contador; Ejemplo 6.9

El siguiente programa: POSPREINC.CPP, ilustra el uso de los operadores de incremento posfijo y prefijo:

Ejemplo 6.10 El siguiente programa: OPER2.CPP, ilustra el uso del operador incremento utilizado como posfijo y prefijo en una operación aritmética:

/* El siguiente programa: POSPREINC.CP P, ilustra el uso de los operadores de incremento posfijo y prefijo. */ #include <iostream.h> //Para cout void main(void) { int contadorPequeno = 0; int contadorGrande = 1000; //Ejemplo de operador de incremento posfijo. cout << "El valor de contadorPequeno es : " << contadorPequeno << endl; cout << "El valor de contadorPequeno++ es : " << contadorPequeno++ << endl; cout << "contadorPequeno termina con : " << contadorPequeno << endl << endl; //Ejemplo de operador de incremento prefijo. cout << "El valor de contadorGrande es : " << contadorGrande << endl; cout << "El valor de ++contadorGrande es : " << ++contadorGrande << endl; cout << "contadorGrande termina con : " << contadorGrande << endl; } //Fin de main()

/* El siguiente programa: OPER2.CPP , ilustra la característica del operador de incremento, cuando se usa en una expresión. Cuando se utiliza como posfijo el valor de la variable asociada se altera después de que se evalúe la expresión. Si se usa como prefijo, el valor de la variable asociada se altera antes de que se evalúe la expresión.*/ #include <iostream.h> //Para cout void main(void) { int i, k = 5; // usa posincremento i = 10 * (k++); // k contribuye con 5 a la expresión cout << "i = " << i << endl << endl; // despliega 50 = (10 * 5) k--; //restaura el valor de x a 5 // usa preincremento i = 10 * (++k); // k contribuye con 6 a la expresión cout << "i = " << i << endl << endl; // despliega 60 = (10 * 6) } //Fin de main()

OPERADOR DE DECREMENTO De manera semejante, el doble signo menos (--) es el operador de decremento, el cual decrementa el valor de una variable en uno. Al igual que el operador de incremento, C++ soporta operador de decremento posfijo y prefijo. Ejemplo 6.11

El siguiente programa, DECCONTA.CPP, ilustra el uso del operador de decremento:

/* El siguiente programa: DECCONTA.CPP, ilustra el uso del operador de decremento posfijo y prefijo. */ #include <iostream.h> //Para cout void main(void) { int contadorPequeno = 0; int contadorGrande = 1000; //El operador de decremento utilizado como posfijo cout << "El valor de contadorPequeno es : " << contadorPequeno << endl; cout << "El valor de contadorPequeno-- es : " << contadorPequeno-- << endl; cout << "contadorPequeno termina con : " << contadorPequeno << endl << endl; //El operador de decremento utilizado como prefijo cout << "El valor de contadorGrande es : " << contadorGrande << endl; cout << "El valor de --contadorGrande es : " << --contadorGrande << endl; cout << "contadorGrande termina con : " << contadorGrande << endl;

} //Fin de main()

EXAMEN BREVE 13



OPERACIONES DE ASIGNACIÓN Una operación de asignación almacena un valor en la memoria. El valor se almacena en la localidad de memoria a la que se tiene acceso con la variable de lado izquierdo del operador de asignación. Como resultado, un operador de asignación C++ asigna el valor del lado derecho del operador a la variable que aparece del lado izquierdo del operador. En otras palabras, la variable del lado izquierdo del operador se establece al valor de lado derecho del operador. Los operadores de asignación C++ se muestran en la tabla 6.2.

Tabla 6.2. Operadores de asignación usados en C++

Operación Símbolo Asignación sencilla = Asignación de adición compuesta += Asignación de sustracción compuesta -= Asignación de multiplicación compuesta *= Asignación de división compuesta /= Asignación de módulo compuesto (sólo enteros) % =

En C++ la expresión x = x + 1 significa sumar 1 a x, y entonces asignar el valor resultante a x. Dicho de otro modo, establecer x al valor x + 1. Esta es una operación perfectamente legítima. Los operadores de asignación compuestos mostrados en la tabla 6.2 simplemente combinan el operador de asignación con un operador aritmético. Suponga que definimos x y y como enteros; entonces:

x += y equivale a x = x + y x -= y equivale a x = x – y x *= y equivale a x = x * y x /= y equivale a x = x / y x %= y equivale a x = x % y

Como puede observar, ambos operadores de incremento y decremento y los operadores de asignación compuestos proporcionan una notación breve para escribir expresiones aritméticas. Tome en cuenta esta notación, porque se usará en forma extensiva en los programas durante el resto de estas lecciones. Ejemplo 6.12

El siguiente programa: OPER3.CPP, ilustra el uso de los operadores matemáticos de asignación:

Nota: El uso del objeto cin se verá en la siguiente lección. Se utiliza para leer información.

EXAMEN BREVE 14

/* El siguiente programa: OPER3.CPP , ilustra los operadores matemáticos de asignación */ #include <iostream.h> //Para cout void main(void) { int i, j; double x, y; cout << "Introduzca el primer número entero : "; cin >> i; cout << "Introduzca el segundo número entero: "; cin >> j; i += j; j -= 6 ; i *= 4; j /= 3; i++; j--; cout << endl; cout << "i = " <> x; cout << "Introduzca el segundo número real: "; cin >> y; // En C++ las asignaciones abreviadas también funcionan con punto flotante x += y; y -= 4.0; x *= 4.0; y /= 3.0; x++; y--; cout << endl; cout << "x = " << x << endl; cout << "y = " << y << endl; } //Fin de main()



SOLUCIÓN DE PROBLEMAS EN ACCIÓN: Control de inventarios PROBLEMA

Lo siguiente es un inventario parcial de una lista de artículos en el departamento de deportes de la tienda ACME, S.A. de C.V.

Artículo Cantidad Unidades vendidas este mes Sedal 132 carretes 24 carretes Anzuelos 97 paquetes 45 paquetes Plomos 123 paquetes 37 paquetes Redes de pesca 12 piezas 5 piezas

Escriba un programa que imprima un informe mensual mostrando la fecha del reporte , el nombre del artículo, la cantidad inicial, unidades vendidas por mes, cantidad final y porcentaje de cantidad vendida.

La solución del problema empieza con la fase de definición del problema. DEFINICIÓN DEL PROBLEMA

Salida: El programa deberá generar un informe mensual impreso con la fecha, el

nombre del artículo, cantidad inicial, unidades vendidas este mes, cantidad final y porcentaje de la cantidad vendida. Ahora es un buen momento para desarrollar el formato de salida. Suponga que usaremos un formato tabular, como éste:

FECHA: dd/mm/aa ARTICULO CANTIDAD INICIAL UNIDADES VENDIDAS CANTIDAD FINAL % VENDIDO xxxxxxxxxxx xxxxxxxxxx xxxxxxxxxxxx xxxxxxxxx xxx

Entrada: El usuario deberá escribir la fecha del informe y los datos del inventario mostrados en la salida .

Procesamiento: Debido a que el artículo, cantidad inicial y unidades vendidas las escribe

el usuario, el programa usará esta información para calcular dos cosas: la cantidad final y el porcentaje vendido . La cantidad final se encuentra con una sencilla sustracción de las unidades vendidas a la cantidad inicial:

Cantidad final = Cantidad inicial – Unidades vendidas El porcentaje vendido se encuentra dividiendo las unidades vendidas por la

cantidad inicial y multiplicándola por 100: % Vendido = (Unidades vendidas / Cantidad inicial) ×× 100%

PLANEACIÓN DE LA SOLUCIÓN

Debemos construir una serie de algoritmos a partir de la definición del problema. Usando el diseño de programación estructurado, dividiremos el problema en subproblemas individuales para solucionar el problema general. Hay cuatro tareas principales que surgen directamente de la definición del problema:



•• Imprimir el encabezado del informe. •• Obtener del usuario los datos del inventario para un artículo determinado. •• Calcular la cantidad final y el porcentaje vendido para un artículo determinado. •• Imprimir el informe del artículo. •• Repetir las últimas tres tareas tres veces.

Debido a que vamos a imprimir el informe, artículo por artículo, las últimas tres tareas deberán repetirse para cada artículo en el inventario. El diagrama de la figura 6.1 muestra la estructura de bloque necesaria para el problema.

Figura 6.1. Diagrama estructurado para el problema de inventario .

El nivel de algoritmo inicial, inventario(), mostrará el análisis anterior y llamará a los módulos de subprogramas individuales.

ALGORITMO INICIAL inventario() INICIO

Llamar a la función imprimir el título del informe. Llamar a la función para obtener los datos del inventario para un artículo

determinado proporcionado por el usuario. Llamar a la función para calcular la cantidad final y el porcentaje de venta. Llamar a la función para imprimir el informe del artículo. Repetir las últimas tres tareas para cada artículo del inventario.

FIN. Durante el desarrollo del algoritmo, se dará cuenta de que el proceso es el mismo para cada uno de los artículos de ventas. Como resultado, un solo enunciado repetir se adiciona al final del algoritmo, en lugar de repetir realmente todos los enunciados del algoritmo tres veces más. Esto hace más eficiente el algoritmo. El primer nivel de refinamiento necesita que mostremos un algoritmo en detalle para cada tarea, o función, que hayamos identificado. Son como sigue:

inventario()

Imprimir un informe de inventario para el

departamento de artículos deportivos

imprimirArt()

Imprimir el informe del artículo

calcularArt() Calcular la cantidad final y

el porcentaje vendido para un artículo

determinado

obtenerDatos() Obtener los datos para un

artículo determinado

imprimirEncabezado()

Imprimir el título del informe



PRIMER NIVEL DE REFINAMIENTO

imprimirEncabezado() Inicio

Escribir(“Favor de introducir la fecha: “) Leer (Fecha) Imprimir la información del título.

Fin.

obtenerDatos() Inicio

Escribir(“Favor de introducir el nombre del artículo: ”) Leer (Nombre del Artículo) Escribir(“Favor de introducir la cantidad inicial del artículo: “) Leer (Cantidad Inicial). Escribir(“Favor de introducir la cantidad de unidades vendidas: “). Leer (Unidades Vendidas)

Fin.

calcularArt() Inicio

Calcular Cantidad Final = Cantidad Inicial – Unidades Vendidas. Calcular % Vendido = (Unidades Vendidas / Cantidad Inicial) × 100.

Fin.

imprimirArt() Inicio

Imprimir( Artículo, Cantidad Inicial, Unidades Vendidas, Cantidad Final, % Vendid )

Fin.

Ahora el trabajo es codificar este algoritmo en C++. Con su actual conocimiento de C++, la codif icación de la mayoría de los algoritmos no debe representar ningún problema. Pero, ¿qué hay del enunciado repetir al final de la función del algoritmo inventario()? Bien, observe que este enunciado necesita que regrese y repita muchos de los enunciados anteriores una y otra vez hasta que todos los artículos sean procesados. Tal operación de repetición se llama una operación de iteración o ciclo. Hasta ahora, no se tienen las herramientas de C++ para realizar tal operación. Así que tendremos que repetir todos los pasos del procesamiento para cada uno de los artículos de venta en el inventario. En la lección 9, aprenderá a realizar operaciones iterativas en C++, de esta forma se hace el código mucho más eficiente.

CODIFICACIÓN DEL PROGRAMA

/* El siguiente programa: INVENTARIO.CPP, realiza las siguientes tareas: Salida: Impresión del informe mensual, conteniendo la fecha, el nombre del artículo, cantidad inicial, unidades vendidas este mes, cantidad final y porcentaje de cantidad vendida. Entrada: El usuario escribe los datos del inventario. Procesamiento : El programa debe calcular dos cosas: Cantidad Final y Porcentaje Vendido. */ #include <iostream.h> // Para cin y cout #include <iomanip.h> // para setw() #include <fstream.h> // Para el objeto imprimir #include <process.h> // Para exit() // Enunciado de constantes. const int TAMANO_FECHA = 9; // Tamaño del arreglo fecha const int TAMANO_ARTICULO = 21; // Tamaño del arreglo nombreArtículo void main(void) { char fecha [TAMANO_FECHA] = "\0"; // Fecha del informe char nombreArticulo[TAMANO_ARTICULO] = "\0"; // Nombre del artículo float cantidadInicial = 0.0; float unidadesVendidas = 0.0; float cantidadFinal = 0.0; float porcentajeVendido = 0.0; /******************************************************************* * Este segmento de codificación define imprimir como un archivo de * * salida que apunta al puerto de su impresora PRN, solo para DOS. * *******************************************************************/ ofstream imprimir; // Define imprimir como un archivo de flujo de salida imprimir.open("PRN"); // Abre el archivo imprimir y apunta hacia PRN if(!imprimir) // Se asegura que la impresora este lista. { cout << "Hay un problema con la impresora " << endl; exit(1); } // Final del if. // Muestra el mensaje de la descripción del programa. cout << "Estimado usuario de ACME S.A. DE C.V.\n\n" "Se le pedirá escribir cuatro artículos de ventas, uno \n" "por uno. Con cada artículo solicitado escriba\n" "el nombre del artículo, la cantidad inicial y la cantidad\n" "vendida este mes. La computadora imprimirá un informe mensual del\n" "inventario para los artículos vendidos" << endl << endl; // Imprime los títulos del informe. cout << "Por favor escriba la fecha en el formato dd/mm/aa: "; cin >> fecha ; imprimir << "\n\nFECHA:" << fecha << endl; imprimir << "\n\n\n" << setw(15) << "ARTICULO" << setw(21) << "CANTIDAD INICIAL" << setw(22) << "UNIDADES VENDIDAS" << setw(19) << "CANTIDAD FINAL" << setw(12) << "%VENDIDO" << endl; imprimir << setw(15) << "--------" << setw(21) << "-----------------" << setw(22) << "-----------------" << setw(19) << "--------------" << setw(12) << "--------" << endl;

// El usuario escribe los datos del artículo cout << "Por favor escriba el nombre del artículo: " << endl; cin >> ws; cin.getline(nombreArticulo ,TAMANO_ARTICULO); cout << "Por favor escriba la cantidad inicial del " << no mbreArticulo << endl; cin >> cantidadInicial; cout << "Por favor escriba el número de unidades del " << nombreArticulo << "vendido el " << fecha << endl; cin >> unidadesVendidas; // Calcula la cantidad final y el porcentaje vendido para el artículo cantidadFinal = cantidadInicial - unidadesVendidas; porcentajeVendido = (unidadesVendidas / cantidadInicial) * 100; // Imprime el informe del artículo imprimir.setf(ios::fixed); imprimir.precision(2); imprimir << setw(15) << nombreArticulo << setw(21) << cantidadInicial << setw(22) << unidadesVendidas << setw(19) << cantidadFinal << setw(12) << porcentajeVendido << endl; // El usuario escribe los datos del artículo cout << "Por favor escriba el nombre del artículo: " << endl; cin >> ws; cin.getline(nombreArticulo ,TAMANO_ARTICULO); cout << "Por favor escriba la cantidad inicial del " << nombreArticulo << endl; cin >> cantidadInicial; cout << "Por favor escriba el número de unidades del " << nombreArticulo << "vendido el " << fecha << endl; cin >> unidadesVendidas; // Calcula la cantidad final y el porcentaje vendido para el artículo cantidadFinal = cantidadInicial - unidadesVendidas; porcentajeVendido = (unidadesVendidas / cantidadInicial) * 100; // Imprime el informe del artículo imprimir.setf(ios::fixed); imprimir.precision(2); imprimir << setw(15) << nombreArticulo << setw(21) << cantidadInicial << setw(22) << unidadesVendidas << setw(19) << cantid adFinal << setw(12) << porcentajeVendido << endl; // El usuario escribe los datos del artículo cout << "Por favor escriba el nombre del artículo: " << endl; cin >> ws; cin.getline(nombreArticulo ,TAMANO_ARTICULO); cout << "Por favor escriba la cantidad inicial del " << nombreArticulo << endl; cin >> cantidadInicial; cout << "Por favor escriba el número de unidades del " << nombreArticulo << "vendido el " << fecha << endl; cin >> unidadesVendidas; // Calcula la cantidad final y el porcentaje vendido para el artículo cantidadFinal = cantidadInicial - unidadesVendidas; porcentajeVendido = (unidadesVendidas / cantidadInicial) * 100; // Imprime el informe del artículo imprimir.setf(ios::fixed); imprimir.precision(2); imprimir << setw(15) << nombreArticulo << setw(21) << cantidadInicial << setw(22) << unidadesVendidas << setw(19) << cantidadFinal << setw(12) << porcentajeVendido << endl;

Nota: cin.getline() y cin >> ws se verán en la lección siguiente. Por lo pronto diremos que cin.getline() se

utiliza para leer cadena de caracteres que tienen espacios en blanco. cin >> ws para eliminar espacios en blanco del área búffer.

OPERACIONES BOOLEANAS Las operaciones booleanas son aquellas que generarán un resultado lógico o booleano de verdadero o falso. En C++, un falso lógico se iguala a 0, y un verdadero lógico se iguala a 1. Realmente, cualquier valor diferente de cero se considera verdadero cuando se aplica a la operación booleana en C++. Hay dos categorías de operadores booleanos: los operadores relacionales y los operadores lógicos.

// El usuario escribe los datos del artículo cout << "Por favor escriba el nombre del artículo: " << endl; cin >> ws; cin.getline(nombreArticulo ,TAMANO_ARTICULO); cout << "Por favor escriba la cantidad inicial del " << nombreArticulo << endl; cin >> cantidadInicial; cout << "Por favor escriba el número de unidades del " << nombreArticulo << "vendido el " << fecha << endl; cin >> unidadesVendidas; // Calcula la cantidad final y el porcentaje vendido para el artículo cantidadFinal = cantidadInicial - unidadesVendidas; porcentajeVendido = (unidadesVendidas / cantidadInicial) * 100; // Imprime el informe del artículo imprimir.setf(ios::fixed); imprimir.precision(2); imprimir << setw(15) << nombreArticulo << setw(21) << cantidadInicial << setw(22) << unidadesVendidas << setw(19) << cantidadFinal << setw(12) << porcentajeVendido << endl; // El usuario escribe los datos del artículo cout << "Por favor escriba el nombre del artículo: " << endl; cin >> ws; cin.getline(nombreArticulo ,TAMANO_ARTICULO); cout << "Por favor escriba la cantidad inicial del " << nombreArticulo << endl; cin >> cantidadInicial; cout << "Por favor escriba el número de unidades del " << nombreArticulo << "vendido el " << fecha << endl; cin >> unidadesVendidas; // Calcula la cantidad final y el porcentaje vendido para el artículo cantidadFinal = cantidadInicial - unidadesVendidas; porcentajeVendido = (unidadesVendidas / cantidadInicial) * 100; // Imprime el informe del artículo imprimir.setf(ios::fixed); imprimir.precision(2); imprimir << setw(15) << nombreArticulo << setw(21) << cantidadInicial << setw(22) << unidadesVendidas << setw(19) << cantid adFinal << setw(12) << porcentajeVendido << endl; // Cierra el archivo imprimir. imprimir.close(); } // Final de main()

OPERADORES RELACIONALES Los operadores relacionales permiten la comparación de dos cantidades. Los seis operadores relacionales comunes disponibles en C++ se muestran en la tabla 6.3:

Tabla 6.3 . Seis operadores relacionales usados en C++

Operador Significado Ejemplo == Igual a if(c == ‘\0’) != No igual a, distinto a if(c != ‘\n’) < Menor que if(i < 10) <= Menor o igual que if(i <= 0) > Mayor que if(j > 10) >= Mayor o igual que if (x >= 8.2) ?: Asignación condicional k = (i < 1) ? 1 : i;

Los operadores relacionales de la tabla anterior se pueden usar para comparar dos variables o expresiones. En general, sólo debe comparar datos de la misma clase. Esto significa que los enteros deben compararse con enteros, punto flotante con punto flotante y caracteres con caracteres. La única excepción a la regla es que los valores de punto flotante se pueden comparar con enteros, porque los enteros son reales. En todos los casos, la operación genera un resultado booleano de verdadero o falso. Vamos a ver algunos ejemplos: Ejemplo 6.13:

Evalúe las siguientes operaciones relacionales: a. 5 == 5 b. 0.025 >= 0.333 c. 3 != 3 d. –45.2 < -3 e. ‘A’ < ‘Z’ f. Si x = 25, y = -10, pruebe x <= y

Solución: a. Verdadero, porque 5 es igual a 5. b. Falso porque 0.025 no es mayor o igual a 0.333. c. Falso , porque 3 es igual a 3. d. Verdadero, porque –45.2 es menor que –3. e. Verdadero, porque C++ realmente compara el valor ASCII de ‘A’ con el valor ASCII de ‘Z’. f. Falso , porque el valor asignado a x (25) no es menor o igual al valor asignado a y (-10)

Los operadores relacionales también se pueden combinar con operadores aritméticos, como el siguiente:

5 + 3 < 4

Ahora la pregunta es: ¿cómo evalúa la computadora esta expresión? ¿Primero realiza la operación de adición o la operación relacional? Como debe de sospechar, la operación de adición se realiza primero y después la operación relacional. En consecuencia, el resultado es falso, porque 8 no es menor que 4. Recuerde, cuando los operadores

relacionales se combinan con operadores aritméticos dentro de una expresión, los operadores relacionales siempre se realizan al final.

Ejemplo 6.14:

Los operadores aritméticos y relacionales pueden ser parte de un enunciado de salida para evaluar una expresión. Determine la salida que se genera con el siguiente programa:

#include <iostream.h> // Para cout void main(void)

{ cout << (3 + 4) << endl; cout << (‘J’ > ‘K’) << endl; cout << (3*10%3-2>20/6+4) << endl;

} // Final del main()

Solución: La salida generada por el programa anterior es:

7 0 0

La primera línea de salida es obvia, porque 3 + 4 = 7. Las líneas de salida restante son valores lógicos basados en la evaluación de las operaciones relacionales respectivas. Recuerde que en C++ un falso lógico se representa por un 0 y un verdadero lógico por un 1. De esta manera, el resultado de ‘J’ > ‘K’ es 0 (falso) porque el valor ASCII para ‘J’ no es más grande que el valor ASCII para ‘K’. Por último, el resultado de la última expresión es 0 (falso) Aquí, el proceso de evaluación va como sigue:

(((3*10) % 3) –2) > ((20 / 6) + 4) = ((30 % 3) –2) > (3+4) = 0 – 2 > 7 = -2 > 7 = 0 (falso)

Como verá en la lección 8, el enunciado if-else, examina una condición y realiza un

conjunto de operaciones si la condición es verdadera y otro si la condición es falsa. De manera semejante, C++ proporciona un operador de asignación condicional , el cual examina una condición y basado en si esta es verdadera o falsa, regresa uno de dos valores.

Operador Significado

(expresión condicional) ? resultadoVerdadero : resultadoFalso Asignación condicional

Por ejemplo, la siguiente condición prueba si una calificación es mayor o igual a 60. Si el valor es mayor o igual a 60, el enunciado asigna la letra ‘P’ a la variable final. Si el valor es menor que 60, el enunciado asigna la letra ‘R’ a la variable final.

final = (calificacion >= 60) ? ‘P’ : ‘R’;

El enunciado cout siguiente muestra como ejemplo la siguiente salida: Su calificación fue de 80: pasó o bien Su calificación fue de 40: Reprobó

cout << “Su calificación fue de “ << calificación << “: “ <<((calificación >=60) ? “Pasó” : “Reprobó”);

Ejemplo 6.15

A continuación veremos un programa: OPREL.CPP, que muestra el uso de los operadores relacionales así como del operador de asignación condicional:

/* El siguiente programa: OPREL.CPP, ilustra el uso de expresiones lógicas, y el uso del operador condicional ?: para desplegar los mensajes VERDADERO o FALSO */ #include <iostream.h> //Para cout y cin //Se definen constantes globales para el rango de valores [30...199] const int NUM_MIN = 30; const int NUM_MAX = 199; void main(void) { int i, j, k; int xorSuma; bool bandera1, bandera2, enRango, entIguales, xorBandera; cout << "Digite el primer entero : "; cin >> i; cout << "Digite el segundo entero: "; cin >> j; cout << "Digite el tercer entero : "; cin >> k; // Prueba que el primer entero esta entre el rango[NUM_MIN ..NUM_MAX] bandera1 = i >= NUM_MIN; bandera2 = i <= NUM_MAX; enRango = bandera1 && bandera2; cout << endl << i << " Se encuentra en el rango " << NUM_MIN << " a " << NUM_MAX << ": " << (enRango ? "VERDADERO" : "FALSO"); // Prueba si dos o más números tecleados son iguales entIguales = i == j || i == k || j == k; cout << endl << "Al menos dos números tecleados son iguales: " << (entIguales ? "VERDADERO" : "FALSO"); // Pruebas diversas cout << endl << i << " != " << j << ": " << ((i != j) ? "VERDADERO" : "FALSO"); cout << endl << "NOT (" < " << j << ": " << ((k > j) ? "VERDADERO" : "FALSO"); cout << endl << "(" << k << " = " << i << ") AND (" << j << " != " << k << "): " << ((k == i && j != k) ? "VERDADERO" : "FALSO"); /* NOTA: C++ no soporta el operador lógico XOR exclusivo para expresiones booleanas. Sin embargo, puede simularse si sumamos los resultados numéricos de las pru ebas lógicas, su valor debe de ser 1 o 2 . */

OPERADORES LÓGICOS Las operaciones lógicas también generan resultados booleanos. Las tres operaciones lógicas que se usan en C++ se muestran en la tabla 6.4:

Tabla 6.4 . Operadores lógicos usados en C++

Operador Significado Ejemplo ! NOT lógico if(!(c > 1 && c < 9)) || OR lógico if (c == 0 || c == 9) && AND lógico if(i > 1 && i < 10)

El estándar ANSI C++ le permite usar los nombres de operación cuando realiza operaciones lógicas. Como una alternativa (necesaria cuando usa compiladores anteriores), como se ve en la tabla, el símbolo de admiración (!) se usa para NOT; los símbolos de doble barra vertical (||) para OR y el símbolo doble ampersand (&&) para AND. El operador NOT se usa para negar, o invertir un valor booleano. Debido a que hay sólo dos valores posibles booleanos (verdadero y falso), la negación de uno da como resultado el otro. Por ejemplo, suponga que definimos un objeto variable booleano A. Entonces la variable A puede tomar sólo dos valores, verdadero o falso. Si A es verdadero, entonces NOT A es falso. Al contrario, si A es falso, entonces NOT A es verdadero. Esta operación se muestra usando una tabla de verdad. Una tabla de verdad simplemente muestra el resultado de una operación lógica sobre un valor booleano. A continuación la tabla de verdad para la operación NOT. A NOT A (!A) verdadero falso falso verdadero La operación OR se aplica a valores booleanos. Por ejemplo, suponga que A y B se definen como variables booleanas. Entonces A y B pueden ser verdadero (no-cero) o falso (cero) El operador OR dicta que si A o B es verdadero el resultado de la operación es

xorSuma = (k <= i) + (j >= k); /* Si xorSuma es 0 o 2 (i.e. no = 1), es FALSE y, por lo tanto, interpreta 0 o 2 como falso. */ xorBandera = xorSuma == 1; cout << endl << "(" << k << " <= " <= " << k << "): " << ( xorBandera ? "VERDADERO" : "FALSO"); cout << endl << "(" << k << " > " < i && j <= k) ? "VERDADERO" : "FALSO"); cout << endl << endl; } //Fin de main()

verdadera. Otra forma para decir esto es que cualquier verdadero da como resultado un verdadero. En términos de una tabla de verdad. A B A OR B (A||B) verdadero verdadero verdadero verdadero falso verdadero falso verdadero verdadero falso falso falso El operador AND también opera sobre valores booleanos. Aquí, si A y B son variables booleanas, entonces la expresión A AND B es verdadera sólo cuando ambos, A y B, son verdaderos. Otra forma de decir esto es que cualquier falso da como resultado falso. En términos de tabla de verdad. A B A AND B (A && B) verdadero verdadero verdadero verdadero falso falso falso verdadero falso falso falso falso

Los operadores lógicos booleanos también se pueden aplicar a expresiones lógicas. Por ejemplo, considere lo siguiente:

(-6 < 0) AND (12 >= 10)

¿Es esta expresión verdadera o falsa? Bien, -6 < 0 es verdadero y 12 >= 10 es verdadero. En consecuencia, la expresión es verdadera. ¿Qué hay de ésta?

((3 – 6) == 3) OR (NOT(2 == 4))

Debe evaluar ambos lados de la expresión. Si cualquier lado es verdadero, entonces el resultado es verdadero. En el lado izquierdo, 3-6 es igua l a –3, el cual no es igual a 3. De esta manera, el lado izquierdo es falso. Del lado derecho, 2 == 4 es falso, pero NOT(2 == 4) es verdadero. Esto hace que el resultado de la operación OR sea verdadero. Nota: En la lección 8 veremos ejemplos en los que se utilicen los operadores lógicos. OPERADORES LÓGICOS AL NIVEL DE BITS C++ proporciona amplias capacidades de manipulación de bits para los programadores que necesitan bajar hasta el llamado nivel de bits y bytes. Los sistemas operativos, el software de equipo de pruebas, el software de conectividad de red y muchos otros tipos de software requieren que el programador se comunique directamente con el hardware. En ésta y en las siguientes secciones trataremos las capacidades de manipulación de bits de C++. Presentaremos cada uno de los muchos operadores al nivel de bits y trataremos en la lección 21 (Almacenamiento de datos relacionados en estructuras), la manera de ahorrar memoria utilizando campos de bits. Todos los datos se representan internamente en las computadoras como secuencias de bits. Cada bit puede asumir el valor 0 o el valor 1. En la mayoría de los sistemas una secuencia de 8 bits forma 1 byte, que es la unidad de almacenamiento estándar para una variable de tipo char. Otros tipos de datos se almacenan en cantidades de bytes más

grandes. Los operadores al nivel de bits se utilizan para manipular los bits de operandos enteros (char, short, int y long, tanto signed como unsigned) Normalmente, los enteros sin signo se utilizan con los operadores al nivel de bits. Los operadores al nivel de bits son: AND a nivel de bits (&), OR inclusivo a nivel de bits ( | )OR exclusivo a nivel de bits ( ^ ), desplazamiento a la izquierda ( << ), desplazamiento a la derecha ( >> ) y complemento ( ~ ). (Observe que hemos utilizado &, << y >> para otros propósitos. Este es un ejemplo clásico de sobrecarga de operadores) Los operadores AND al nivel de bits, OR inclusivo al nivel de bits y OR exclusivo al nivel de bits comparten sus dos operandos bit por bit. El operador AND al nivel de bits establece a 1 cada bit del resultado si los bits correspondientes en ambos operandos son 1. El operador OR inclusivo al nivel de bits establece a 1 cada bit del resultado si el bit correspondiente en alguno (o ambos) operandos es 1. El operador OR exclusivo al nivel de bits establece a 1 cada bit del resultado si el bit correspondiente en solamente un operando es 1. El operador de desplazamiento a la izquierda desplaza los bits de su operando izquierdo hacia la izquierda el número de bits especificado por su operando derecho. El operador de desplazamiento a la derecha desplaza los bits de su operando izquierdo hacia la derecha el número de bits especificado por su operando derecho. El operador de complemento al nivel de bits establece a 1 todos los bits 0 del operando del resultado, y establece a 0 todos los bits 1 en el resultado. En la tabla 6.5 se resumen las operaciones al nivel de bits.

Tabla 6.5. Operadores lógicos para el manejo de bits Operador Significado Ejemplo

~ Operador complemento a unos para el manejo de bits. ~j & Operador AND para el manejo de bits. i & 128 | Operador OR inclusivo para el manejo de bits. j | 64 ^ Operador OR exclusivo para el manejo de bits. j ^ 12 << Operador desplazamiento a la izquierda para manejo de bits. i << 2 >> Operador desplazamiento a la derecha para el manejo de bits. j >> 3 Operadores de asignación para el manejo de bits x &= y x = x & y i &= 128 x |= y x = x | y j |= 64 x ^= y x = x ^ y k ^= 15 x << y x = x << y j << = 2 x >>= y x = x >> y k >> = 3

A continuación se presentan una serie de programas que muestran el uso de estos operadores lógicos para el manejo de bits. Ejemplo 6.16

El siguiente programa: BITOPER, ilustra el uso de los operadores OR, AND, XOR y ~, para el manejo de bits.

Ejemplo 16.17

Cuando se utilizan los operadores al nivel de bits es útil imprimir los valores en su representación binaria para ilustrar los efectos precisos de estos operadores. El siguiente programa: BITOPER2.CPP, imprime un entero unsigned en su representación binaria en grupos de 8 bits. La función visualizarBits() utiliza el operador AND al nivel de bits para combinar la variable valor con la variable visualizaMascara. Dicho operador frecuentemente se utiliza con un operando llamado máscara –que es un valor entero con bits específicos establecidos a 1. Las máscaras se utilizan para ocultar algunos bits de un valor mientras se seleccionan otros. En visualizarBits(), a la variable de máscara visualizaMascara se le asigna el valor 1 << 15 (1000 0000 0000 0000) El operador de desplazamiento a la izquierda desplaza el valor 1 desde el bit de menor orden (el del extremo más a la derecha) hacia el bit de mayor orden (el del extremo más a la izquierda) en visualizaMascara y rellena con bits 0 a partir de la derecha. La instrucción:

cout << (valor & visualizarMascara ? ‘1’ : ‘0’;

determina si se debe imprimir un 1 o un 0 para el bit actual del extremo izquierdo de la variable valor. Supongamos que la variable valor contiene 65000 (1111 1101 1110 1000) Cuando se combinan valor y visualizaMascara utilizando &, todos los bits, a excepción del

/* El siguiente programa: BITOPER.CPP, ilustra el uso del operador OR para bits, del operador AND para bits, del operador XOR para bits y del operador ~ para bits. */ #include <iostream.h> //Para cout void main (void) { cout << "\tEjemplo de uso del operador OR para bits" << endl << endl; cout << "\t0 | 0 es : " << (0 | 0) << endl; cout << "\t0 | 1 es : " << (0 | 1) << endl; cout << "\t1 | 0 es : " << (1 | 0) << endl; cout << "\t1 | 1 es : " << (1 | 1) << endl << endl ; cout << "\t1 | 2 es : " << (1 | 2) << endl; cout << "\t128 | 127 es : " << (128 | 127) << endl << endl ; cout << "\tEjemplo de uso del operador AND para bits" << endl << endl; cout << "\t0 & 0 es : " << (0 & 0) << endl; cout << "\t0 & 1 es : " << (0 & 1) << endl; cout << "\t1 & 0 es : " << (1 & 0) << endl; cout << "\t1 & 1 es : " << (1 & 1) << endl << endl ; cout << "\t1 & 2 es : " << (1 & 2) << endl; cout << "\t15 & 127 es : " << (15 & 127) << endl << endl ;

cout << "\tEjemplo de uso del operador XOR para bits" << endl << endl; cout << "\t0 ^ 0 es : " << (0 ^ 0) << endl; cout << "\t0 ^ 1 es : " << (0 ^ 1) << endl; cout << "\t1 ^ 0 es : " << (1 ^ 0) << endl; cout << "\t1 ^ 1 es : " << (1 ^ 1) << endl << endl ; cout << "\t1 ^ 2 es : " << (1 ^ 2) << endl; cout << "\t15 ^ 127 es : " << (15 ^ 127) << endl << endl ; int valor = 0xFF; cout << "\tEjemplo de uso del operador ~ para bits" << endl << endl ; cout << "\tEl inverso de " << hex << valor << ", es " << ~valor << endl << endl; } //Fin de main()

bit de nivel más alto de la variable valor, son enmascarados (ocultados), debido a que cualquier bit al que se le aplica AND con 0 da como resultado 0. Si el bit del extremo más a la izquierda es 1, valor & visualizaMascara evalúa a 1000 0000 0000 0000 (lo cual se interpreta como true) y se imprime 1; en caso contrario se impr ime 0.Luego la variable valor se desplaza hacia la izquierda en un bit mediante la expresión valor <<= 1 (esto es equivalente a la asignación valor = valor << 1. Estos pasos se repiten para cada bit de la variable valor.

Ejemplo 6.18

El siguiente programa: BITOPER3.CPP, muestra el uso del operador AND al nivel de bits, del operador OR inclusivo al nivel de bits, del operador OR exclusivo al nivel de bits y del operador de complemento al nivel de bits. El programa utiliza la función visualizarBits() para imprimir los valores de entero unsigned.

/* El siguiente programa: BITOPER2.CPP, imprime los bits de un entero sin signo. */ #include <iostream.h> //Para cout y cin #include <iomanip.h> //Para setw() void visualizarBits(unsigned); void main(void) { unsigned x; cout << "Introduzca un número entero sin signo: "; cin >> x; visualizarBits(x); }//Fin de main() void visualizarBits(unsigned valor) { unsigned c, visualizaMascara = 1 << 15; cout << setw(7) << valor << " = "; for( c = 1; c <= 16; c++) { cout << ( valor & visualizaMascara ? '1' : '0' ); valor <<= 1; if( c % 8 == 0) cout << ' '; }//Fin del for cout << endl; }//Fin de visualizarBits()

/* El siguiente programa:BITOPER3.CPP, utiliza los operadores AND a nivel de bits, OR inclusivo al nivel de bits, OR exclusivo al nivel de bits y complemento a nivel de bits. */ #include <iostream.h> //Para cout y cin #include <iomanip.h> //Para setw() void visualizarBits( unsigned ); void main(void) { unsigned numero1, numero2, mascara, conjuntoBits; numero1 = 65535; mascara = 1; cout << "El resultado de combinar\n"; visualizarBits( numero1 ); visualizarBits( mascara ); cout << "utilizando el operador AND (&) a nivel de bits es\n"; visualizarBits( numero1 & mascara ); numero1 = 15; conjuntoBits = 241; cout << "\nEl resultado de combinar\n"; visualizarBits( numero1 ); visualizarBits ( conjuntoBits ); cout << "utilizando el operador OR inclusivo (|) a nivel de bits es\n"; visualizarBits ( numero1 | conjuntoBits ); numero1 = 139; numero2 = 199; cout << "\nEl resultado de combinar\n"; visualizarBits( numero1 ); visualizarBits( numero2 ); cout << "utilizando el operador OR exclusivo (^) a nivel de bits es\n"; visualizarBits( numero1 ^ numero2 ); numero1 = 21845; cout << "\nEl complemento a uno de \n"; visualizarBits( numero1 ); cout << "es" << endl; visualizarBits( ~numero1 ); }//Fin de main() void visualizarBits(unsigned valor) { unsigned c, visualizaMascara = 1 << 15; cout << setw(7) << valor << " = "; for( c = 1; c <= 16; c++) { cout << ( valor & visualizaMascara ? '1' : '0' ); valor <<= 1; If( c % 8 == 0) cout << ' '; }//Fin del for cout << endl; }//Fin de visualizarBits()

En el programa anterior: BITOPER3.CPP, a la variable mascara se le asigna el valor 1 (00000000 00000001), y a la variable numero1 se le asigna el valor 65535 (11111111 11111111) Cuando mascara y numero1 se combinan mediante el operador AND al nivel de bits (&) en la expresión numero1 & mascara, el resultado es 00000000 00000001. Todos los bits, a excepción del bit de nivel más inferior de la variable numero1 , son enmascarados (ocultados) aplicando AND con la variable mascara. El operador OR inclusivo al nivel de bits se utiliza para establecer a 1 los bits específicos en un operando. En el programa a la variable numero1 se le asigna 15 (00000000 00001111), y a la variable conjuntoBits se le asigna 241 (00000000 11110001) Cuando numero1 y conjuntoBits se combinan mediante el operador OR al nivel de bits en la expresión numero1 | conjuntoBits, el resultado es 255 (00000000 11111111) El operador OR exclusivo a nivel de bits ( ^ ) establece a 1 cada bit del resultado si únicamente uno de los bits correspondientes en los dos operandos es 1. En el programa a las variables numero1 y numero2 se les asignan los valores 139 (00000000 10001011 ) y 199 (00000000 11000111 ), respectivamente. Cuando estas variables se combinan mediante el operador OR exclusivo en la expresión numero1 ^ numero2, el resultado es 00000000 01001100. El operador de complemento a nivel de bits ( ~ ) establece a 0 todos los bits 1 de su operando en el resultado, y establece a 1 todos los bits 0 en el resultado –es también conocido como tomar el complemento a uno del valor. En el programa a la variable numero1 se le asigna el valor 21845 (01010101 01010101) Cuando se evalúa a la expresión ~numero1, el resultado es (10101010 10101010)

Ejemplo 6.19 El siguiente programa: BITOPER4.CPP, muestra al operador de desplazamiento a la izquierda (<<) y al operador de desplazamiento a la derecha (>>) La función visualizarBits() se utiliza para imprimir los valores enteros unsigned.

/* El siguiente programa: BITOPER4.CPP, muestra el uso de los operadores de desplazamiento a nivel de bits. */ #include <iostream.h> //Para cout y cin #include <iomanip.h> //Para setw() void visualizarBits( unsigned ); void main(void) { unsigned numero1 = 960; cout << "El resultado del desplazamiento a la izquierda de\n"; visualizarBits( numero1 ); cout << "en 8 posiciones utilizando el " << "operador de desplazamiento a la izquierda es\n"; visualizarBits( numero1 << 8 ); cout << "\nEl resultado del desplazamiento a la derecha de\n"; visualizarBits( numero1); cout << "en 8 posiciones utilizando el " << "operador de desplazamiento a la derecha es\n"; visualizarBits( numero1 >> 8 ); }//Fin de main()

El operador de desplazamiento a la izquierda ( << ) desplaza a los bits de su operando izquierdo hacia la izquierda el número de bits especificado por su operando derecho. Los bits que quedan vacantes en el lado derecho se reemplazan con ceros y los unos desplazados hacia fuera por el lado izquierdo se pierden. En el programa a la variable numero1 se le asigna el valor 960 (00000011 11000000): El resultado del desplazamiento en 8 bits hacia la izquierda de dicha variable en la expresión numero1 << 8 es 49152 (11000000 00000000) El operador de desplazamiento a la derecha (>>) desplaza los bits de su operando izquierdo hacia la derecha el número de bits especificado por su operando derecho. Realizar un desplazamiento derecho sobre un entero unsigned. Causa que los bits vacantes del lado izquierdo se reemplacen con ceros, y se pierden los unos desplazados hacia fuera del lado derecho. En el programa el resultado de desplazar hacia la derecha a numero1 en la expresión numero1 >> 8 es 3 (00000000 00000011 )

Cuando trabaje con valores al nivel de bits, una de las operaciones que tendrá que efectuar con cierta frecuencia es el desplazamiento de bits: a la izquierda o a la derecha. C++ proporciona dos operadores de desplazamiento de bits: uno que desplaza los bits a la derecha (>>) y el otro lo desplaza a la izquierda (<<) La expresión siguiente utiliza el operador de desplazamiento a la izquierda para desplazar el valor de la variable bandera dos posiciones a la izquierda:

bandera = bandera << 2;

Suponiendo que la variable bandera contiene el valor 2 como se muestra a continuación:

0000 0010

Después de desplazar el valor anterior dos posiciones a la izquierda su valor será de 8:

0000 1000

void visualizarBits(unsigned valor) { unsigned c, visualizaMascara = 1 << 15; cout << setw(7) << valor << " = "; for( c = 1; c <= 16; c++) { cout << ( valor & visualizaMascara ? '1' : '0' ); valor <<= 1; if( c % 8 == 0) cout << ' '; }//Fin del for cout << endl; }//Fin de visualizarBits()

Cuando el desplazamiento se provoca hacia la izquierda, C++ coloca ceros en los bits de las posiciones menos significativos. Cuando el desplazamiento es a la derecha, lo que C++ coloca en la posición de los bits más significativos depende de si la variable es sin signo o con signo. Si la variable es sin signo (unsigned), C++ coloca ceros en los bits más significativos. Si la variable tiene signo, C++ coloca unos o ceros en los bits más significativos dependiendo de si la variable es negativo o positivo respectivamente. El siguiente programa: DESPLAZA.CPP, ilustra el uso del operador de desplazamiento: Ejemplo 6.20

El siguiente programa: DESPLAZA.CPP, ilustra el uso de los operadores de desplazamiento a la derecha y a la izquierda.

/* El siguiente programa: DESPLAZA.CPP , ilustra el uso de los operadores de desplazamiento a la derecha y a la izquierda. */ #include <iostream.h> //Para cout void main(void)

{ unsigned uVal = 1; signed int valor = -1;

unsigned uResultado;

uResultado = uVal << 2; cout << "(unsigned) " << uVal << " desplazado 2 veces a la izquierda es " << uResultado << endl;

uResultado = uVal >> 2; cout << "(unsigned) " << uVal << " desplazado 2 veces a la derecha es " << uResultado << endl;

uVal = 65535; uResultado = uVal << 2; cout << "(unsigned) " << uVal << " desplazado 2 veces a la izquierda es " << uResultado << endl;

uResultado = uVal >> 2; cout << "(unsigned) " << uVal << " desplazado 2 veces a la derecha es " << uResultado << endl << endl;

uResultado = valor << 2; cout << "(signed) " << valor << " desplazado 2 veces a la izquierda es " << uResultado << endl;

uResultado = valor >> 2; cout << "(signed) " << valor << " desplazado 2 veces a la derecha es " << uResultado << endl; } //Fin de main()

Ejemplo 6.21 El siguiente programa: BITS.CPP, ilustra el uso de los operadores lógicos para el manejo de bits:

ROTACIÓN DE BITS Cuando se trabaja al nivel de bits, hay ocasiones en que en vez de simplemente desplazar los bits a la derecha o a la izquierda, requerirá rotar los bits. Cuando rota los bits a la izquierda, el valor del bit más significativo se convierte en el bit menos significativo, los otros bits se desplazan una posición a la izquierda. Cuando gira los bits a la derecha, el valor del bit menos significativo se convierte en el más significativo, los otros bits se desplazan una posición a la derecha. Para realizar esta tarea, C++ proporciona las funciones _rotl() y _rotr() las cuales se aplican a valores enteros sin signo. _lrotl() y _lrotr() que se aplican a valores enteros largo (long int) sin signo. Ejemplo 6.22 El siguiente programa: GIRAR.CPP, ilustra el uso de las funciones anteriores:

/* El siguiente programa: BITS.CPP ilustra los operadores para el manejo de bits. */ #include <iostream.h> //Para cout void main(void) { int i, j, k;

// Asigna valores a i y j i = 0xF0; j = 0x1A;

k = j & i; cout << j << " AND " << i << " = " << k << endl;

k = j | i; cout << j << " OR " <> 2; cout << i << " desplazado dos bits a la derecha es " <<

" = " << k << endl; } //Fin de main()

EL OPERADOR sizeof() Cuando escribe programas que manejan operaciones de entrada/salida en archivos o bien al localizar memoria para asignarla a listas dinámicas, es frecuentemente conveniente conocer la cantidad de memoria que su programa ha utilizado para una determinada variable. El operador sizeof() regresa el número de bytes que una variable o clase requiere. Ejemplo 6.23

El siguiente programa: SIZEOF1.CPP, ilustra el uso del operador sizeof():

/* El siguiente programa: GIRAR.CPP, ilustra el uso de las funciones: _rotl(), _rotr(), _lrotl(), _lrotr() */ #include <iostream.h> //Para cout #include <stdlib.h> //Para _rotl(), _rotr(), _lrotl(), _lrotr() void main(void) { unsigned valor = 1; unsigned long valor2 = 1; cout << "Rotación para valores enteros sin signo." << endl << endl; cout << valor << " rotado una vez a la derecha es : " << _rotr(valor, 1) << endl; valor = 5; cout << valor << " rotado dos veces a la derecha es : " << _rotr(valor, 2) << endl; valor = 65534; cout << valor << " rotado dos veces a la izquierda es: " << _rotl(valor, 2) << endl << endl; cout << "Rotación para valores enteros sin signo long" << endl << endl; cout << valor2 << " rotado una vez a la derecha es : " << _lrotr(valor, 1) << endl; valor2 = 5; cout << valor2 << " rotado dos veces a la derecha es : " << _lrotr(valor2, 2) << endl; valor2 = 65534; cout << valor2 << " rotado dos veces a la izquierda es: " << _lrotl(valor2, 2) << endl; } //Fin de main()

Ejemplo 6.24

El siguiente programa: SIZEOF2.CPP, ilustra el uso de sizeof() tanto para variables como para tipos de datos.

/* El siguiente programa: SIZEOF1.CPP, ilustra el uso de operador sizeof. */ #include <iostream.h> //Para cout void main (void)

{ cout << "Las variables de tipo int utilizan " << sizeof(int)

<< " bytes" << endl; cout << "Las variables de tipo float utilizan " << sizeof(float) << " bytes" << endl; cout << "Las variables de tipo double utilizan " << sizeof(double)

<< " bytes" << endl; cout << "Las variables de tipo unsigned utilizan " << sizeof(unsigned) << " bytes" << endl; cout << "Las variables de tipo long utilizan " << sizeof(long) << " bytes" << endl; } //Fin de main()

/* El siguiente programa: SIZEOF2.CPP, ilustra el uso de sizeof() tanto para variables como para tipos de datos.*/ #include <iostream.h> //Para cout void main(void) { short int unCorto; int unInt; long unLong; char unCar; float unReal; cout << "Tabla 1. Tamaño de los datos usando sizeof(variable)" << endl << endl; cout << " Tipo de dato Memoria utilizada" << endl; cout << " bytes)" << endl; cout << "------------------ ------------------" << endl ; cout << " short int " << sizeof(unCorto)<< endl; cout << " integer " << sizeof(unInt) << endl; cout << " long integer " << sizeof(unLong) << endl ; cout << " character " << sizeof(unCar) << endl; cout << " float " << sizeof(unReal) << endl; cout << endl << endl << endl ; cout << "Tabla 2. Tamaño de los datos usando sizeof(tipoDato)" << endl << endl;

cout << " Tipo de dato Memoria utilizada" << endl; cout << " bytes)" << endl; cout << " ------------------ ------------------" << endl ; cout << " short int " << sizeof(short int) << endl; cout << " integer " << sizeof(int) << endl ; cout << " long integer " << sizeof(long) << endl; cout << " character " << sizeof(char) << endl; cout << " float " << sizeof(float)<< endl ; cout << endl << endl << endl ;

} Fin de main()

ASIGNACIÓN DE TIPO (typecasting) Una de las labores de un compilador es la conversión automática del valor de un tipo de dato a otro tipo de dato compatible. Por ejemplo, el compilador maneja la mayoría de las expresiones que combinan diversos tipos de enteros o tipos de enteros con tipos de punto flotante. Typecasting (asignación de tipo) es una característica del lenguaje, que le permite especificar explícitamente la manera de convertir un valor del tipo de dato original a un tipo de dato compatible. Por lo tanto, la característica typecasting le da instrucciones al compilador para que realice la conversión que desea y no la que éste considere necesaria. C++ soporta las siguientes formas typecasting:

Asignación de tipo (expresión); y

(asignación de tipo) expresión; Ejemplos: int i = 2; float a, b; a = float(i); b = (float)i; Ejemplo 6.25

El siguiente programa: TYPECAST.CPP, ilustra como maneja los datos el compilador y como se hace la asignación de tipo :

/* El siguiente programa: TYPECAST.CPP, ilustra la característica typecasting (asignación de tipo) */ #include <iostream.h> //Para cout void main(void) { short cortoEnt1, cortoEnt2; unsigned short unByte;

int unEnt; long unLong; char unCar; float unReal; // Asigna valores cortoEnt1 = 10; cortoEnt2 = 6;

// Realiza operaciones sin typecasting unByte = cortoEnt1 + cortoEnt2; unEnt = cortoEnt1 - cortoEnt2; unLong = cortoEnt1 * cortoEnt2; unCar = unLong + 5; // La conversión a caracter es automática unReal = cortoEnt1 * cortoEnt2 + 0.5;

cout << "cortoEnt1 = " << cortoEnt1 << endl << "cortoEnt2 = " << cortoEnt2 << endl << "unByte = " << unByte << endl << "unEnt = " << unEnt << endl << "unLong = " << unLong << endl << "unCar es = " << unCar << endl << "unReal = " << unReal << endl << endl << endl;

SOLUCION DE PROBLEMAS EN ACCION: Lógica booleana PROBLEMA

Un operador lógico booleano común que no está disponible en C++ es la operación NAND (NOT AND) Dadas dos variables A y B, la operación NAND se define como sigue:

A B A NAND B verdadero verdadero falso verdadero falso verdadero falso verdadero verdadero falso falso verdadero

Observe que la operación NAND simplemente es opuesta a la operación AND. En símbolos, A NAND B = NOT(A AND B) Escriba un programa C++ que muestre el resultado NAND de dos valores lógicos escritos por el usuario. Empecemos por definir el problema en términos de salida, entrada y proces amiento.

DEFINICIÓN DEL PROBLEMA

Salida: El programa deberá mostrar el resultado lógico de la operación NAND como se define en su tabla de verdad.

Entrada: El usuario escribirá valores lógicos para las variables de entrada, A y B. Procesamiento: Aunque la operación NAND no está disponible en C++, puede

implementarla con los operadores NOT y AND, de la siguiente manera:

A NAND B = NOT(A AND B)

O, usando la sintaxis alternativa:

A NAND B = !(A && B)

Dado que este es un problema relativamente sencillo, no necesitaremos dividirlo en pequeños subproblemas. Más aún, desarrollaremos un algoritmo sencillo de la definición del problema. Ahora, la definición del problema pide que indiquemos al usuario que escriba dos valores booleanos para A

// Realiza operaciones con typecasting unByte = (unsigned short) (cortoEnt1 + cortoEnt2); unEnt = (int) (cortoEnt1 - cortoEnt2); unLong = (long) (cortoEnt1 * cortoEnt2); unCar = (unsigned char) (unLong + 5); unReal = (float) (cortoEnt1 * cortoEnt2 + 0.5); cout << "cortoEnt1 = " << cortoEnt1 << endl << "cortoEnt2 = " << cortoEnt2 << endl << "unByte = " << unByte << endl << "unEnt = " << unEnt << endl << "unLong = " << unLong << endl << "unCar es = " << unCar << endl << "unReal = " << unReal << endl << endl << endl; } //Fin de main()



y B y que aplique la relación anterior para generar el resultado booleano. Sin embargo, hay una dificultad menor. No es posible leer valores booleanos desde el teclado. En cambio, deberá leer información de caracteres, probar la información de verdadero o falso y después hacer una asignación a las variables A y B. El siguiente algoritmo llevará a cabo el trabajo:


INICIO Escribir(“Breve descripción de lo que hace el programa”) Escribir(“Escribir una V/F para verdadero o falso: “) Leer (Entrada) Si (Entrada = “V”) entonces Asigna verdadero a A. Si no Asigna falso a A. Escribir(“Escribir una V/F para verdadero o falso: “) Leer (Entrada) Si (Entrada = “V”) entonces Asigna verdadero a B. Si no Asigna falso a B. Asigna NOT(A AND B) a NAND. Escriba NAND.

FIN.

/* El siguiente programa: NAND.CPP ilustra el uso de los operadores NOT y AND

Salida: El programa debe mostrar el resultado lógico de la operación NAND. Entrada: El usuario debe escribir valores booleanos para las variables de entrada

A y B. Procesamiento: A NAND B = NOT(A AND B) = !(A && B).*/

#include <iostream.h> // Para cin y cout. void main(void) { // Enunciado de clases enumeradas booleanas. enum boolean {FALSO, VERDADERO}; // Definición de variables. char entrada = ' '; // Entrada del usuario. boolean NAND = FALSO; // Resultado de la operacion NAND. boolean A = FALSO; // Valor booleano. boolean B = FALSO; // Valor booleano. // Muestra el mensaje de la descripción del programa. cout << "Este programa generará un resultado NAND (no AND)\n" "de los dos valores booleanos que escriba." << endl << endl ; // El usuario escribe la primera variable booleana. cout << "Escriba un valor booleano (V para VERDADERO o F para FALSO)" << endl; cin >> entrada; // Verifica la entrada del usuario para VERDADERO O FALSO y hace las // asignaciones booleanas. if((entrada == 'V') || ( entrada == 'v')) A = VERDADERO; else A = FALSO; // El usuario escribe la segunda variable booleana. cout << "Escriba un valor booleano (V para VERDADERO o F para FALSO)" << endl; cin >> entrada; // Verifica la entrada del usuario para VERDADERO O FALSO y hace las // asignaciones booleanas. if((entrada == 'V') || (entrada == 'v')) B = VERDADERO; else B = FALSO; // Determine el resultado NAND. NAND = !(A && B); // Verifica el resultado NAND para verdadero o falso y muestra el resultado if (NAND ==VERDADERO) cout << "\n\nEl resultado de NAND es: VERDADERO" << endl; else cout << "\n\nEl resultado de NAND es: FALSO" << endl; } // Final de main()

BIBLIOTECA DE MANEJO DE CARACTERES

La mayoría de los datos se introducen en la computadora como caracteres, incluyendo letras, dígitos y diversos símbolos especiales. En esta sección tratamos las capacidades de C++ para examinar y manipular caracteres individuales. En el resto de la lección continuaremos la discusión sobre el manejo de cadenas de caracteres.

La biblioteca de manejo de caracteres incluye va rias funciones que realizan pruebas

y manipulaciones útiles de datos de carácter. Cada función recibe como argumento un carácter, representado con un int o EOF. Los caracteres se manipulan frecuentemente como enteros. Recuerde que EOF tiene normalmente el valor –1, y algunas arquitecturas de hardware no permiten que se almacén valores negativos en las variables char. Por lo tanto, las funciones para el manejo de caracteres manipulan a los caracteres como si fueran enteros. La tabla 6.6 resume las funciones de la biblioteca de manejo de caracteres. Cuando utilice funciones de la biblioteca de caracteres, asegúrese de incluir el archivo de encabezado <ctype.h>.

Tabla 6.6. Resumen de las funciones de la biblioteca de manejo de caracteres

Prototipo Descripción int isdigit( int c ) Devuelve true si c es dígito, y false si no lo es. int isalpha( int c ) Devuelve true si c es una letra, y false si no lo es. int isalnum( int c ) Devuelve true si c es un dígito o una letra, y false si

no lo es. int isxdigit( int c ) Devuelve true si c es un carácter de dígito

hexadecimal, y false si no lo es. int islower( int c ) Devuelve true si c es una letra minúscula, y false si

no lo es. int isupper( int c ) Devuelve true si c es una letra mayúscula, y false si

no lo es. int tolower( int c ) Si c es una letra mayúscula, tolower() devuelve a c

como letra minúscula. De lo contrario, devuelve el argumento sin cambios.

int toupper( int c ) Si c es una letra minúscula, toupper() devuelve a c como letra mayúscula. De lo contrario, devuelve el argumento sin cambios.

int isspace( int c ) Devuelve true si c es un carácter de espacio en blanco, -nueva línea (‘\n’), espacio (‘ ’ ), avance de forma (‘\f’), tabulación horizontal (‘\t’) o tabulación vertical (‘\v’) – y false si no lo es.

int iscntrl( int c ) Devuelve true si c es un carácter de control, y false si no lo es.

int ispunct( int c ) Devuelve true si c es un carácter imprimible diferente a espacio, dígito o letra, y false si no lo es

int isprint( int c ) Devuelve true si c es un carácter imprimible incluyendo espacio (‘ ’), y false si no lo es.

int isgraph( int c ) Devuelve true si c es un carácter imprimible diferente a espacio (‘ ’), y false si no lo es.

Ejemplo 6.26 El siguiente programa: PRUEBACAR.CPP, muestra a las funciones isdigit(), isalpha (), isalnum() e isxdigi()t. La función isdigit() determina si su argumento es un dígito (0 – 9) La función isalpha() determina si su argumento es una letra mayúscula (A – Z) o minúscula (a – z). La función isalnum() determina si su argumento es una letra mayúscula, minúscula o un dígito. La función isxdigit() determina si su argumento es un dígito hexadecimal (A – F, a – f, 0 – 9) El programa anterior utiliza el operador condicional (?:) con cada función para determinar si se debe imprimir la cadena “es un” o “no es un” para cada carácter que se prueba. Por ejemplo, la expresión:

isdigit( ‘8’ ) ? “8 es un” : “8 no es un”

/* El siguiente programa: PRUEBACAR.CPP, muestra el uso de isdigit(), isalpha(), isalnum(), e isxdigit(). */ #include <iostream.h> //Para cout y cin #include <ctype.h> //Para isdigit(), isalpha(), isalnum() e isxdigit() void main(void) { cout << "De acuerdo a isdigit():\n" << ( isdigit( '8' ) ? "8 es un" : "8 no es un" ) << " dígito\n" << ( isdigit( '#' ) ? "# es un" : "# no es un" ) << " dígito\n"; cout << "\nDe acuerdo a isalpha():\n" << ( isalpha( 'A' ) ? "A es una " : "A no es una") << " letra\n" << ( isalpha( 'b' ) ? "b es una" : "b no es una" ) << " letra\n" << ( isalpha( '&' ) ? "& es una " : "& no es una " ) << " letra\n" << ( isalpha( '4' ) ? "4 es una" : "4 no es una" ) << " letra\n"; cout << "\nDe acuerdo a isalnum():\n" << ( isalnum( 'A' ) ? "A es un" : "A no es un" ) << " dígito o una letra\n" << ( isalnum( '8' ) ? "8 es un" : "8 no es un" ) << " dígito o una letra\n" << ( isalnum( '#' ) ? "# es un" : "# no es un" ) << " dígito o una letra\n"; cout << "\nDe acuerdo a isxdigit():\n" << ( isxdigit( 'F' ) ? "F es un" : "F no es un" ) << " dígito hexadecimal\n" << ( isxdigit( 'J' ) ? "J es un" : "J no es un" ) << " dígito hexadecimal\n" << ( isxdigit( '7' ) ? "7 es un" : "7 no es una" ) << " dígito hexadecimal\n" << ( isxdigit( 'f' ) ? "f es un" : "f no es un" ) << " dígito hexadecimal\n"; }//Fin de main()

indica que si ‘8’ es un dígito, es decir, isdigit() devuelve un valor true (diferente de 0), se imprime la cadena “8 es un”, y si ‘8’ no es un dígito, es decir, isdigit() devuelve 0, se imprime la cadena “8 no es un”.

Ejemplo 6.27

El siguiente programa: PRUEBACAR2.CPP, muestra las funciones islower(), isupper(), tolower() y toupper() La función islower() determina si su argumento es una letra minúscula (a – z ) La función isupper() determina si su argumento es una letra mayúscula (A – Z ) La función tolower() convierte una letra mayúscula a minúscula y devuelve la letra minúscula. Si el argumento no es una letra mayúscula, tolower() devuelve el argumento sin cambio. La función toupper() convierte una letra minúscula a mayúscula y devuelve la letra mayúscula. Si el argumento no es una letra minúscula, toupper() devuelve el argumento sin cambio.

/* El siguiente programa: PRUEBACAR2.CPP, muestra el uso de islower(), isupper(),tolower() y toupper(). */ #include <iostream.h> //Para cout y cin #include <ctype.h> //Para islower(), isupper() y toupper() void main(void) { cout << "De acuerdo a islower():\n" << ( islower( 'p' ) ? "p es una" : "p no es una" ) << " letra minúscula\n" << ( islower( 'P' ) ? "P es una" : "P no es una" ) << " letra minúscula\n" << ( islower( '5' ) ? "5 es una" : "5 no es una" ) << " letra minúscula\n" << ( islower( '!' ) ? "! es una" : "! no es una" ) << " letra minúscula\n"; cout << "\nDe acuerdo a isupper():\n" << ( isupper( 'D' ) ? "D es una" : "D no es una" ) << " letra mayúscula\n" << ( isupper( 'd' ) ? "d es una" : "d no es una" ) << " letra mayúscula\n" << ( isupper( '8' ) ? "8 es una" : "8 no es una" ) << " letra mayúscula\n" << ( isupper( '$' ) ? "$ es una" : "$ no es una" ) << " letra mayúscula\n"; cout << "\nu convertida a mayúscula es " << ( char ) toupper( 'u' ) << "\n7 convertido a mayúscula es " << ( char ) toupper( '7' ) << "\n$ convertido a mayúscula es " << ( char ) toupper( '$' ) << "\nL convertida a minúscula es " << ( char ) tolower( 'L' ) << endl; }//Fin de main()

Ejemplo 6.28

El siguiente programa: PRUEBACAR3.CPP, muestra las funciones isspace(), iscntrl(), ispunct(), isprint() e isgraph() La función isspace() determina si su argumento es un carácter de espacio en blanco, tal como espacio (‘ ’), avance de forma (‘\f’), nueva línea (‘\n’), retorno de carro (‘\r’), tabulación horizontal (‘\t’) o tabulación vertical (‘\v’) La función iscntrl() determina si su argumento es un carácter de control, tal como tabulación horizontal, tabulación vertical, avance de forma, alerta (‘\a’), retroceso (‘\b’), retorno de carro, nueva línea. La función ispunct() determina si su argumento es un carácter imprimible que no sea espacio, dígito o letra, tal como $, #, (, ), [, ], {, }, ;, :, %, etc. La función isprint() determina si su argumento es un carácter que puede desplegarse en pantalla (incluyendo el carácter espacio) La función isgraph() prueba por los mismos caracteres que isprint(), pero no se incluye el carácter de espacio.

/* El siguiente programa. PRUEBACAR3.CPP, muestra el uso de las funciones isspace() iscntrl(), ispunct(), isprint() e isgraph(). */ #include <iostream.h> //Para cout y cin #include <ctype.h> //Para las funciones isspace() iscntrl(), ispunct(), isprint() e isgraph(). void main(void) { cout << "De acuerdo a isspace(): \nNueva línea " << ( isspace( '\n' ) ? "es un" : "no es un" ) << " caracter de espacio en blanco\nTabulación horizontal " << ( isspace( '\t' ) ? "es un" : "no es un" ) << " caracter de espacio en blanco\n" << ( isspace( '%' ) ? "% es un" : "% no es un" ) << " caracter de espacio en blanco\n"; cout << "\nDe acuerdo a iscntrl(): \nNueva línea " << ( iscntrl( '\n' ) ? "es un" : "no es un" ) << " caracter de control\n" << ( iscntrl( '$' ) ? "$ es un" : "$ no es un" ) << " caracter de control\n"; cout << "\nDe acuerdo a ispunct():\n" << ( ispunct( ';' ) ? "; es un" : "; no es un" ) << " caracter de puntuación\n" << ( ispunct( 'Y' ) ? "Y es un" : "Y no es un" ) << " caracter de puntuación\n" << ( ispunct( '#' ) ? "# es un" : "# no es un" ) << " caracter de puntuación\n"; cout << "\nDe acuerdo a isprint():\n" << ( isprint( '$' ) ? "$ es un" : "$ no es un" ) << " caracter de impresión\nAlerta " << ( isprint( '\a' ) ? "es un" : "no es un" ) << " caracter de impresión\n"; cout << "\nDe acuerdo a isgraph():\n" << ( isgraph( 'Q' ) ? "Q es un" : "Q no es un" ) << " caracter de impresión diferente al espacio en blanco\nEspacio en blanco" << ( isgraph( ' ' ) ? " es un" : " no es un" ) << " caracter de impresión\ndiferente al espacio en blanco" << endl; }//Fin de main()

FUNCIONES DE CONVERSIÓN DE CADENAS En las siguientes secciones trataremos varias de las funciones más populares de manejo de cadenas de caracteres de C++, que incluyen funciones para la conversión de cadenas a valores numéricos, funciones para búsquedas en cadenas y funciones para manipular, comparar y buscar en bloques de memoria. Esta sección presenta las funciones de conversión de cadena de la biblioteca de utilerías generales (stdlib) Estas convierten cadenas de dígitos a valores enteros y de punto flotante. La tabla 6.7 resume las funciones de conversión de cadenas. Observe el uso de const para declarar la variable nPtr en los encabezados de función (lea de derecha a izquierda como nPtr es un apuntador a una constante de carácter); const declara que el valor del argumento no se modificará. Cuando utilice funciones de la biblioteca de utilerías generales, asegúrese de incluir el archivo de encabezado <stdlib.h>.

Tabla 6.7. Resumen de las funciones de conversión de cadenas de la biblioteca de utilerías generales.

Prototipo Descripción double atof( const char *nPtr ) Convierte la cadena nPtr a double int atoi( const char *nPtr ) Convierte la cadena nPtr a int. long atol (const char *nPtr ) Convierte la cadena nPtr a long int. double strtod( const char *nPtr , char **endPtr) Convierte la cadena nPtr a double long strtol( const char *nPtr, char ** endPtr, int base ) Convierte la cadena nPtr a long . unsigned long strtoul( const char *nPtr, char **endPtr, int base )

Convierte la cadena nPtr a unsigned long .

Ejemplo 6.29

La función atof() convierte su argumento –una cadena que representa un número de punto flotante – a un valor double. Dicha función devuelve el valor double. Si el valor a convertir no puede ser representado –por ejemplo, si el primer carácter de la cadena no es un dígito – la función atof() devuelve 0. El siguiente programa: ATOF.CPP, ilustra el uso de la función atof()

/* El siguiente programa: ATOF.CPP, ilustra el uso de la función atof() */ #include <iostream.h> //Para cout y cin #include <stdlib.h> //Para atof() void main(void) { double d = atof( "99.0" ); cout << "La cadena de caracteres \"99.0\" convertida a double es " << d << "\nEl valor convertido dividido entre 2 es " << d / 2.0 << endl; }//Fin de main()

Ejemplo 6.30

La función atoi() convierte su argumento –una cadena de dígitos que representan un entero –a un valor int. Dicha función devuelve el valor int. Si el valor a convertir no puede ser representado, la función devuelve 0. El siguiente programa: ATOI.CPP, ilustra el uso de la función atoi()

Ejemplo 6.31

La función atol() convierte su argumento –una cadena de dígitos que representan un entero largo –a un valor long. Dicha función devuelve el valor long. Si el valor a convertir no puede ser representado, la función atol() devuelve 0. Si int y long se almacenan en 4 bytes, las funciones atoi() y atol() trabajan en forma idéntica. El siguiente programa: ATOL.CPP, ilustra el uso de la función atol()

Ejemplo 6.32

La función strtod() convierte a double a una secuencia de caracteres que representan un valor de punto flotante. Esta función recibe dos argumentos –una cadena (char *) y un apuntador a una cadena. La cadena contiene la secuencia de caracteres que se convertirá a double. Al segundo argumento se le asigna la localidad del primer carácter después de la parte convertida de la cadena. La instrucción

d = strtod( string, &stringPtr );

/* El siguiente programa: ATOI.CPP, ilustra el uso de la función atoi() */ #include <iostream.h> //Para cout y cin #include <stdlib.h> //Para atoi() void main(void) { int i = atoi( "2593" ); cout << "La cadena de caracteres \"2593\" convertida a int es " < //Para cout y cin #include <stdlib.h> //Para atol() void main(void) { long l = atol( "1000000" ); cout << "La cadena de caracteres \"1000000\" convertida a long es " << 1 << "\nEl valor convertido dividido entre 2 es " << l / 2 << endl; }//Fin de main()

del programa STRTOD.CPP, indica que a d se le asigna el valor double convertido a partir de string, y a &stringPtr se le asigna la localidad del primer carácter después del valor convertido en string.

Ejemplo 6.33

La función strtol() convierte a long una secuencia de caracteres que representan un entero. La función recibe tres argumentos –una cadena (char *), un apuntador a una cadena y un entero. La cadena contiene la secuencia de caracteres a convertirse. Al segundo argumento se le asigna la localidad del primer carácter después de la parte convertida de la cadena. El entero especifica la base del valor que está siendo convertido. La instrucción:

x = strtol( string, &remainderPtr, 0 );

del programa STRTOL.CPP, indica que a x se le asigna el valor long convertido a partir de string. Al segundo argumento, &remainderPtr, se le asigna el resto de string después de la conversión. El uso de NULL para el segundo argumento causa que se ignore el resto de la cadena. El tercer argumento, 0, indica que el valor a convertirse puede estar en formato octal (base 8), decimal (base 10) o hexadecimal (base 16) Las bases se pueden especificar como 0 o cualquier valor entre 2 y 36. Las representaciones numéricas de enteros desde base 11 hasta base 36 utilizan los caracteres de la A a la Z para representar los valores del 10 al 35. Por ejemplo, los hexadecimales pueden consistir de los dígitos 0 – 9 y los caracteres A – F. Un entero de base 11, puede consistir de los dígitos 0 – 9 y del carácter A. Un entero de base 24 puede consistir de los dígitos 0 – 9 y los caracteres A – N. Un entero de base 36 puede consistir de los dígitos 0 – 9 y los caracteres A – Z .

* El siguiente programa: STRTOD.CPP , ilustra el uso de la función strtod() */ #include <iostream.h> //Para cout y cin #include <stdlib.h> //Para strtod() void main(void) { double d; char *string = "51.2% se recibió", *stringPtr; d = strtod( string, &stringPtr); cout << "La cadena de caracteres \"" << string << "\" es convertida al valor \ndouble " << d << " y a la cadena \"" << stringPtr << "\"" << endl; }//Fin de main()

/* El siguiente programa: STRTOL.CPP , ilustra el uso de la función strtol() */ #include <iostream.h> //Para cout y cin #include <stdlib.h> //Para strtol() void main(void) { long x; char *string = "-1234567abc", *remainderPtr;

Ejemplo 6.34

La función strtoul() convierte a unsigned long una secuencia de caracteres que representan un entero unsigned long. La función trabaja en forma idéntica a la función strtol() La instrucción:

x = strtoul( string, &remainderPtr, 0 );

del programa STRTOUL.CPP, indica que a x se le asigna el valor unsigned long convertido a partir de string. Al segundo argumento, &remainderPtr, se le asigna el resto de string después de la conversión. El tercer argumento, 0, indica que el valor a convertirse puede estar en formato octal, decimal o hexadecimal.

Ejemplo 6.35

El siguiente programa: CONVDATO.CPP, ilustra el uso de algunas funciones y macros utilizadas en C++ para la conversión de datos.

x = strtol( string, &remainderPtr, 0 ); cout << "La cadena original es \"" << string << "\"\nEl valor convertido es " << x << "\nEl resto de la cadena original es \"" << remainderPtr << "\"\nEl valor convertido más 567 es " << x + 567 << endl; }//Fin de main()

/* El siguiente programa: STRTOUL.CPP, ilustra el uso de la función strtoul() */ #include <iostream.h> //Para cout y cin #include <stdlib.h> //Para strtol() void main(void) { unsigned long x; char *string = "1234567abc", *remainderPtr; x = strtoul( string, &remainderPtr, 0 ); cout << "La cadena original es \"" << string << "\"\nEl valor convertido es " << x << "\nEl resto de la cadena original es \"" << remainderPtr << "\"\nEl valor convertido menos 567 es " << x - 567 << endl; }//Fin de main()

/* El siguiente programa: CONVDATO.CPP, ilustra el uso de algunas funciones y macros utilizadas en C++ para la conversión de datos: atoi(): sintaxis: int atoi(const char * str); donde: const char * str es la cadena a convertir. itoa(): sintaxis: char *itoa(int valor, char *cadena, int base); donde: int valor es el valor a convertir. char *cadena la cadena resultante. int base base para la conversión (2 a 36). toascii(): sintaxis: int toascii(int ch); donde: int ch es el caracter a convertir . tolower(): sintaxis: int tolower(int ch); donde: int ch caracter a convertir. */ #include <iostream.h> //Para cout #include <stdlib.h> //Para las funciones atoi(), itoa) #include <ctype.h> //Para la macro toascii() y la función tolower() void main(void) { int valor; char *cadena = "8726"; valor = atoi(cadena); cout << "EJEMPLO QUE MUESTRA EL USO DE LA FUNCION atoi()" << endl << endl; cout << "El valor entero de cadena es: " << valor << endl;

cout << "La valor de la cadena es : " << cadena << endl << endl; valor = 8377; int base = 10; char caracteres[20]; itoa(valor, caracteres, base); cout << "EJEMPLO QUE MUESTRA EL USO DE LA FUNCION itoa()" << endl << endl; cout << "El valor entero es : " << valor << endl; cout << "La valor de la cadena es : " << caracteres << endl; cout << "La base utilizada fue : " << base << endl << endl ; # char ch = 'A'; int convch; convch = toascii(ch); cout << "EJEMPLO QUE MUESTRA EL USO DE LA MACRO toascii()" << endl << endl ; cout << "El caracter " << '\"' << ch << '\"'<< " convertido a formato ascii es: " << convch << endl << endl ; ch = 'M'; convch = tolower(ch); cout << "EJEMPLO QUE MUESTRA EL USO DE LA FUNCION tolower()" << endl << endl; cout << "El caracter " << ch << " convertido a minúscula es " << char(convch) << endl << endl; } //Fin de main()

FUNCIONES DE BUSQUEDA DE LA BIBLIOTECA DE MANEJO DE CADENAS Esta sección presenta las funciones de la biblioteca de manejo de cadenas que se utilizan para buscar caracteres y otras cadenas dentro de cadenas. En la tabla 6.8 se resumen dichas funciones. Observe que las funciones strcspn() y strspn() especifica a size_t como tipo de devolución. size_t es un tipo definido por el estándar como el tipo entero del valor devuelto por el operador sizeof()

Tabla 6.8. Funciones de búsqueda de la biblioteca de manejo de cadenas Prototipo Descripción

char *strchr( const char *s, int c ) Localiza la primera ocurrencia del carácter c en la cadena s. Si encuentra a c, devuelve un apuntador a c en s. En caso contrario, se devuelve el apuntador NULL.

size_t strcspn( const char *s1, const char *s2 ) Determina y devuelve la longitud del segmento inicial de la cadena s1 que consiste de caracteres que no están contenidos en la cadena s2.

size_t strspn( const char *s1, const char *s2 ) Determina y devuelve la longitud del segmento inicial de la cadena s1 que consiste solamente de caracteres que están contenidos en la cadena s2.

char *strpbrk( const char *s1, const char *s2 ) Localiza la primera ocurrencia en la cadena s1 de cualquier carácter que esté en la cadena s2. Si encuentra un carácter de la cadena s2, devuelve un apuntador al carácter en la cadena s1. En caso contrario, devuelve un apuntador a NULL.

char *strrch( const char *s, int c ) Localiza la última ocurrencia de c en la cadena s. Si encuentra a c, devuelve un apuntador a c en la cadena s. En caso contrario, devuelve un apuntador NULL.

char *strstr( const char *s1, const char *s2 ) Localiza la primera ocurrencia en la cadena s1 de la cadena s2. Si encuentra la cadena, devuelve un apuntador a la cadena en s1. En caso contrario, devuelve el apuntador NULL.

Ejemplo 6.36

La función strchr() busca la primera ocurrencia de un carácter en una cadena. Si encuentra al carácter, devuelve un apuntador al carácter en la cadena, y en caso contrario devuelve NULL. El programa STRCHR.CPP, utiliza a strchr() para buscar las primeras ocurrencia de ‘a’ y ‘z’ en la cadena “¡Hola a todos!”.

/* El siguiente programa: STRCHR.CPP, ilustra el uso de la función strchr() */ #include <iostream.h> //Para cout y cin #include <string.h> //Para strchr() void main(void) { char *string = "¡Hola a todos!"; char caracter1 = 'a', caracter2 = 'z'; if( strchr( string, caracter1 ) != NULL ) cout << '\'' << caracter1 << "' se encontro en \"" << string << "\".\n"; else

Ejemplo 6.37

La función strcspn() del programa STRCSPN.CPP, determina la longitud de la parte inicial de la cadena que está en el primer argumento que no contiene ningún carácter de la cadena que está en el segundo argumento. La función devuelve la longitud del segmento.

Ejemplo 6.38

La función strpbrk() busca la primera ocurrencia en su primer argumento de cadena de un carácter que esté en su segundo argumento de cadena. Si encuentra un carácter del segundo argumento, devuelve un apuntador al carácter en el primer argumento, y en caso contrario devuelve NULL. El programa STRPBRK.CPP, localiza la primera ocurrencia en string1 de cualquier carácter que está en string2.

cout << '\'' << caracter1 << "' no se encontró en \"" << string << "\".\n"; if( strchr( string, caracter2 ) != NULL ) cout << '\'' << caracter2 << "' se encontro en \"" << string << "\".\n"; else cout << '\'' << caracter2 << "' no se encontró en \"" << string << "\".\n"; }//Fin de main()

/* El siguiente programa: STRCSPN.CPP, ilustra el uso de la función strcspn() */ #include <iostream.h> //Para cout y cin #include <string.h> //Para strcspn() void main(void) { char *string1 = "El valor es 3.14159"; char *string2 = "1234567890"; cout << "string1 = " << string1 << "\nstring2 = " << string2 << "\n\nLa longitud del segmento inicial de string1" << "\nque no contiene caracteres de string2 es = " << strcspn( string1, string2 ) << endl; }//Fin de main()

/* El siguiente programa: STRPBRK.CPP , ilustra el uso de la función strpbrk() */ #include <iostream.h> //Para cout y cin #include <string.h> //Para strpbrk() void main(void) { char *string1 = "¡Hola a todos!"; char *string2 = "texto"; cout << "De los caracteres en \"" << string2 << "\"\n'" << *strpbrk( string1, string2 ) << '\'' << " es el primer carácter que aparece en \n\"" << string1 << '\"' << endl; }//Fin de main()

Ejemplo 6.39

La función strrchr() busca la última ocurrencia del carácter especificado en una cadena. Si encuentra el carácter, devuelve un apuntador al carácter en la cadena, y en caso contrario devuelve 0. El programa STRCHR.CPP, busca la última ocurrencia del carácter ‘z’ en la cadena “Un zoológico tiene muchos animales incluyendo zorrillos”.

Ejemplo 6.40

La función strspn() utilizada en el programa STRSPN.CPP, determina la longitud de la parte inicial de la cadena que está en su primer argumento, que sólo contiene caracteres de la cadena que está en su segundo argumento. La función devuelve la longitud del segmento.

Ejemplo 6.41

La función strstr() busca la primera ocurrencia de su segundo argumento de cadena en su primer argumento de cadena. Si la segunda cadena se encuentra en la primera cadena, se

/* El siguiente programa: STRRCHR.CPP, ilustra el uso de la función strrchr() */ #include <iostream.h> //Para cout y cin #include <string.h> //Para strrchr() void main(void) { char *string1 = "Un zoológico tiene muchos animales incluyendo zorrillos"; int c = 'z'; cout << "El resto de string1 que empieza con la \n" << "última ocurrencia del caracter '" << (char) c << "' es: \"" << strrchr( string1, c ) << '\"' << endl; }//Fin de main()

/* El siguiente programa: STRSPN.CPP, ilustra el uso de la función strspn() */ #include <iostream.h> //Para cout y cin #include <string.h> //Para strspn() void main(void) { char *string1 = "El valor es 3.14159"; char *string2 = "aerolsEv "; cout << "string1 = " << string1 << "\nstring2 = " << string2 << "\n\nLa longitud del segmento inicial de string1\n" << "que contiene sólo caracteres de string2 es = " << strspn( string1, string2 ) << endl; }//Fin de main()

devuelve un apuntador hacia la localidad de la cadena en el primer argumento. El programa STRSTR.CPP, utiliza strstr() para encontrar la cadena “def” en la cadena “abcdefabcdef”

FUNCIONES DE MEMORIA DE LA BIBLIOTECA DE MANEJO DE CADENAS Las funciones de biblioteca de manejo de cadenas que se presentan en esta sección facilitan la manipulación, comparación y búsqueda de bloques de memoria. Las funciones tratan los bloques de memoria como si fueran arreglos de caracteres. Estas funciones pueden manipular cualquier bloque de datos. La tabla 6.9 resume las funciones de memoria de la biblioteca de manejo de cadenas. En la discusión de las funciones objeto se refiere a un bloque de datos.

Tabla 6.9. Las funciones de memoria de la biblioteca de manejo de cadenas Prototipo Descripción

void *memcpy( void *s1, const void *s2, size_t n) Copia n caracteres desde el objeto al que apunta s2 hacia el objeto al que apunta s1. Se devuelve el apuntador al objeto resultante.

void *memmove( void *s1, const void *s2, size_t n) Copia n caracteres del objeto al que apunta s2 hacia el objeto al que apunta s1. La copia se realiza como si los caracteres se copiaran primero desde el objeto al que apunta s2 hacia un arreglo temporal, y luego desde el arreglo temporal hacia el objeto al que apunta s1. Se devuelve un apuntador al objeto resultante.

int memcmp( const void *s1, const void *s2, size_t n) Compara los primeros n caracteres de los objetos a los que apunta s1 y s2. Si s1 es igual, menor o mayor que s2, la función devuelve 0, menor que 0 o mayor que 0.

void *memchr( const void *s, int c, size_t n ) Localiza la primera ocurrencia de c (convertido a unsigned char) en los primeros n caracteres del objeto al que apunta s. Si encuentra a c, devuelve un apuntador a c en el objeto. En caso contrario devuelve 0.

void *memset( void *s, int c, size_t n) Copia c (convertido a unsigned char) a los primeros n caracteres del objeto al que apunta s. Se devuelve un apuntador al resultado.

/* El siguiente programa: STRSTR.CPP, ilustra el uso de la función strstr() */ #include <iostream.h> //Para cout y cin #include <string.h> //Para strstr() void main(void) { char *string1 = "abcdefabcdef"; char *string2 = "def"; cout << "string1 = " << string1 << "\nstring2 = " << string2 << "\n\nEl resto de string1 que empieza con la \n" << "primera ocurrencia de string2 es: " << strstr( string1, string2 ) << endl; }//Fin de main()

Los parámetros de apuntador para estas funciones están declarados como void *. En otra lección veremos que un apuntador hacia cualquier tipo de datos se puede asignar directamente a un apuntador de tipo void *. Por esta razón, estas funciones pueden recibir apuntadores hacia cualquier tipo de datos. Puesto que un apuntador void * no puede desreferenciarse, cada función recibe un argumento de tamaño que especifica el número de caracteres (bytes) que la función procesará. Para efectos de simplicidad, los ejemplos de esta sección manipulan arreglos de caracteres (bloques de caracteres) Ejemplo 6.42

La función memcpy() copia un número especificado de caracteres desde el objeto al que apunta su segundo argumento hacia el objeto al que apunta su primer argumento. Dicha función puede recibir un apuntador a cualquier tipo de objeto. Si los dos objetos se sobreponen en memoria, es decir, si ambos son parte del mismo objeto, el resultado de esta función queda indefinido. El programa MEMCPY.CPP, utiliza memcpy() para copiar la cadena que está en el arreglo s2 al arreglo s1.

Ejemplo 6.43

La función memmove(), al igual que memcpy(), copia un número especificado de bytes desde el objeto al que apunta su segundo argumento hacia el objeto al que apunta su primer argumento. La copia se realiza como si los bytes se copiaran desde el segundo argumento hacia un arreglo de caracteres temporal, y luego se copian de dicho arreglo hacia el primer argumento. Esto permite que caracteres de una parte de una cadena se copien a otra parte de la misma. El siguiente programa: MEMMOVE.CPP, utiliza memmove() para copiar los últimos 11 bytes del arreglo x hacia los 11 primeros bytes de dicho arreglo.

Ejemplo 6.44

/* El siguiente programa: MEMCPY.CPP, ilustra el uso de la función memcpy() */ #include <iostream.h> //Para cout y cin #include <string.h> //Para memcpy() void main(void) { char s1[17], s2 [] = "Copia esta cadena"; memcpy( s1, s2, 18 ); cout << "Después de que s2 se copia a s1 con memcpy,\n" << "s1 contiene \"" << s1 << '\"' << endl; }//Fin de main()

/* El siguiente programa: MEMMOVE.CPP, ilustra el uso de la función memmove() */ #include <iostream.h> //Para cout y cin #include <string.h> //Para memmove() vvoid main(void) { char x[] = "Hogar Dulce Hogar"; cout << "La cadena en el arreglo x antes de memmove es: " << x; cout << "\nLa cadena en el arreglo x después de memmove() es: " << ( char * ) memmove( x, &x[6], 11 ) << endl; }//Fin de main()

La función memcmp() del programa MEMCMP.CPP, compara el número especificado de caracteres de su primer argumento con los caracteres correspondientes de su segundo argumento. La función devuelve un valor mayor que 0 si el primer argumento es mayor que el segundo argumento, devuelve 0 si los argumentos son iguales, y devuelve un valor menor que 0 si el primer argumento es menor que el segundo argumento.

Ejemplo 6.45

La función memchr () busca la primera ocurrencia de un byte, representado como unsigned char, en el número especificado de bytes de un objeto. Si se encuentra el byte, se devuelve un apuntador al byte en el objeto, y en caso contrario se devuelve NULL. El programa MEMCHR.CPP, busca el carácter (byte) ‘d’ en la cadena “Esta es una cadena”.

Ejemplo 6.46

La función memset() copia el valor del byte que está en su segundo argumento hacia el número especificado de byte del objeto al que apunta su primer argumento. El programa MEMSET.CPP, utiliza memset() para copia ‘b’ hacia los 7 primeros bytes de string1.

/* El siguiente programa: MEMCMP.CPP, ilustra el uso de la función memcmp() */ #include <iostream.h> //Para cout y cin #include <iomanip.h> //Para setw() #include <string.h> //Para memcmp() void main(void) { char s1[] = "ABCDEFG", s2[] = "ABCDXYZ"; cout << "s1 = " << s1 << "\ns2 = " << s2 << endl << "\nmemcmp( s1, s2, 4 ) = " << setw( 3 ) << memcmp( s1, s2, 4 ) << "\nmemcmp( s1, s2, 7 ) = " << setw( 3 ) << memcmp( s1, s2, 7 ) << "\nmemcmp( s2, s1, 7 ) = " << setw( 3 ) << memcmp( s2, s1, 7 ) << endl; }//Fin de main()

/* El siguiente programa: MEMCHR.CPP, ilustra el uso de la función memchr() */ #include <iostream.h> //Para cout y cin #include <string.h> //Para memchr() void main(void) { char *s = "Esta es una cadena"; cout << "El resto de s después de que el caracter 'd' " << "se ha encontrado es \"" << (char *) memchr( s, 'd', 19 ) << '\"' << endl; }//Fin de main()

OTRAS FUNCIONES DE LA BIBLIOTECA DE MANEJO DE CADENAS

La función restante de la biblioteca de manejo de cadenas es strerror() La tabla 6.10 resume la función strerror()

Tabla 6.10. Otra función para el manejo de cadenas de la bibllioteca de manejo de cadenas

Prototipo Descripción char *strerror( int numeroError ) Convierte numeroError a una cadena de texto

completa en forma dependiente del sistema. Se devuelve un apuntador a la cadena.

Ejemplo 6.47

La función strerror() toma un número de error y crea una cadena de mensaje de error. Se devuelve un apuntador hacia la cadena. El programa STRERROR.CPP, muestra el uso de strerror()

FUNCIONES DE CADE NA Las funciones de cadena estándar en C++ se usan para manejar cadenas. El procesamiento de cadenas se utiliza en muchos programas de aplicación, así que estas funciones suelen ser muy útiles. Las funciones mostradas en la tabla 6.11 proporcionan algunas de las rutinas de manejo de cadenas más comunes, en otra lección se verán más funciones de cadena y con mayor detalle.

/* El siguiente programa: MEMSET.CPP, ilustra el uso de la función memset() */ #include <iostream.h> //Para cout y cin #include <string.h> //Para memset() void main(void) { char string1[15] = "BBBBBBBBBBBBBB"; cout << "string1 = " << string1 << endl; cout << "string1 después de memset = " << (char *) memset( string1, 'b', 7 ) << endl; }//Fin de main()

/* El siguiente programa: STRERROR .CPP, ilustra el uso de la función strerror() */ #include <iostream.h> //Para cout y cin #include <string.h> //Para strerror() void main(void) { cout << strerror( 2 ) << endl; }//Fin de main()

Una función de cadena de interés especial es la función strcpy() Esta función se debe usar cuando se asignan cadenas a variables de cadenas. Como un ejemplo, considere la siguiente definición de variable de cadena:

char nombre[31] = “\0”;

Ahora suponga que desea asignar un valor de cadena a la variable de cadena nombre. Los siguientes enunciados no se compilarán:

nombre[] = “Brenda”; o nombre = “Brenda”;

La razón por la que estas asignaciones no trabajan es que la variable de cadena nombre es realmente una dirección de memoria. De esta manera, se intenta asignar un valor de cadena de carácter a un valor de dirección. Esto se llama error de tipo de datos y no se compila. Para asignar datos de cadena, deberá usar la función strcpy() para copiar el valor de cadena dentro de un área de almacenamiento de cadena como esta:

strcpy(nombre,”Brenda”);

Para compilar este enunciado deberá incluir en el programa el archivo de encabezado string.h.

Tabla 6.11. Algunas funciones de cadena disponibles en C++

Nombre de la Archivo de función cabecera Operación strcat() string.h Adiciona una cadena a otra. strcmp() string.h Compara dos cadenas. strlen() string.h Regresa la longitud de una cadena strcpy () string.h Copia una cadena.

Ejemplo 6.48:

La función de comparación de cadena, strcmp(), debe usarse cuando se comparan cadenas más que operadores relacionales booleanos, porque los operadores relacionales booleanos no son confiables cuando se comparan cadenas. El siguiente programa: CADENA.CPP, ilustra el uso de la función strcmp()

El programa anterior primero usa la función strcmp() para comparar la cadena “Janet” con la cadena “Janet”. La segunda línea del programa también compara “Janet” con “Janet” usando el operador

/* El siguiente programa: CADENA.CPP, ilustra como funciona la función strcmp() */ #include <iostream.h> // Para cout #include <string.h> // Para strcmp() void main(void) { cout << strcmp("Janet", "Janet") << endl; cout << ("Janet" == "Janet") << endl; cout << strcmp("JANET", "Janet") << endl; cout << strcmp("Janet", "JANET") << endl; } // Final de main()



relacional ==. Si observa la operación de strcmp(), encontrará un cero si las dos cadenas son iguales; un valor negativo si el primer argumento de la cadena es menor que el segundo argumento de cadena y un valor positivo si la primera cadena es más grande que la segunda cadena. ¿Cómo se comparan las dos cadenas? Bien, recuerde que cada carácter en la cadena se representa como un valor ASCII. La función strcmp() en realidad resta el valor individual ASCII de un carácter a la vez de izquierda a derecha hasta que ocurra la condición de desigualdad o se acaben los caracteres. Si todos los caracteres en las dos cadenas son los mismos, el resultado de restar carácter por carácter es cero. Si un carácter determinado en la primera cadena es más grande que el correspondiente en la segunda cadena, el resultado de la resta es positivo, si un carácter determinado en la primera cadena es más pequeño que el correspondiente en la segunda cadena, el resultado de la resta es negativo. Esta es la salida que produce el programa:

0 0

-32 32

Observe que la salida del primer enunciado es 0, lo cual indica en forma correcta que de acuerdo con la función strcmp(), las dos cadenas son iguales. Sin embargo, la salida del segundo enunciado, que usa el operador relacional booleano ==, es también 0. Como ya sabe, significa falso, indicando erróneamente por medio de esto que las dos cadenas no son iguales. En el tercer enunciado, la función strcmp() genera un valor negativo de –32, correctamente indica que “JANET” es menor que “Janet”, de acuerdo al código ASCII. Finalmente, en el último enunciado, la función strcmp() genera un valor positivo de 32, indicación correcta de que “Janet” es más grande que “JANET”.

FUNCIONES MATEMÁTICAS Las funciones matemáticas realizan una operación matemática. Como resultado, estas funciones necesitan un argumento numérico y regresa un resultado numérico; por eso, algunas veces son llamadas funciones numéricas. Algunas funciones matemáticas estándar se muestran en la tabla 6.12. La mayoría de estas operaciones le parecerán familiares por sus conocimientos de matemáticas. Cuando use cualquiera de estas funciones en C++, deberá asegurarse que el argumento es la clase de datos correcta como la especificada en la definición de la función. Además, cualquier variable que se asigne a la función deberá definirse con la misma clase de datos que el resultado de la función.

Tabla 6.12. Algunas funciones matemáticas estándar en C++

Nombre Archivo de de la función cabecera Operación abs() math.h Regresa el valor absoluto del argumento (entero) acos() math.h Regresa el arco coseno del argumento (radianes) asin() math.h Regresa el arco seno del argumento (radianes) atan() math.h Regresa el arco tangente del argumento (radianes). cos() math.h Regresa el coseno del argumento (radianes). hypot() math.h Regresa la hipotenusa de un triángulo rectángulo. log() math.h Regresa el logaritmo natural del argumento. log10() math.h Regresa el logaritmo base 10 del argumento. pow() math.h Regresa x elevado a la potencia y.



pow10() math.h Regresa 10 elevado a la potencia y. rand() stdlib.h Genera un número aleatorio entre 0 y 215 – 1. srand() stdlib.h Inicializa el generador de un número aleatorio

que debe usarse antes que rand(). sin() math.h Regresa el seno del argumento (radianes). sqrt() math.h Regresa la raíz cuadrada del argumento. tan() math.h Regresa la tangente del argumento (radianes). ceil() math.h Redondea al siguiente valor entero mayor. Nota: Hasta esta lección no se ha visto el manejo de funciones, el ejemplo a continuación,

FUNMAT.CPP, sirva de referencia de como se usan las funciones anteriores. Para mayor información consulte el manual o bien las ayudas de su compilador. En la lección 9 se enseñará formalmente el uso de la estructura de control for.

Ejemplo 6.49

El siguiente programa: FUNMAT.CPP, ilustra el uso de las funciones matemáticas.

/* El siguiente programa: FUNMAT.CPP, ilustra el uso de las funciones matematicas: abs() sintaxis: int abs(int expresión); labs() sintaxis: long int abs(long int expresión); fabs() sintaxis: float fabs(float expresión); abs() sintaxis: complex abs(complex numeroComplejo); nota: Para el manejo de long double existe la función fabsl() acos() sintaxis: double acos(double expresión); El valor regresado se encuentra entre: [0,PI. El ángulo en radianes debe estar entre: [-1.0, 1.0] asin() sintaxis: double asin(double expresión); El valor regresado se encuentre entre: [-PI/2, PI/2] El ángulo en radianes debe estar entre: [-1.0, 1.0] atan() sintaxis: double atan(double expresión); El valor regresado se encuentre entre: [-PI/2, PI/2] nota: Para el manejo de long double existen las funciones: acosl(), asinl(), atanl(). En este último caso también existen las variantes atan2() y atan2l() los cuales devuelven el arcotangente de y/x. ceil() sintaxis: double ceil(double valor); nota: Para el manejo de long double existe la función ciell(). sin() sintaxis: double sin(double expresión); cos() sintaxis: double cos(double expresión); El valor regresado se encuentre entre: [-1.0, 1.0] tan() sintaxis: double tan(double expresión); nota: Para el manejo de long double existen las funciones: sinl(), cosl() y tanl(). cosh() sintaxis: double cosh(double expresión); sinh() sintaxis: double sinh(double expresión); tanh() sintaxis: double tanh(double expresión); nota: Para el manejo de long double existen las funciones: sinhl(), coshl() y tanhl().

div() sintaxis: div_t div(int numerador, int denominador); donde: struct div_t {

int quot; int rem; } div_t; fmod() sintaxis: double fmod(double x, double y); modf() sintaxis: double modf(double valor, double *parteEntera);

nota: Para el manejo de long int existe la funcion ldiv() Para el manejo de long double existen las funciónes fmodl(), modfl() exp() sintaxis: double exp(double x); ldexp() sintaxis: double ldexp(double valor, int exponente); significado: x * 2 elevado a un exponente. pow() sintaxis: double pow(double valor, double exponente); significado: x elevado a la n. pow10() sintaxis: double pow10(int exponente); significado: 10 elevado a la x. frexp() sintaxis: double frexp(double valor, int *exponente); nota: Para el manejo de long double existen las funciones: expl(), ldexpl(), powl(), pow10l(), frexp(). log() sintaxis: double log(double valor); log10() sintaxis: double log10(double valor); nota: Para el manejo de long double existen las funciones: logl(), log10l() max() sintaxis: #define max(x,y) (((x) > (y)) ? (x) : (y)) min() sintaxis: #define min(x,y) (((x) < (y)) ? (x) : (y)) rand() sintaxis: int rand(void); random() sintaxis: int random(int ceiling); randomize() sintaxis: void randomize(void); srand() sintaxis: void srand(unsigned semilla); sqrt() sintaxis: double sqrt(double valor); nota: Para el manejo de long double exite la función sqrtl() */ #include <iostream.h> //Para cout #include <math.h> //Para las funciones matemáticas #include <errno.h> //Para el manejo de la variable global errno #include <stdlib.h> //Para la función div() y las macros max() y min() #include <conio.h> //Para clrscr() #include <complex.h> //Para manejar números complejos void main(void) { cout << "LOS EJEMPLOS SIGUIENTES MUESTRAN EL USO DE LAS FUNCIONES:" << endl; cout << "abs(), labs(), fabs()" << endl << endl; //Utilizaremos la función abs() cout << "Valor absoluto de un entero utilizando la función abs()" << endl; cout << "El valor absoluto de 5 es : " << abs(5)<< endl; cout << "El valor absoluto de 0 es : " << abs(0)<< endl; cout << "El valor absoluto de -5 es: " << abs(-5)<< endl << endl; cout << "Para continuar oprima ENTER: "; cin.get();

//Utilizaremos la función labs() cout << endl; cout << "El valor absoluto de un entero largo utilizando la función labs()" << endl; cout << "El valor absoluto de 32769 es : " << labs(32769)<< endl; cout << "El valor absoluto de -32769 es: " << labs(-32769)<< endl << endl ; cout << "Para continuar oprima ENTER: "; cin.get(); //Utiliza remos la función fabs() cout << endl; cout << "El valor absoluto de un flotante utilizando fabs()" << endl; for(float valor = -1.0; valor <= 1.0; valor += 0.5) cout << "El valor absoluto de " << valor << " = " << fabs(valor) << endl; cout << endl; cout << "Para continuar oprima ENTER: "; cin.get(); cout << endl; cout << "El valor absoluto de un complejo utilizando la función abs()" << endl; complex numeroComplejo(10.0, 5.0); cout << "El valor absoluto del numero complejo " << numeroComplejo << " es " << abs(numeroComplejo) << endl << endl; cout << "Para continuar oprima ENTER: "; cin.get(); clrscr(); cout << "LOS EJEMPLOS SIGUIENTES MUESTRAN EL USO DE LAS FUNCIONES:" << endl; cout << "arcocoseno(), arcoseno() y arcotangente()" << endl << endl; //Utilizaremos la función acos() for(double radianes = -0.5; radianes <= 0.5; radianes += 0.2) cout << "arcocoseno(" << radianes << ") = " << acos(radianes) << endl; cout << endl; cout << "Para continuar oprima ENTER: "; cin.get();

//Utilizaremos la función asin() cout << endl; for(double radianes = -0.5; radianes <= 0.5; radianes += 0.2) cout << "arcoseno(" << radianes << ") = " << asin(radianes) << endl; cout << endl; cout << "Para continuar oprima ENTER: "; cin.get(); //Utilizaremos la función atan() cout << endl; for(double radianes = -0.5; radianes <= 0.5; radianes += 0.2) cout << "arcotangente(" << radianes << ") = " << atan(radianes) << endl; cout << endl; cout << "Para continuar oprima ENTER: "; cin.get(); clrscr(); cout << "LOS EJEMPLOS SIGUIENTES MUESTRAN EL USO DE LA FUNCION ceil()" << endl << endl; //Utilizaremos la función ceil() cout << "1.9 redondeado al entero mayor es: " << ceil(1.9) << endl; cout << "2.1 redondeado al entero mayor es: " << ceil(2.1) << endl << endl; cout << "Para continuar oprima ENTER: "; cin.get();

clrscr(); cout << "LOS EJEMPLO SIGUIENTES MUESTRAN EL USO DE LAS FUNCIONES:" << endl; cout << "sin(), cos() y tan()" << endl << endl; //Utilizaremos la función sin() for(double radianes = 0.0; radianes < 3.1; radianes += 0.5) cout << "seno(" << radianes << ") = " << sin(radianes) << endl; cout << endl; cout << "Para continuar oprima ENTER: "; cin.get(); //Utilizaremos la función cos() cout << endl; double pi = 3.14159265; cout.setf(ios::fixed); cout.precision(6); cout << "El coseno(pi/2) = " << cos(pi/2.0) << endl; cout << "El coseno(pi) = " << cos(pi) << endl << endl; cout << "Para continuar oprima ENTER: "; cin.get(); //Utilizaremos la función tan() cout << endl; cout << "La tangente(pi) = " << tan(pi) << endl; cout << "La tangente(pi/4) = " << tan(pi/4) << endl << endl; cout << "Para continuar oprima ENTER: "; cin.get(); clrscr(); cout << "LOS EJEMPLOS SIGUIENTES MUESTRAN EL USO DE LAS FUNCIONES:" << endl; cout << "Coseno hiperbólico, seno hiperbólico y tangente hiperbólico" << endl << endl; //Utilizaremos la función cosh() for(double radianes = -0.5; radianes <= 0.5; radianes += 0.2) cout << "cosenohiperbólico(" << radianes << ") = " << cosh(radianes) << endl; cout << endl; cout << "Para continuar oprima ENTER: "; cin.get(); //Utilizaremos la función sinh() cout << endl; double resultado; for(double radianes = 0.0; radianes < 3.1; radianes += 0.5) if(((resultado = sinh(radianes)) == HUGE_VAL) && (errno == ERANGE)) cout << "Error por desbordamiento)" << endl; else cout << "senohiperbólico(" << radianes << ") = " << sinh(radianes) << endl; cout << endl; cout << "Para continuar oprima ENTER: "; cin.get(); //Utilizaremos la función tanh() cout << endl; for(double radianes = -0.5; radianes <= 0.5; radianes += 0.2) cout << "tangentehiperbólico(" << radianes << ") = " << tanh(radianes) << endl; cout << endl; cout << "Para continuar oprima ENTER: "; cin.get();

clrscr(); cout << "EL EJEMPLO SIGUIENTE MUESTRA EL USO DE LAS FUNCIONES:" << endl; cout << "div(), fmod(), modf()" << endl << endl; //Utilizaremos la función div() div_t respuesta; respuesta = div(11,3); cout <<"En este ejemplo se muestra el uso de la función div()" << endl; cout << "El valor del cociente de 11/3 = " << respuesta.quot << endl; cout << "El valor del residuo de 11/3 = " << respuesta.rem << endl << endl; cout << "Para continuar oprima ENTER: "; cin.get(); //Utilizaremos la función fmod() cout << endl; cout << "En este ejemplo se muestra el uso de la función fmod()" << endl; cout << "El residuo de 10.0/3.0 = " << fmod(10.0, 3.0) << endl << endl; cout << "Para continuar oprima ENTER: "; cin.get(); //Utilizaremos la función modf() cout << endl; cout << "En este ejemplo se muestra el uso de la función modf()" << endl; double valor1 = 1.2345; double parteEntera; double parteFraccionaria; parteFraccionaria = modf(valor1, &parteEntera); cout << "El valor fraccionario de 1.2345 es = " << parteFraccionaria << endl; cout << "El valor entero de 1.2345 es = " << parteEntera << endl << endl; cout << "Para continuar oprima ENTER: "; cin.get(); clrscr(); cout << "LOS EJEMPLOS SIGUIENTES MUESTRAN EL USO DE LAS FUNCIONES: " << endl; cout << "exp(), x * 2 elevado a exponente, x elevado a n, 10 elevado a x" << endl; cout << "frexp() " << endl << endl; //Utilizaremos la función exp() for(double valor = 0.0; valor <= 1.0; valor += 0.2) cout << "exp(" << valor << ") = " << exp(valor) << endl; cout << endl; cout << "Para continuar oprima ENTER: "; cin.get(); //Utilizaremos la función ldexp() cout << endl; cout << "3 * 2 elevado a 4 = " << ldexp(3.0, 4) << endl << endl; cout << "Para continuar oprima ENTER: "; cin.get(); //Utilizaremos la función pow() cout << endl; for(int exponente = -2; exponente <= 2; exponente++) cout << "10 elevado a la " << exponente << " = " << pow(10.0, exponente) << endl; cout << endl; cout << "Para continuar oprima ENTER: "; cin.get();

//Utilizaremos la función pow10() cout << endl; for(int exponente = -2; exponente <= 2; exponente++) cout << "10 elevado a la " << exponente << " = " << pow10(exponente) << endl; cout << endl; cout << "Para continuar oprima ENTER: "; cin.get(); // Utilizaremos la función frexp() cout << endl; double valor = 1.2345; double mantisa; int exponente; mantisa = frexp(valor, &exponente); cout << "La cantidad inicial es = " << mantisa * pow(2.0, 1.0 * exponente) << endl; cout << "El valor de la mantisa es = " << mantisa << endl; cout << "El valor del exponente es = " << exponente << endl << endl; cout << "Para continuar oprima ENTER: "; cin.get(); clrscr(); cout << "EL EJEMPLO SIGUIENTE MUESTRA EL USO DE LAS FUNCIONES:" << endl; cout << "log(), log10()" << endl << endl; //Utilizaremos la función log() cout << "El logaritmo natural de 256.0 = " << log(256.0) << endl << endl; cout << "Para continuar oprima ENTER: "; cin.get(); //Utilizaremos la función log10(x) cout << endl; cout << "El logaritmo neperiano de 100 = " << log10(100) << endl; cout << "El logaritmo neperiano de 10000 = " << log10(10000) << endl << endl; cout << "Para continuar oprima ENTER: "; cin.get(); clrscr(); cout <<"EL SIGUIENTE EJEMPLO MUESTRA EL USO DE LAS MACR OS: max(), min()" << endl << endl;

//Utilizaremos la macro max() cout << "El valor máximo de 10.0 y 25.0 es : " << max(10.0, 25.0) << endl << endl; cout << "Para continuar oprima ENTER: "; cin.get(); //Utilizaremos la macro min() cout << endl; cout << "El valor mínimo de 10.0 y 25.0 es : " << min(10.0, 25.0) << endl << endl; cout << "Para continuar oprima ENTER: "; cin.get(); clrscr(); cout << "EL SIGUIENTE EJEMPLO MUESTRA EL USO DE LAS FUNCIONES: rand() y random();" << endl;

cout << "randomize() y srand()" << endl << endl; //Utilizaremos la función rand() cout << "Valores generados por la función rand()" << endl;

for(int i = 0; i < 10; i++) cout << rand() << ' '; cout << endl << endl; cout << "Para continuar oprima ENTER: "; cin.get();

//Utilizaremos la función random() cout << endl; cout << "Valores generados por la función random()" << endl; for(int i = 0; i < 10; i++) cout << random(100) << ' '; cout << endl << endl; cout << "Para continuar oprima ENTER: "; cin.get(); //Utilizaremos la función random() para generar número aleatorios entre // [-5, +5] cout << endl; cout << "Valores generados por la función random() entre [-5,+5]" << endl; for(int i = 0; i < 10; i++) cout << (random(10)-5) << ' '; cout << endl << endl; cout << "Para continuar oprima ENTER: "; cin.get(); //Utilizaremos la función random() para generar número aleatorios entre // [0.0, 1.0] cout << endl; cout << "Valores generados por la función random() entre [0.0,1.0]" << endl; cout.precision(1); for(int i = 0; i < 10; i++) cout << (random(10)/10.) << ' '; cout << endl << endl; cout << "Para continuar oprima ENTER: "; cin.get(); //Utilizaremos las funciones srand() y randomize()para generar número aleatorios //a partir de una semilla. cout << endl; cout.precision(6); cout << "Valores aleatorios a partir de la semilla dada por la función srand(100)" << endl; srand(100); for(int i = 0; i < 5; i++) cout << rand() << ' '; cout << endl << endl; cout << "Para continuar oprima ENTER: "; cin.get(); cout << endl; cout << "Mismos valores aleatorios generados por la misma semilla srand(100)" << endl; srand(100); for(int i = 0; i < 5; i++) cout << rand() << ' '; cout << endl << endl; cout << "Para continuar oprima ENTER: "; cin.get();

SOLUCION DE PROBLEMAS EN ACCION: Comunicación de datos PROBLEMA

En el campo de la comunicación de datos, los datos binarios de la computadora digital se convierten en datos de ondas senoidales analógicos para la transmisión a grandes distancias por medio de la red telefónica. Esta idea se muestra en la figura 6.2. En ésta, un 1 binario se representa con una onda senoidal de una amplitud más grande y un 0 binario se representa por otra onda senoidal de una amplitud más baja. Esto se llama modulación de la amplitud. Los datos binarios se representan usando una onda senoidal, así el estudio de las comunicaciones de datos a menudo requiere el análisis de una onda senoidal. Dicho análisis tiene el objetivo de encontrar la amplitud en volts, de una onda senoidal en cualquier punto determinado en el tiempo. Esto se llama valor instantáneo de la onda senoidal y se encuentra usando la ecuación:

νν = Vcresta sen(2ππft)

donde:

νν es el voltaje instantáneo en cualquier punto en el tiempo t en la forma de la onda, en volts. Vcresta es la amplitud de cresta de la onda, en volts.

EXAMEN BREVE 16

cout << endl; cout << "5 valores aleatorios diferentes generados por randomize()." << endl; cout << "La semilla se genera a partir del reloj del sistema." << endl; randomize(); for(int i = 0; i < 5; i++) cout << rand() << ' '; cout << endl << endl; cout << "Para continuar oprima ENTER: "; cin.get(); clrscr(); cout << "EL SIGUIENTE EJEMPLO MUESTRA EL USO DE LA FUNCION: sqrt()" << endl;

//Utilizaremos la función sqrt() for(double valor = 0.0; valor < 5.0; valor += 0.5) cout << "La raíz cuadrada de " << valor << " = " << sqrt(valor) << endl; cout << endl; //Observe el mensaje de error: sqrt: DOMAIN error cout << "Manejo de errores en el caso de valores no permisibles sqrt(-1.0)" << endl; cout << "La raíz cuadrada de -1 = " << sqrt(-1.0) << endl << endl; cout << "Para TERMINAR el programa oprima ENTER: "; cin.get(); } //Fin de main()



ππ es la constante 3.14159. f es la frecuencia de la onda en hertz. t es el tiempo, en segundos, para νν.

Escriba un programa para encontrar el valor del voltaje instantáneo de una onda senoidal según se muestra en la figura 6.2. El usuario tiene que escribir el voltaje de la cresta en volts, la frecuencia en kilohertz y el tiempo en milisegundos.


Salida: El programa deberá mostrar el valor de voltaje instantáneo, νν, resultante de la ecuación anterior.

Entrada: El usuario deberá escribir la siguiente información:

• La amplitud de la cresta de la onda, Vcresta, en volts. • La frecuencia de la onda, f, en kilohertz. • El punto en el tiempo, t, en milisegundos para cada voltaje

instantáneo que se calcule. Procesamiento: El programa debe calcular el valor de voltaje instantáneo usando la

ecuación dada. +Vcresta νν νν = Vcresta sen(2ππft) t -Vcresta

Figura 6.2. Una onda senoidal para el problema de comunicaciones de datos.


Usando el enfoque estructurado para solucionar este problema, dividiremos el problema en tres subproblemas que reflejen la definición del problema. Las tres tareas principales que siguen directamente de la definición del problema son:

•• Obtenga las entradas del usuario para Vcresta, f, y t. •• Calcule el voltaje instantáneo. •• Muestre el valor de voltaje instantáneo, νν resultante del cálculo.

Los algoritmos respectivos son: ALGORITMO INICIAL

comunicacionDatos()

INICIO Llama a la función para obtener los datos Vcresta , f, y t del usuario. Llama a la función para calcular el voltaje instantáneo. Llama a la función para mostrar el valor del voltaje instantáneo, νν.

FIN. PRIMER NIVEL DE REFINAMIENTO

obtenerDato()

Inicio Escribir(“Favor de introducir la amplitud de la cresta Vcresta , en volts: ”). Leer (Vcresta). Escribir(Favor de introducir la frecuencia de la onda senoidal, f, en kilohertz: ”). Leer (f). Escribir(“Favor de introducir el tiempo, t, en milisegundos: ”). Leer (t).

Fin. calcularVoltaje()

Inicio Calcular νν = Vcresta sen(2ππ ft).

Fin.

mostrarVoltaje() Inicio

Escribir(“El valor del voltaje instantáneo es: ”, νν). Fin.


La implementación lineal de la serie de algoritmos anteriores es como sigue:

/* El siguiente programa: COMUNICACION.CPP, calcula el valor de voltaje instantáneo, v, resultante de la ecuación planteada en el problema. Salida: El programa debe mostrar el valor de voltaje instantáneo, v, resultante de la ecuación planteada en el problema. Entrada: El usuario debe escribir lo siguiente: La amplitud de la cresta de la onda senoidal, Vcresta, en volts; la frecuencia de la onda, f, en kilohertz; el punto en el tiempo, t, en milisegundos para el cual se calcula el voltaje instantáneo. Procesamiento: El programa debe calcular el valor del voltaje instantáneo. */ #include <iostream.h> // Para cin y cout. #include <math.h> // Para sin() // Enunciados constantes const float PI = 3.14159; void main(void) {

SOLUCION DE PROBLEMAS EN ACCION: Coordenadas polares y rectangulares PROBLEMA

Muchas veces en física y problemas de ingeniería, necesitará convertir coordenadas rectangulares a polares y viceversa. El diagrama de vector en la figura 6.3 resume el proceso de conversión.

Como puede ver, un vector se puede representar en dos formas:

1. Coordenada polar :

M ∠∠ θθ Donde:

M es la magnitud o longitud del vector. θθ es el ángulo que hace el vector con el eje horizontal.

//Definición de variables float vCresta = 0.0; // Voltaje de la cresta en volts. float f = 0.0; // Frecuencia en kilohertz. float t = 0.0; // Tiempo en milisegundos. float v = 0.0; // Voltaje instantáneo en volts. // Muestra el mensaje de descripción del programa. cout << "Este programa, mostrará el valor del voltaje instantáneo\n" "de una señal de CA. Escriba las siguientes tres cantidades: " << endl << endl; cout << "\tVoltaje de la señal de la cresta, vCresta.\n\n" "\tFrecuencia de la señal, f,\n\n" "\tEl punto en el tiempo, t, para el cual\n" "\tse calcula el voltaje. " << endl << endl; // Entradas del usuario cout << "Escriba el voltaje de la señal cresta en volts: vCresta = "; cin >> vCresta; cout << "Escriba la frecuencia de la señal en kilohertz: f = "; cin >> f; cout << "Escriba el tiempo en milisegundos: t = "; cin >> t; // Calculo del valor del voltaje instantáneo. v = vCresta * sin(2 * PI * f * t); // Muestra el valor de voltaje instantáneo. cout.setf(ios::fixed); cout.precision(4); cout << "\n\nEl voltaje instantáneo para " << t << " milisegundos es\n" << v << " volts." << endl; } // final del main()



2. Coordenada rectangular :

x + iy

Donde: x es el eje real o coordenada horizontal, para la punta del vector. y es el eje imaginario o coordenada vertical, para la punta del vector. i = √-1, un número imaginario. M ∠∠θθ o bien x + iy M y x

Polar →→ Rectangular Rectangular →→ Polar M ∠∠ θθ = √√ x2 + y2 ∠∠ arctan y/x x + iy = M cos θθ + M senθθ

Figura 6.3. Conversión de coordenadas polares/rectangulares.

Vamos a escribir un programa C++ que convierta de coordenadas polares a rectangulares usando valores proporcionados por el usuario.


Salida: La salida será en forma tabular, mostrando la coordenada polar de entrada

y la correspondiente coordenada rectangular. La coordenada polar se mostrará en el formato M @ θθ. Los valores de M y θθ se mostrarán como variables, y el símbolo @ se mostrará como un carácter fijo. La coordenada rectangular se mostrará usando el formato x + iy. Los valores de x y y se mostrarán como variables usando dos lugares decimales. El símbolo + y el carácter i se mostrarán como información de carácter fijo.

Entrada: El usuario escribe la magnitud del vector y el ángulo que hace con el eje

horizontal, en grados. Procesamiento: El programa debe calcular x y y como sigue:

x = M cosθθ y = M senθθ

Eje imaginario +

θθ Eje real +




Usando la definición del problema anterior, una serie apropiada de algoritmos sería la que sigue:

ALGORITMO INICIAL

coordenadas() INICIO

Llama a la función para obtener la entrada de la coordenada polar del usuario. Llama a la función para calcular la coordenada rectangular. Llama a la función para mostrar la coordenada polar introducida y para calcular la coordenada rectangular.

FIN.

PRIMER NIVEL DE REFINAMIENTO

obtenerDato() Inicio

Escribir(“favor de introducir la magnitud del vector, M: ”). Leer (M). Escribir(“Favor de introducir el ángulo del vector en grados: ”). Leer(ángulo).

Fin. calculoRectangular()

Inicio Calcular x = M cos(ángulo). Calcular y = M sen(ángulo).

Fin.

mostrarResultados() Inicio

Escribir(“Títulos de la tabla”). Escribir(“La coordenada polar es : M @ ”, ángulo). Escribir(“La coordenada rectangular es: ”, x + iy).

Fin.

* El siguiente programa: RECTANGULAR.CPP, convierte coordenadas polares a rectangulares. Salida: La salida será en forma tabular, mostrando la entrada de coordenada polar y la coordenada rectangular correspondiente. La coordenada polar se mostrará en el formato M @ angulo. Los valores de M y angulo se mostrarán como variable y el símbolo @ se mostrará como un caracter fijo. La coordenada rectangular se mostrará usando el formato x + iy. x y y se mostrarán como variables usando dos lugares decimales. El símbolo + y el caracter i se mostrarán como información de caracter fijo. Entrada: El usuario debe escribir la magnitud, M, del vector y su ángulo. Procesamiento: El programa debe calcular x y y como sigue: x = M cos(angulo). y = M sen(angulo). El angulo se debe convertir a radianes durante los cálculos. */

JERARQUIA DE LOS OPERADORES Cuando realice operaciones en C++ debe tener cuidado con la jerarquía de los operadores. Por ejemplo C++ realiza primero una multiplicación y después una suma. Consideremos la siguiente expresión:

respuesta = 5 + 2 * 3;

/#include <iostream.h> // Para cin y cout. #include <iomanip.h> // Para setw(). #include <math.h> // para sin() y cos(). // Enunciado de constantes. const float PI = 3.14159; void main(void) { // Definición de variables. float x = 0.0; // Coordenada rectangular x. float y = 0.0; // Coordenada rectangular y. float m = 0.0; // Magnitud polar. float angulo = 0.0; // Angulo polar. // Muestra el mensaje con la descripción del programa. cout << "Este programa convertirá coordenadas de vectores polares\n" "a coordenadas de vectores rectangulares. " << endl << endl; // Obtención de la coordenada polar. cout << "Escriba la magnitud del vector: m = "; cin >> m; cout << "Escriba el ángulo del vector en grados: angulo = "; cin >> angulo; // Calcula la coordenada rectangular. x = m * cos(PI/180 * angulo); // PI/180 * angulo convierte grados a // radianes. y = m * sin(PI/180 * angulo); // Muestra los valores rectangular y polar al usuario. cout << "\n\n\n" << setw(25) << "COORDENADA POLAR" << setw(40) << "COORDENADA RECTANGULAR" << endl; cout << setw(25) << "----------------" << setw(40) << "----------------------" << endl << endl; cout.setf(ios::fixed); cout.precision(2); cout << setw(13) << m << " @" << setw(6) << angulo << " grados" << setw(19) << x << " + i" << y << endl; } // Final de main()



Dos resultados son posibles:

Para evitar esta confusión, C++ asigna una jerarquía a cada operador. Operador Nombre Ejemplo :: Alcance nombre_clase::nombre_miembro_clase :: Global ::nombre_variable . Selector objeto.nombre_miembro - > Selector apuntador ->nombre_miembro [ ] Suscrito apuntador[elemento] ( ) Llamado función expresión(parámetros) ( ) Valor type(parámetros) sizeof Tamaño objeto sizeof expresión sizeof Tamaño tipo sizeof(type) ++ Posincremento variable ++ ++ Preincremento ++variable -- Posdecremento variable— -- Predecremento --variable & Operador dirección &variable * Operador referencia *apuntador new Operador ubicación new type delete Operador desubicación delete apuntador delete [ ] Desubicación arreglo delete apuntador ~ Complemento a unos ~expresión a nivel bits ! Operador NOT lógico !expresión + Suma unaria +1 - Resta unaria -1 ( ) Operador Typecast (type) expresión .* Selector miembro objeto.*apuntador -> Selector miembro objeto -> *apuntador * Multiplicación expresión * expresión / División expresión / expresión % Módulo expresión % expresión

respuesta = 5 + 2 * 3; respuesta = 5 + 2 * 3; = 7 * 3; = 5 + 6; = 21; = 11;

+ Suma expresión + expresión - Resta expresión – expresión << Desplazar a la izquierda uResultado = uVal << 2;

a nivel bit >> Desplazar a la derecha uResultado = uVal >> 2; a nivel bit < Menor que bandera = i < j; <= Menor que o igual a bandera = i <= j;

> Mayor que bandera = k > j; >= Mayor que o igual a bandera = k >= j; == Igual bandera = k == j; != No igual (distinto) bandera = k != J; & AND a nivel bit k = j & i; ^ XOR a nivel bit k = j ^ 0x1C; | OR a nivel bit k = j | i; && AND a nivel lógico bandera = bandera 1 && bandera2; || OR a nivel lógico bandera = bandera1 || bandera2; ?: Expresión condicional (k = i && j != k) ? “Verdadero” : “Falso”; = Asignación aritmética x = y; += x += y; -= x -= y; *= x *= y; /= x /= y; % = x % = y; >>= Asignación desplazamiento x >>=2; <<= x <<= 2; &= Asignación a nivel bit x &=y; |= x |= y; ^= x ^= y; , Operador coma for(i = 0, j = 1; i > 100; i++, j++)

LO QUE NECESITA SABER

Antes de continuar con la siguiente lección, asegúrese de haber comprendido los siguientes conceptos:

qq La mayoría de los cálculos se efectúan en instrucciones de asignación.

qq Cuando se coloca un nuevo valor en una localidad de memoria, reemplaza el valor previo de dicha localidad. El valor previo se destruye.

qq Cuando se lee un valor de memoria, el proceso es no destructivo, es decir, se copia el valor, dejando el original tal cual en la localidad de memoria.

qq C++ evalúa las expresiones aritméticas en una secuencia precisa determinada por las reglas de procedencia de operadores y de asociatividad.

qq Las operaciones aritméticas en C++ incluyen las operaciones simples de adición, sustracción, multiplicación y división que se pueden realizar en cualquier clase de dato numérico.

qq La adición, sustracción, la multiplicación y la división son básicamente igual para las clases de datos entero y los de punto flotante . Sin embargo cuando se dividan dos enteros, obtendrá un resultado entero.

qq Si necesita un resultado de punto flotante , al menos uno de los operandos debe definirse como valor de punto flotante.

qq El operador módulo (%) se define sólo para enteros y generará un error de compilador si se usa con valores de punto flotante.

qq C++ proporciona operadores de incremento prefijo y posfijo que agregan 1 al contenido de una variable. C++ proporciona operadores de decremento prefijo y posfijo que restan 1 al contenido de una variable.

qq Los operadores prefijo de C++ le indican que primero incremente o decremente el valor de la variable y luego que use esa variable. Los operadores posfijo de C++ le indican que primero use el valor de la variable y que luego lo incremente o decremente.

qq Hay operadores de incremento/decremento definidos en C++. El operador de incremento ++, adiciona un 1 a la variable, y el operador de decremento --, resta 1 de la variable.

qq Puede preincrementar/predecrementar una variable o posincrementar / posdecrementar una variable.

qq Hay una gran diferencia cuando se usa incremento/decremento como parte de una expresión que se va a calcular en C++. Una operación preincremento/predecremento en una variable se realiza antes de evaluar la expresión, y una operación posincremento/posdecremento se realiza en una variable después de que se evalúa la expresión.

qq Para asegurar que las expresiones son evaluadas en forma consistente , C++ asigna una jerarquía a cada operador, el cual controla el orden en que ocurrirán las operaciones. Si desea controlar el orden en que las operaciones se realizarán, utilice paréntesis. C++ primero evalúa las expresiones entre paréntesis.

qq El operador de asignación simple en C++ es el operador =. Un valor del lado derecho del operador = se asigna a la variable del lado izquierdo del operador.

qq Hay operadores de asignación compuesta , como +=, *= y otros, que combinan una operación aritmética con la operación de asignación. Estos operadores se usan como una forma de notación corta dentro de un programa C++.

qq Los operadores booleanos son aquellos que generan un resultado lógico de verdadero o falso. Las dos categorías de operadores booleanos en C++ son operadores relacionales y lógicos.

qq Los operadores relacionales permiten comparar dos cantidades. Estos operadores incluyen ==, !=, >, <, <=, >=.

qq Los operadores lógicos realizan operaciones lógicas sobre valores booleanos para generar un resultado booleano. Los operadores lógicos estándar disponible en C++ son NOT(!), OR(||) y AND(&&)

qq El operador AND al nivel de bits (&) toma dos operandos enteros. Un bit en el resultado se establece a 1 si los bits correspondientes en cada operando son 1.

qq Las máscaras se utilizan para ocultar algunos bits mientras se conservan otros.

qq El operador OR inclusivo a nivel de bits ( | ) toma dos operandos. Un bit en el resultado se establece a 1 si el bit correspondiente en cualquiera de los operandos es 1.

qq Cada uno de los operandos al nivel de bits (a excepción del operador unario de complemento al nivel de bits) tiene un operador de asignación correspondiente.

qq El operador OR exclusivo a nivel de bits ( ^ ) toma dos operandos. Un bit en el resultado se establece a 1 si solamente uno de los bits correspondientes en los dos operandos es 1.

qq El operador de desplazamiento a la izquierda ( << ) desplaza los bits de su operando izquierdo hacia la izquierda el número de bits especificado por su operando derecho. Los bits vacantes del lado derecho se remplazan con 0.

qq El operador de desplazamiento a la derecha ( >> ) desplaza los bits de su operando izquierdo hacia la derecha el número de bits especificado por su operando derecho. Realizar un desplazamiento a la derecha de un entero sin signo causa que los bits vacantes de la izquierda se reemplacen con 0. los bits vacantes en los enteros con signo pueden reemplazarse con ceros o unos –esto depende de la máquina.

qq El operador de complemento a nivel de bits ( ~ ) toma un operando e invierte sus bits, y esto produce el complemento a uno del operando.

qq Algunos archivos de encabezado C+++ incluyen funciones estándar que se pueden usar para realizar tareas comunes. Hay funciones matemáticas, funciones de conversión y funciones de cadena, sólo por mencionar algunas categorías.

qq La función islower() determina si su argumento es una letra minúscula ( a – z ).

qq La función isupper() determina si su argumento es una letra mayúscula ( A – Z ).

qq La función isdigit() determina si su argumento es un dígito ( 0 – 9 )

qq La función isalpha() determina si su argumento es una letra mayúscula ( A – Z ) o minúscula ( a – z ).

qq La función isalnum() determina si su argumento es una letra mayúscula ( A – Z ), minúscula ( a – z ) o un dígito ( 0 – 9 ).

qq La función isxdigit() determina si su argumento es un dígito hexadecimal ( A – F, a – f, 0 – 9 )-

qq La función toupper() convierte una letra minúscula a mayúscula.

qq La función tolower() convierte una letra mayúscula a minúscula.

qq La función isspace() determina si su argumento es alguno de los siguientes caracteres de espacio en blanco: ‘ ‘ (espacio), ‘\f’, ‘\n’, ‘\ r’, ‘\t’ o ‘\v’.

qq La función isnctrl() determina si su argumento es uno de los siguientes caracteres de control: ‘\t’, ‘\v’, ‘\f’, ‘\a’, ‘\b’, ‘\ r’, o ‘\n’.

qq La función ispunct() determina si su argumento es un carácter imprimible que no sea espacio, dígito o letra.

qq La función isprint() determina si su argumento es cualquier carácter imprimible, incluyendo el carácter de espacio.

qq La función isgraph() determina si su argumento es un carácter imprimible que no sea el carácter de espacio.

qq La función atof() convierte su argumento –una cadena que comienza con una serie de dígitos que representan un número de punto flotante –a un valor double.

qq La función atoi() convierte su argumento –una cadena que comienza con una serie de dígitos que representan un entero –a un valor int.

qq La función atol() convierte su argumento –una cadena que comienza con una serie de dígitos que representan un entero largo –a un valor long.



qq La función strtod() convierte a double una secuencia de caracteres que representan un valor de punto flotante. La función recibe dos argumentos –una cadena (char *) y un apuntador a char *. La cadena contiene la secuencia de caracteres a convertirse, y al apuntador a char * se le asigna el resto de la cadena después de la conversión

qq La función strtol() convierte a long una secuencia de caracteres que representan un entero. La función recibe tres: argumento –una cadena (char *), un apuntador a char * y un entero. La cadena contiene la secuencia de caracteres a convertirse, al apuntador a char * se le asigna el resto de la cadena después de la conversión y el entero especifica la base del valor que está siendo convertido.

qq La función strtoul() convierte a unsigned long una secuencia de caracteres que representan un entero. La función recibe tres argumentos –una cadena (char *), un apuntador a char * y un entero. La cadena contiene la secuencia de caracteres a convertirse, al apuntador a char * se le asigna el resto de la cadena después de la conversión y el entero especifica la base del valor que está siendo convertido.

qq La función strchr() busca la primera ocurrencia de un carácter en una cadena. Si encuentra dicho carácter devuelve un apuntador al carácter en la cadena, y en caso contrario devuelve NULL.

qq La función strspn() determina la longitud de la parte inicial de la cadena que está en su primer argumento que no contiene ningún carácter de la cadena que está en su segundo argumento. La función devuelve la longitud del segmento.

qq La función strpbrk() busca la primera ocurrencia en su primer argumento de cualquier carácter que aparece en su segundo argumento. Si encuentra un carácter del segundo argumento devuelve un apuntador al carácter, y en caso contrario devuelve NULL

qq La función strrchr() busca la última ocurrencia de un carácter en una cadena. Si encuentra dicho carácter devuelve un apuntador al carácter en la cadena, y en caso contrario devuelve NULL.

qq La función strspn() determina la longitud de la parte inicial de la cadena que está en su primer argumento, que sólo contiene caracteres de la cadena que está en su segundo argumento. La función devuelve la longitud del segmento.

qq La función strstr() busca la primera ocurrencia de su segundo argumento de cadena en su primer argumento de cadena. Si la segunda cadena se encuentra en la primera, se devuelve un apuntador hacia la localidad de la cadena en el primer argumento.

qq La función memcpy() copia el número especificado de caracteres desde el objeto al que apunta su segundo argumento hacia el objeto al que apunta su primer argumento. Dicha función puede recibir un apuntador a cualquier tipo de objeto. memcpy() recibe a dichos apuntadores como void, y éstos se convierten a apuntadores char para utilizarlos en la función. La función memcpy() manipula los bytes de los argumentos como caracteres.

qq La función memmove() copia un número especificado de bytes desde el objeto al que está apuntado su segundo argumento hacia el objeto al que está apuntado su primer argumento. La copia se realiza como si los bytes se copiaran desde el segundo argumento hacia un arreglo de caracteres temporal y luego se copiaran desde el arreglo temporal hacia el primer argumento.

qq La función memcmp() compara el número especificado de caracteres de sus argumentos primero y segundo.

qq La función memchr() busca la primera ocurrencia de un byte, representado como unsigned char en el número especificado de bytes de un objeto. Si encuentra al byte devuelve un apuntador a éste, y en caso contrario devuelve un apuntador a NULL.

qq La función memset() copia su segundo argumento, al que trata como unsigned char, hacia un número especificado de bytes del objeto al que está apuntando el primer argumento.

qq La función strerror() convierte un número de error entero a una cadena de texto completa en forma dependiente del sistema. Se devuelve un apuntador a la cadena.

PREGUNTAS Y PROBLEMAS PREGUNTAS

1. ¿Qué valor producirá cada una de las siguientes operaciones de enteros?

a. 4 – 2 * 3 b. –35 / 6 c. –35 % 6 d. –25 * 14 % 7 * -25 / -5 e. –5 * 3 + 9 – 2 * 7 f. (-13 / 2) % 6

2. Evalúe cada una de las siguientes expresiones: a. 0.5 + 3.75 / 0.25 *2 b. 2.5 – (1.2 + (4.0 – 3.0) * 2.0) + 1.0 c. 6.0E – 4 * 3.0E + 3 d. 6.0E –4 / 3.0E + 3

3. Evalúe cada una de las siguientes expresiones:

a. 5.0 – (6.0 / 3) b. 200 * 200 c. 5 – 6 / 3 d. (5 – 6) / 3 e. 1 + 25 % 5 f. –33000 + 2000

4. Evalúe cada una de las siguientes expresiones:

a. int i = 0; int j = 10; ++i + j++;

b. float k = 2.5; k-- * 2;

c. char caracter = ‘a’; ++caracter;

d. int x = 1; int y = -1; int z = 25; ++x + ++y - --z;

5. Evalúe cada una de las siguientes operaciones relacionales: a. 7 != 7 b. –0.75 <= -0.5 c. ‘m’ > ‘n’ d. 2 * 5 % 3 – 7 < 16 / 4 + 2 e. “Andy” == “Andy” f. strcmp(“Andy”, “Andy”)

6. Determine la salida generada por lo siguiente: a. cout << ((2 % 5) / (5 % 2)) << endl; b. cout << (3 * 6 / 3 + 6) << endl; c. cout << ((3 * 6) / (3 + 6)) << endl; d. cout << ( NOT (1 OR 0)) << endl; e. cout << ((2 – 5 / 2 * 3) <= (8 % 2 – 6)) << endl; f. int x = -7;

int y = 3; cout << ( NOT(3 * x < 4 * y) AND (5 * x >= Y)) << endl;

g. cout << (3.5 AND 0) << endl; h. cout << (3.5 OR 2.0) << endl;

7. El estándar ANSI C++ especifica la operación lógica excluyente OR, XOR. El estándar proporciona para el teclado XOR o un símbolo de intercalación, ^, alternativo, que se usa como sintaxis para esta operación. Dadas dos variables booleanas, A y B, la operación XOR se define como:

A B A XOR B verdadero verdadero falso verdadero falso verdadero falso verdadero verdadero falso falso falso

¿Puede ver en la tabla un patrón que sugiera cómo trabajar XOR? Bien, la operación XOR siempre producirá un resultado verdadero si hay un número impar de variables verdaderas. Ahora para la pregunta: ¿Cuál de las siguientes expresiones lógicas pr oducirá la operación XOR?

a. NOT A OR NOT B b. (A AND NOT B) OR (NOT A AND B) c. NOT(A AND NOT B) OR (NOT A AND B) d. NOT(NOT A AND NOT B)

8. ¿Qué operación lógica estándar realiza la expresión en la pregunta 7d?

9. Desarrolle una tabla de verdad para la siguiente expresión lógica:

NOT A OR NOT B

10. ¿Cuál de las siguientes es equivalente a la operación lógica en la pregunta 9?

a. !(A && B) b. !(A || B) c. !A && !B d. Ninguna de las anteriores

11. Explique cómo se obtiene la información de cómo usar una función estándar disponible en su compilador.

12. Determine el valor que producen las siguientes funciones. Use el manual de referencia de su compilador con la característica ayuda en línea, para asegurarse cómo operan las funciones.

a. abs(-5) b. sin(1.57) c. log(2.73) d. log10(100) e. pow(2,5) f. cos(0) g. toascii(‘ ’) h. tolower(‘A’) i. strlen(“C++”)

13. Explique que sucede cuando ejecuta las siguientes funciones:

a. strcmp(nombre, “Brenda”); b. strcmp(nombre1, nombre2);

14. Pruebe o desapruebe por medio de la tabla de verdad que:

NOT A AND NOT B == NOT(A AND B)

15. Indique si las siguientes oraciones son verdaderas o falsa. Si son falsas, explique por qué.

a. El operador de módulo (%) sólo puede utilizarse con operandos enteros. b. Los operadores aritméticos *, /, % , + y – tienen el mismo nivel de precedencia. c. Un programa C++ que imprime tres líneas de salida debe tener tres instrucciones de salida cout.

16. Indique cuáles de las siguientes oraciones son verdaderas y cuáles son falsas. Expllique sus respuestas. a. Los operadores de C++ se evalúan de izquierda a derecha. b. Los siguientes son nombres de variables válidos: _bajo_barra, m928134, t5, j7, susVentas, cuCuentaTotal, a, b,

c, z, z2. c. La instrucción cout << “a = 5;”; es un ejemplo típico de una instrucción de asignación. d. Las expresiones aritméticas válidas de C++ sin paréntesis se evalúan de izquierda a derecha. e. Los siguientes son nombres de variables inválidos: 3g, 87, 67h2, h22, 2h.

17. Llene los espacios en blanco de las siguientes oraciones: a. ¿Qué expresiones aritméticas están al mismo nivel de precedencia que la multiplicación?



b. Cuando se anidan paréntesis, ¿qué par de paréntesis debe evaluarse primero en una expresión aritmética? _______________________.

c. Una localidad de memoria de la computadora que puede contener valores distintos en diferentes momentos de la ejecución de un programa se llama ________________.

18. Dada la ecuación algebraica y = ax3 + 7, ¿Cuáles de las siguientes son instrucciones correctas en C++ para dicha ecuación, si es que las hay? a. y = a * x * x* x + 7; b. y = a * x * x*( x + 7); c. y = (a * x) * x*( x + 7); d. y = (a *x) * x* x + 7; e. y = a * (x * x* x) + 7; f. y = a * x * (x* x + 7);

19. Indique el orden de evaluación de los operadores de las siguientes instrucciones C++ y muestre el valor de x tras la ejecución de cada instrucción.

a. x = 7 + 3 * 6 / 2 – 1; b. x = 2 %2 + 2 *2 – 2; c. x = (3 * 9 * (3 + (9 * 3 / (3) )));

20. Llene los espacios en blanco en cada una de las siguientes oraciones. a. Los bits en el resultado de una expresión cuando se utiliza el operador ____________ se establecen a 1 si los

bits correspondientes de cada operando son 1. En caso contrario, los bits se establecen a 0.

b. Los bits en el resultado de una expresión cuando se utiliza el operador _____________ se establecen a 1 si al menos uno de los bits correspondientes en cualquier operando es 1. En caso contrario, los bits se establecen a 0.

c. Los bits en el resultado de una expresión cuando se utiliza al operador ___________ se establecen a 1 si únicamente uno de los bits correspondientes en cualquier operando es 1. En caso contrario, los bits se establecen a 0.

d. El operador AND al nivel de bits & se utiliza frecuentemente para ___________ bits, es decir, seleccionar determinados bits de una cadena de bits mientras otros se establecen a cero.

e. Los operadores ________________ y _______________ se utilizan para dezplazar los bits de un valor hacia la izquierda o a la derecha, respectivamente .

21. Escriba una sola instrucción para realizar cada una de las siguientes cosas. Suponga que las variables c (que almacena un carácter), x, y y. son de tipo int, las variables d, e y f son de tipo float, la variable ptr es tipo char * y los arreglos s1[100] y s2[100] son de tipo char.

a. Convierta el carácter que está almacenado en la variable c a letra mayúscula. Asigne el resultado a la variable c.

b. Determine si el valor de la variable c es un dígito. Utilice el operador condicional, como se muestra en los programas, para imprimir “ es un “ o “ no es un “ cuando se desplligue el resultado.

c. Convierta la cadena “1234567” a long e imprima el valor.

d. Determine si el valor de la variable c es un carácter de control. Utilice el operador condicional para imprimir “ es un “ o “ no es un “ cuando se despliegue el resultado

e. Asigne a ptr la localidad de la última ocurrencia de c en s1.

f. Convierta la cadena “8.63582” a double e imprima el valor.

g. Determine si el valor de c es una letra. Utilice el operador condicional para imprimir “ es una “ o “ no es una “ cuando se despliegue el resultado.

h. Asigne a ptr la locallidad de la primera ocurrencia de s2 en s1.

i. Determine si el valor de la variable c es un carácter imprimible. Utilice el operador condicional para imprimir “ es un “ o “ no es un “ cuando se despliegue el resultado.

j. Asigne a ptr la localidad de la primera ocurrencia en s1 de cualquier carácter que esté en s2.

k. Asigne a ptr la localidad de la primera ocurrencia de c en s1.

l. Convierta la cadena “-21”a int e imprima el valor.



PROBLEMAS 1. Escriba un programa que permita al usuario convertir una temperatura en grados Fahrenheit a grados

Centígrados usando la siguiente relación: C = 5 / 9 (F – 32)

2. Escriba un programa que permita al usuario convertir una medida de pulgadas a centímetros.

3. Escriba un programa de verificación qué demuestre qué pasa cuando usa un argumento ilegal dentro de una función. Por ejemplo, ¿qué pasa cuando usa un argumento de carácter en una función aritmética?

4. Escriba un programa que permita al usuario encontrar la hipotenusa de un triángulo rectángulo usando el teorema de Pitágoras . (Sugerencia: use la función hypot() en el archivo de cabecera math.h.

5. Escriba un programa para solucionar la siguiente ecuación para x: 3x – 5y + 2 = 35

Suponga que el usuario escribirá los valores para y.

6. Escriba un programa para generar una tabla de verdad para una operación NOR. Una operación NOR es una operación NOT OR. De esta manera:

A NOR B = NOT(A OR B) Suponga que el usuario escribirá valores lógicos para A y B.

7. Escriba un programa para convertir coordenadas rectangulares a polares. Genere una salida tabular de la coordenada rectangular en comparación con la coordenada polar.

8. La energía cinética de un objeto en movimiento se encuentra usando la ecuación:

K = (1/2)(mv2)

Donde:

K es la energía cinética, en kg/seg. m es la masa en kg. v es la velocidad en m/seg.

Escriba un programa que acepte entradas de masa y velocidad de un objeto y determine su energía cinética.

9. A continuación aparece la lista de inventario y precios del departamento de Salud y Belleza de la tienda general ACME, S.A. de C.V.

Artículo Precio Jabón GrandMa’s Lye 0.49 Bolsa Bahm 1.29 Sopa de pollo 0.29 Linimento 2.35 Polvo para hornear 0.63

ACME, S.A. de C.V. quiere realizar una gran venta y reducir todos los artículos de Salud y Belleza en 5%. Escriba un programa que imprima una lista de todos los artículos de Salud y Belleza mostrando el precio regular y el de promoción. Suponga que en la salida debe ir la lista anterior.

10. Revise el programa del problema 9 para permitir que ACME, S.A. de C.V. escriba cualquier porcentaje de descuenta sobre la venta.

11. Revise el programa del problema 9 para leer los nombres y precios de los artículos desde un archivo en disco llamado precios. Genere el informe en su pantalla del monitor. (Nota: deberá crear un archivo de texto precios, con su editor, que contenga los nombres y precios de los artículos mencionados en la tabla del problema 9)

12. ACME, S.A. de C.V. quedaron entusiasmados con los programas que escribió, así que ellos quieren ampliar sus operaciones de computadora para el departamento de nómina. Escriba un programa de nómina para ACME, S.A. de C.V. , que calcule el pago neto de José (su único empleado) determinado por la siguiente información:



Nombre del empleado Número de horas trabajadas a la semana Salario por hora ISR (7.15%) Retención federal (16%) Retención estatal (4.75%)

Genere un informe usando el siguiente formato:

Nombre del empleado: XXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Salario por hora: $XXX.XX Número de horas trabajadas a la semana: XX.XX Pago bruto: $XXXX.XX Deducciones:

ISR: $XXX.XX Retención federal: XXX.XX Retención estatal: XXX.XX -------------- Total de deducciones: $XXX.XX

Pago neto: $XXXX.XX

13. El diagrama en la figura 6.4 muestra cómo se usa la triangulación para encontrar la distancia a un objeto. Esta es la idea: dos dispositivos de triangulación se separan a cierta distancia, y ambos dispositivos obtienen un ajuste sobre un objeto como se muestra en la figura 6.4. Los dos dispositivos de triangulación y el objeto forman un triángulo con un lado d, y dos ángulos θθ1 y θθ2 como se muestra. El tercer ángulo se encuentra fácilmente restando los dos ángulos conocidos a 180º. La distancia de cada dispositivo de triangulación al objeto se encuentra usando la ley de los senos, que establece:

r1 / senθθ1 = r2 / senθθ2 = d / sen[180 – (θθ1 + θθ2)]

Escriba un programa para encontrar la distancia que hay entre el objeto y cada dispositivo de triangulación. Suponga que el usuario escribirá la distancia (d) entre los dispositivos y los dos ángulos (θθ1 y θθ2) que el objeto forma con los dispositivos de triangulación,

r2 r1

180º -(θθ1 + θθ2) θθ1 θθ2 Dispositivo de Dispositivo de triangulación 1 triangulación 2

r1 / senθθ1 = r2 / senθθ2 = d / sen[180 – (θθ1 + θθ2)]

Figura 6.4. Un diagrama de triangulación para el problema 12.

14. Escriba un programa que desplace a la derecha en 4 bits a una variable entera. El programa deberá imprimir el entero en bits antes y después de la operación de desplazamiento ¿Su sistema coloca 0 o 1 en los bits vacantes?

d

15. Si su computadora utiliza enteros de 4 bytes, modifique el programa BITOPER3.CPP , página 203, para que funcione con enteros de 4 bytes.

16. El desplazamiento hacia la izquierda en 1 bit de un entero unsigned es equivalente a multiplicar el valor por 2. Escriba la función power2() que tome dos argumentos enteros –numero y pow- y calcule:

numero * 2pow

Utilice el operador de desplazamiento para calcular el resultado. El programa deberá imprimir los valores como enteros y como bits.

17. Es posible utilizar el operador de desplazamiento a la izquierda para empacar dos valores de carácter en una variable entera sin signo de 2 bytes. Escriba un programa que reciba dos caracteres desde el teclado y los pase a una función packCharacters() Para empacar dos carácteres en una variable entera unsigned, asigne el primer carácter a la variable unsigned, desplace la variable unsigned hacia la izquierda en 8 posiciones de bit y combine la variable unsigned con el segundo carácter usando el operador OR inclusivo al nivel de bits. El programa deberá enviar a la salida los caracteres en su formato de bits antes y después de que se empaquen en el entero unsigned para probar que los caracteres están, de hecho, empacados correctamente en la variable unsigned.

18. Utilizando el operador de desplazamiento a la derecha, el operador AND al nivel de bits y una máscara, escriba la función unpackCharacters() que tome el entero unsigned del problema 17 y lo desempaque en dos caracteres. Para desempacar dos caracteres desde un entero de 2 bytes unsigned, combine el entero sin signo con la máscara 65280 (11111111 00000000) y desplace hacia la derecha en 8 bits el resultado. Asigne el valor resultante a una variable char. Luego combine el entero unsigned con la máscara 255 (00000000 11111111)- Asigne el resultado a otra variable char. El programa primero deberá imprimir al entero unsigned en bits antes de que sea desempacado, y después los caracteres en bits para confirmar que se desempacaron correctamente.

19. Si su sistema utiliza enteros de 4 bytes, vuelva a escribir el problema 17 para empacar 4 caracteres. 20. Si su sistema utiliza enteros de 4 bytes, vuelva a escribir la función unpackCharacters() del problema 18

para desempacar 4 caracteres. Cree las máscaras que necesite para desempacar los 4 caracteres desplazando hacia la izquierda el valor 255 en la variable de máscara en 8 bits, 0, 1, 2 0 3 veces (dependiendo del byte que se vaya a desempacar)

21. Escriba un programa que invierta el orden de los bits de un valor entero sin signo. El programa deberá recibir el valor del usuario y llamar a la función reverseBits() para imprimir los bits en orden inverso. Imprima el valor en bits antes y después de invertir los bits, para confirmar que se invirtieron adecuadamente.

22. Modifique la función visualizarBits() del programa BITOPER3.CPP, de la página 203, para que sea portable entre sistemas que utilicen enteros de 2 y 4 bytes. Sugerencia: utilice el operador sizeof() para determinar el tamaño de un entero en una máquina particular.

23. Escriba un programa que reciba un carácter desde el teclado y pruebe el carácter con cada una de las funciones de la biblioteca de manejo de caracteres. El programa deberá imprimir el valo r devuelto por cada función.

24. El siguiente programa utiliza la función múltiple() para determinar si el entero introducido desde el teclado es un múltiplo de algún entero x. Examine la función múltiple() y luego determine el valor de x.

/* El siguiente programa: PROBLEMA24.CPP, determina si un valor es múltiplo de x. */ #include <iostream.h> //Para cout y cin int multiple( int ); void main(void) { int y;

cout << “Introduzca un número entero entre 1 y 32000: ” ; cin >> y;

25. ¿Qué hace el siguiente programa? 26. Escriba un programa que introduzca una línea de texto con la función miembro getline() de istream en el

arreglo de caracteres s[100] Dé salida a la línea en letras mayúsculas y minúsculas. 27. Escriba un programa que introduzca 4 cadenas que representen enteros, convierta dichas cadenas a

enteros, sume los valores e imprima el total de los 4 valores. 28. Escriba un programa que introduzca 4 cadenas que representen valores flota, convierta dichas cadenas a

double, sume los valores e imprima el total de los 4 valores. 29. Escriba un programa que introduzca una línea de texto y una cadena de búsqueda desde el teclado.

Mediante la función strstr(), localice la primera ocurrencia de la cadena de búsqueda en la línea de texto, y asigne la localidad a la variable searchPtr de tipo char *. Si encuentra la cadena de búsqueda, imprima

if( múltiple( y ) ) cout << y << “ es un múltiplo de x” << endl; else cout << y << “ no es un múltiplo de x” << endl;

}//Fin de main() int multiple( int num ) {

int mask = 1, mult = 1; for( int i = 0; i < 10; i++, mask <<= 1)

if( ( num & mask ) ! = 0 ) {

mult = 0; break;

}//Fin de if return mult; }//Fin de multiple()

#include <iostream.h> //Para cout y cin int misterio( unsigned ); void main(void)

{ unsigned x; cout << “Introduzca un númro entero: ”; cin >> x; cout << “El resultado es ” << misterio( x ) << endl;

}//Fin de main() int misterio( unsigned bits )

{ unsigned mask = 1 << 15, total = 0; for( int i = 0; i < 16; i++, bits <<= 1 )

if( ( bits & mask ) == mask ) ++total;

return total % 2 == 0 ? 1 : 0; }//Fin de misterio()



el resto de la línea de texto comenzando con la cadena de búsqueda. Luego utilice nuevamente strstr() para localizar la siguiente ocurrencia de dicha cadena en la línea de texto. Si encuentra una segunda ocurrencia, imprima el resto de la línea, comenzando con la segunda ocurrencia. Sugerencia: la segunda llamada a strstr() debe contener searchPtr + 1 como primer argumento.

30. Escriba un programa basado en el programa del problema 29 que introduzca varias líneas de texto y una cadena de búsqueda, y utilice la función strstr() para determinar el número total de ocurrencias de la cadena en las líneas de texto. Imprima el resultado.

31. Escriba un programa que introduzca varias líneas de texto y un carácter de búsqueda, y utilice la función strchr() para determinar el número total de ocurrencias del carácter en la línea de texto.

32. Escriba un programa basado en el programa del problema 31 que introduzca varias línea de texto, y use la función strchr() para determinar el número total de ocurrencias de cada letra del alfabeto en el texto. Las letras mayúsculas y minúsculas.

33. Cuáles se deberán contar juntas. Guarde los totales de cada letra en un arreglo e imprima los valores en formato tabular después de que se hayan determinado los totales.

34. Basándose en la tabla de códigos de caracteres ASCII de la página 26 diga si cada una de las siguientes frases es verdadera o falsa.

a. La letra “A” viene antes que la letra “B”. b. El dígito “9” viene antes del dígito “0”. c. Los símbolos sutilizados comúnmente para la suma, resta, multiplicación y división están antes de que

cualquiera de los dígitos. d. Los dígitos están antes que las letras. e. Si un programa de ordenamiento ordena cadenas en secuencia ascendente, dicho programa colocará el símbolo

de paréntesis derecho antes que el símbolo de paréntesis izquierdo. 35. Escriba un programa que lea una serie de cadenas e imprima solamente aquellas cadenas que comienzan

con la letra “b”. 36. Escriba un programa que lea una serie de cadenas e imprima solamente aquellas cadenas que terminen

con las letras “DE”. 37. Escriba un programa que introduzca un código ASCII e imprima el carácter correspondiente. Modifique

este programa para que genere todos los códigos de tres dígitos posibles en el rango de 000 a 255 e intente imprimir los caracteres correspondientes. ¿Qué pasa cuando se ejecuta este programa?

38. Utilizando como guía la tabla de caracteres ASCII de la página 26, escriba sus propias versiones de las funciones para el manejo de caracteres de la tabla 6.6 página 40.

39. Escriba sus propias versiones de las funciones de tabla 6.7 página 44 para convertir cadenas a números. 40. Escriba sus propias versiones de las funciones de la tabla 6.8 página 49 para buscar cadenas. 41. Escriba sus propias versiones de las funciones de la tabla 6.9 página 52 para manipular bloques de

memoria. 42. (Proyecto: un revisor de ortografía) Muchos paquetes de software de procesamiento de texto populares

tienen revisores de ortografía integrados. En este proyecto se le pide que desarrolle su propia utilería de revisión ortográfica. Le damos algunas sugerencias para ayudarle a comenzar. Luego deberá considerar la adición de más capacidades. Tal vez encuentre útil el uso de un diccionario computarizado como fuente de palabras. ¿Por qué tecleamos tantas palabras con falta de ortografía? En algunos casos es simplemente porque no sabemos la ortografía correcta y, por lo tanto, hacemos nuestra mejor suposición. En algunos casos se debe a que intercambiamos dos letras (por ejemplo, defualt en vez de default) A veces tecleamos dos veces una letra accidentalmente (por ejemplo, tamto en vez de tanto)- A veces tecleamos una tecla cercana en vez de la que pretendíamos (por ejemplo, numca en vez de nunca) Y así sucesivamente. Diseñe e implemente un programa revisor de ortografía en C++. El programa mantiene un arreglo wordList de cadenas de caracteres. Usted puede teclear estas cadenas u obtenerlas a partir de un diccionario computarizado. El programa le pide al usuario que teclee una palabra. Después busca esa palabra en el arreglo wordList. Si la palabra está presente en el arreglo, el programa deberá imprimir La palabra está escrita correctamente.



Si la palabra no está presente en el arreglo, el programa deberá imprimir La palabra no está escrita correctamente. A continuación, el programa deberá tratar de localizar otras palabras en wordList que el usuario tal vez podía haber pretendido teclear. Por ejemplo, se pueden probar todas las posibles transposiciones simples de letras adyacentes para descubrir que la palabra default tiene una concordancia directa con una palabra que está en wordList. Por supuesto, esto implica que el programa deberá revisar todas las demás transposiciones simples, tales como edfault, dfeault, deafult, defalut y defautl. Cuando encuentra una nueva palabra que concuerde con alguna de wordList, imprímala en un mensaje como ¿Quieres decir default? Implemente otras pruebas, tales como el reemplazo de cada letra doble con una sola letra, y otras que pueda desarrollar para mejorar el valor de su revisor de ortografía.

EXAMEN BREVE 13

1. Diga el orden en el cual C++ realiza las operaciones aritméticas . Asegúrese de mencionar

cómo se manejan los paréntesis.

2. Escriba un enunciado usando el operador de decremento que es equivalente al enunciado x = x – 1;.

3. Verdadero o falso: el operador de división producirá un resultado entero cuando cualquiera de los operandos sea un entero.

4. Verdadero o falso: el operador módulo se define sólo para enteros. 5. ¿Cuál es la diferencia entre usar el operador preincremento y el posincremento en una

variable, en especial cuando la variable se usa como parte de una expresión compuesta?

6. ¿Cuál es el resultado de 10 / 100?

EXAMEN BREVE 14 1. Escriba un enunciado usando un operador de asignación de adición compuesta que sea

equivalente al enunciado x = x + 5.

2. Escriba un enunciado usando un operador de asignación de división compuesta que sea equivalente al enunciado x = x / y

3.

EXAMEN BREVE 15 1. Los operadores que permiten comparar dos valores se llaman operadores

___________________.

2. En C++, un falso lógico equivale al valor _________________________. 3. ¿Cuál es la diferencia entre el operador = y el operador == en C++? 4. ¿Qué valor se genera como resultado de la siguiente operación? 4 > 5 – 2

5. ¿Qué valor se genera como resultado de la siguiente operación? (5!=5) AND (3==3)

EXAMEN BREVE 16

1. Para usar una función estándar en su programa debe incluir su ___________________. 2. Explique como obtener una descripción en línea de una función estándar con el compilador.



3. ¿Qué función deberá emplear en su programa para asignar datos de cadena a una variable de cadena?

4. Escriba un enunciado que asigne la cadena “C++” a la variable de cadena llamada compilador.

5. ¿Por qué la función strcmp() debe usarse en lugar de los operadores relacionales booleanos cuando se comparan valores de cadena?

RESPUESTA EXAMEN BREVE 13 1. El orden en que C++ realiza las operaciones aritméticas es como sigue: () * / % + -.Cualquier

operación dentro de paréntesis se realizará primero, después (de izquierda a derecha) la multiplicación, división y módulo y después (de izquierda a derecha) la suma y la resta.

2. El enunciado –x es equivalente a x = x – 1; 3. Falso: Se requiere que ambos operandos sean enteros para que el cociente lo sea.

4. Verdadero: El operador módulo se define sólo para enteros. 5. La diferencia entre usar el operador preincremento en comparación con el operador

posincremento en una variable es que el primero incrementa la variable antes de que se evalúe cualquier expresión que incluya la variable, y el segundo incrementa la variable después de que se evalúe cualquier expresión que incluya a la variable. Es importante tener cuidado con la que se usa, especialmente cuando la variable forma parte de una expresión compuesta, porque se pueden producir resultados indeseables si se utiliza el operador incremento equivocado.

6. El resultado de 10/100 es 0, porque ambos operandos son enteros y el operador / genera un resultado entero cuando ambos operandos son enteros.

RESPUESTA EXAMEN BREVE 14

1. El enunciado x += 5; equivale a x = x + 5; 2. El enunciado x /=y; es equivalente a x = x / y;

RESPUESTA EXAMEN BREVE 15

1. Los operadores que permiten comparar dos valores se llaman operadores relacionales. 2. En C++, un falso lógico equivale al valor 0 (cero) 3. La diferencia entre el operador = y el operador == en C++ es que el operador = asigna el

enunciado a la derecha de la variable a la misma; y el operador == compara dos cantidades para determinar si son iguales.

4. true (1) se genera como resultado de la operación 4 > 5 – 2, porque 4 es mayor que (5 – 2) o sea 3.

5. El valor booleano false (0) se genera como resultado de la operación (5!=5) AND (3==3), porque (5!=5) es falso, haciendo que el enunciado compuesto AND sea falso.



RESPUESTA EXAMEN BREVE 16 1. Para usar una función estándar en su programa debe incluir su archivo de encabezado. 2. La respuesta a esta pregunta depende del compilador que se utilice. Entérese como se hace en

su compilador. 3. La función strcmp() debe emplearse para asignar unos datos de cadena a una variable de cadena

en un programa C++.

4. El enunciado strcmp(compilador, “C++”); asignará la cadena “C++” a una variable de cadena llamada compilador.

5. La función strcmp() se debe usar en lugar de los operadores relacionales booleanos cuando se comparan valores de cadenas, porque los operadores relacionales booleanos no dan resultados lógicos correctos cuando se comparan las cadenas.

contenido de la lecciÓn 7 - azul2.bnct.ipn.mxazul2.bnct.ipn.mx/c/fundamentos/archivos...

Documents