Está en la página 1de 10
La programación modular es un paradigma de programación que significa escribir un programa de acuerdo
La programación modular es un paradigma de programación que significa escribir un programa de
acuerdo a las siguientes reglas:
El programa tiene diseño modular.
Los módulos están diseñados de modo descendente.
Cada módulo se codifica utilizando tres estructuras de control básicas: secuencial,
decisión/selección ( , , ) y repetición ( , ,
).
Evitar completamente el uso de , la instrucción de transferencia de control, por
contraproducente. Dado que podría conducir a «programa espagueti» que es mucho más difícil de
seguir y mantener.
En la programación con diseño modular, un problema complejo se subdivide en varios subproblemas
de menor complejidad, los cuales a su vez se subdividen en otros problemas más simples. El proceso debe
de continuarse hasta obtener subproblemas lo suficientemente simples como para que puedan ser
implementados fácilmente con un lenguaje de programación. Esta técnica se conoce como refinamiento
sucesivo (stepwise) o análisis descendente (top-down).
Cada uno de los módulos o subprogramas tiene funcionamiento independiente entre sí y cada uno de
los ellos ejecuta una actividad o tarea única bien definida y se codifican independientemente de otros
módulos. Los módulos pueden enviar información y/o recibir información desde otro bloque, es decir se
pueden comunicar entre sí mediante una interfaz que también debe de estar bien definida.
Cada programa tiene un módulo llamado programa principal que controla todo lo que sucede; el
programa comienza a ejecutarse por este módulo y de aquí se transfiere el control de ejecución hacia
otros módulos.
La programación estructurada utiliza un número limitado de estructuras de control que minimizan la
complejidad de los programas y por consiguiente reducen los errores: hace que los programas sean más
fáciles.
Los programas son más fáciles de escribir, verificar, leer y mantener
Reducción significativa de errores al codificar
La estructura de los programas es clara
Reducción de esfuerzo en las pruebas debido a la reducción de errores
Se incrementa el rendimiento del programador
Las estructuras de control de un lenguaje de programación son métodos de especificar el orden en que
las instrucciones de un algoritmo se ejecutarán. Las estructuras de control son:
las instrucciones se ejecutan una a continuación de la anterior, siempre una a la vez y
tal como aparecen escritas en el programa
dependiendo del valor de una expresión lógica el programa puede ejecutar uno de dos
posibles caminos de ejecución.
dependiendo de la evaluación de un valor lógico, el programa puede estar ejecutando
repetitivamente una instrucción o grupo de instrucciones.
Un programa C++ se compone de una o más funciones. Una de ellas debe ser obligatoriamente la
función "main". Una función en C++ es un grupo de instrucciones que realizan una o más acciones. Además
el programa contendrá una serie directivas que permitirán agregar al mismo archivos de
directivas que permitirán agregar al mismo archivos de Marco Antonio Ayala @marantaya Escuela de Física (2016)
directivas que permitirán agregar al mismo archivos de Marco Antonio Ayala @marantaya Escuela de Física (2016)

cabecera que están compuestos de funciones y datos predeterminados. De manera más explícita, un programa básico de C++ puede incluir:

Directivas del preprocesador. Declaraciones globales. La función main. Funciones definidas por el usuario.
Directivas del preprocesador.
Declaraciones globales.
La función main.
Funciones definidas por el usuario.
Comentarios del programa.
El siguiente programa muestra la estructura típica de un programa C++.
Programa I: Estructura general de un programa C++
1
/*
2
* Created on October 26, 2013, 9:16 PM
3
* IDE/Compiler: NetBeans 7.3.1/g++ 4.8.1 x64
4
* File: Welcome.cpp
5
*/
6
7
#include <iostream>
8
#include <cstdlib>
9
#include <windows.h>
10
11
12
13
int main(int argc, char** argv) {
SetConsoleTitle("Welcome to C++ Programming");
std::cout << "\n\tBienvenido a la programación en C++";
14
15
";
16
17
std::cout << "\n\n\tPresione [Enter] para continuar
std::cin.get();
return 0;
18
}
El preprocesador en un compilador C o C++ es un programa que es invocado antes de la compilación
real y que realiza acciones en base a una o más directivas que se encuentren dentro del código fuente (las
directivas de preprocesador son instrucciones al compilador antes de que efectúe la compilación del
programa principal).
Se puede utilizar el preprocesador para compilar código en forma condicional, insertar archivos,
especificar los mensajes de error en tiempo de compilación, sustitución de elementos del programa por

valores previamente definidos, aplicar reglas específicas de la máquina a las secciones del código, entre otros.

Las directivas siempre comienzan con el signo de almohadilla # seguido por el nombre la
Las directivas siempre comienzan con el signo de almohadilla # seguido por el nombre la directiva y
algunas de ellas pueden incluir argumentos o valores. Las directivas del preprocesador pueden aparecer
en cualquier parte del código fuente, pero el resultado de su instrucción sólo se aplica de donde aparece
hacia el resto del programa. Las directivas más usuales son:
y . Otras menos comunes
son:
,
,
, etc.
Solamente se puede escribir una directiva por línea en el programa fuente. En caso de que la directiva
sea demasiado larga, se puede colocar el carácter \ al final de la línea y continuar en la siguiente.
Indica al compilador que lea el archivo fuente que viene a continuación y su contenido lo inserte en la
posición donde se encuentre la directiva. La sintaxis de la directiva son las siguientes:
Las primeras dos versiones implican que ninguna expansión de macro será intentada; en otras
palabras, el archivo header_name nunca es revisado en busca de identificadores tipo macro. El archivo
header_name debe ser un nombre de archivo válido con una extensión y una ruta opcional de ubicación
del archivo.
La tercera versión asume que el primer carácter no blanco seguido después de #include no es el
carácter <, ni la comilla doble; es más, asume la existencia de una definición de macro que expandirá el
identificador de macro en un encabezado en cualquiera de los formatos <header_name> o "header_name".
Los archivos que se incluyen con una directiva #include son llamados "archivos de cabecera" o
"archivos de inclusión". Estos archivos tienen extensión *.h para lenguaje C y/o C++; y extensión *.hpp,
exclusivo para lenguaje C++.
El preprocesador remueve la línea de la directiva #include y conceptualmente la reemplaza con el
código del archivo de cabecera en el mismo punto en que se encuentra la directiva dentro del programa
fuente. El código en sí no cambia, pero el compilador «ve» o procesa un programa fuente «aumentado».
La diferencia entre los formatos <header_name> y "header_name" reside en el algoritmo empleado
para localizar el archivo de cabecera incluido.
La versión <header_name> especifica un archivo de cabecera estándar: la búsqueda es hecha
sucesivamente en cada uno de los directorios include, en el mismo orden en que han sido especificados. Si
el archivo no es localizado en ninguno de los directorios (carpetas) por defecto, entonces un mensaje de
error es emitido.
La versión "header_name" especifica un archivo de cabecera suministrado por el usuario. El archivo es
buscado en el siguiente orden:
En el mismo directorio del archivo que contiene la directiva #include
En los directorios de archivos de cabecera que incluye el archivo fuente
En el directorio de trabajo (directorio actual)
A través de la ruta especificada por la opción /I del compilador.
En las rutas especificadas por medio de la variable de entorno INCLUDE
especificadas por medio de la variable de entorno INCLUDE Como una convención se debe de utilizar

Como una convención se debe de utilizar los delimitadores < y > para cuando se incluya archivos de cabecera que vienen definidos junto con la implementación del compilador y utilizar comillas dobles si se va a incluir archivos de cabecera creados por el programador. Por ejemplo:

#include <stdio.h> #include <unistd.h> #include "usefullib.h" #include "myprog.h"

Las directivas #include pueden estar en cualquier parte del programa, pero lo más común es
Las directivas #include pueden estar en cualquier parte del programa, pero lo más común es situarlas
al principio del mismo.
El (Programa I: Estructura general de un programa C++) incluye tres archivos de cabecera desde la
línea 7 a la línea 9:
#include <iostream>
#include <cstdlib>
#include <windows.h>
La mayoría de programas en C++ necesitarán leer datos del teclado por medio del objeto cin o escribir
datos en pantalla a través del objeto cout, por lo que siempre llevarán como cabecera del programa la
directiva:
Si en el programa se van a manejar cadenas de caracteres es necesario colocar en la cabecera del
programa, la directiva:
Para conservar compatibilidad con el lenguaje de programación C respecto a las instrucciones de
entrada/salida (E/S) {input/output (I/O)}, en donde se utilizan las funciones scanf (…) y printf (…) se
debe agregar la directiva de preprocesador:
La sintaxis de la directiva #define es la siguiente:
La directiva #define es utilizada para especificar una macro. Las macros proveen el mecanismo de
sustitución de un identificador (nombre) por una secuencia de caracteres (token_sequence), ya sea que
tengan o no un conjunto de parámetros similar a las funciones.
La secuencia de caracteres puede consistir de palabras claves, constantes, operadores, instrucciones
completas de código. Un espacio o más debe de existir entre el identificador (macro_identifier) y la
secuencia de caracteres <token_sequence>. Si la secuencia está vacía, el proceso de sustitución elimina el
identificar en todas sus ocurrencias en el código fuente.
Por convención se ha establecido en colocar en mayúsculas todos los identificadores definidos por
#define
#define ADD +
#define PI 3.14159265358979323846
#define INCLUDE_PATH "C:\\Libreria\\cpp\\libutils.hpp"
#define AUTHOR "Tom & Jerry"
La directiva #undef remueve la definición de un identificador previamente definido por #define. La
sintaxis de esta directiva es:
Así los identificadores anteriores se remueve su definición de la siguiente manera:
#undef PI
#undef ADD
definición de la siguiente manera: #undef PI #undef ADD Marco Antonio Ayala @marantaya Escuela de Física

#undef INCLUDE_PATH #undef AUTHOR

Esta directiva del preprocesador tiene el siguiente formato: Con la directiva #pragma, un compilador en
Esta directiva del preprocesador tiene el siguiente formato:
Con la directiva #pragma, un compilador en particular es capaz de definir directivas que no interfieran
con otros compiladores que también soporten #pragma. Si el compilador no reconoce el nombre de la
directiva entonces ignora la directiva #pragma sin emitir ningún mensaje de error o advertencia. Es una
forma de proveer de información adicional al compilador en la forma que debe de realizar la traducción
del lenguaje.
Algunas directivas pragmas que son reconocidas por el compilador de Microsoft Visual Studio son las
siguientes:
Proporciona un método de guardar el estado de la compilación en un punto determinado del código
fuente. Se usa esta directiva para guardar en un archivo la información de la compilación de los archivos
de cabecera incluidos en el programa fuente y que son comunes en los distintos archivos que componen el
proyecto, en dicho caso, puede reducir la cantidad de espacio en disco usada por los archivos de cabecera
precompilados.
Los archivos de cabecera precompilados pueden ser compartidos por los archivos de código fuente del
proyecto solamente si las directivas #include antes de #pragma hdrstop son idénticas. Por lo tanto se
puede tener el mayor rendimiento del compilador si incluye archivos de cabecera comunes antes de
#pragma hdrstop.
Utilice esta directiva de preprocesador solamente en archivos de código fuente. La directiva no tiene
efecto cuando es utilizada en archivos de cabecera o dentro de una función.
Se puede especificar un nombre de archivo y la ruta donde se guarda la información de la
precompilación, pero si no se hace, se crea un archivo automáticamente en el directorio donde está
alojado el archivo de código fuente.
#pragma hdrstop
#pragma hdrstop ("c:\\projects\\include\\myinc.pch")
La sintaxis de esta directiva es la siguiente:
,
La directiva de comentario le permite escribir una cadena de caracteres dentro del archivo de salida.
El tipo de comentario puede tener cualquiera de los siguientes valores:
comentario puede tener cualquiera de los siguientes valores: exestr: El enlazador escribe una cadena de caracteres

exestr: El enlazador escribe una cadena de caracteres dentro de un archivo objeto (*.obj). La cadena especificada es colocada en el archivo ejecutable final. Tal cadena de caracteres nunca será cargada en la memoria pero puede ser encontrada dentro del archivo ejecutable usando un utilitario de búsqueda de archivos apropiado. lib: Escribe un comentario que es grabado dentro del archivo objeto (*.obj). Un módulo de librería que no está especificado en el archivo de respuesta del enlazador, puede ser especificado la directiva comentario lib. El enlazador incluye el nombre del módulo de librería especificado en la cadena como la última librería. Múltiples módulos pueden ser nombrados y enlazados en el orden en que son nombrados.

user: El compilador escribe una cadena dentro del archivo objeto (*.obj). El enlazador ignora la

user: El compilador escribe una cadena dentro del archivo objeto (*.obj). El enlazador ignora la cadena de caracteres especificada.

Las declaraciones globales son todas aquellas instrucciones que introducen al programa objetos que se encuentran
Las declaraciones globales son todas aquellas instrucciones que introducen al programa objetos que
se encuentran disponibles para todas las funciones del programa. Los objetos pueden ser de tipo
fundamental, definidos por el usuario, pueden ser variables o constantes, pueden ser corresponder a una
función, etc.
Las siguientes declaraciones son globales si se encuentran localizadas fuera de cualquier función y su
disponibilidad (que pueden usarse) es a partir de su declaración en adelante.
int avar = 27;
const double SQRT2 = 1.4142135623730950488016887242097;
double ReadNumber(const char*, const double&, const double&);
Una función en C++ es un subprograma que realiza una o más instrucciones y al terminar devuelve un
valor único, un conjunto de valores o solamente realiza una tarea específica tal como entrada/salida. La
ejecución de las instrucciones se realiza de manera independiente de otros bloques o segmentos de
programa (otras funciones).
Una función en C++ tiene un tipo que está definido por una palabra a la izquierda del nombre de la
función. En el caso anterior la función es de tipo int.
El bloque de instrucciones que componen a la función se especifica justo después del encabezado de la
función entre llaves { y }.
Una función en C++ termina se encuentra la llave de cierre del bloque de instrucciones } o de manera
explícita cuando se ejecuta la sentencia return. Si la función devuelve un valor, este debe de incluirse como
parte de la instrucción de retorno, en cualquiera de las siguientes formas de sintaxis:
Cada programa C o C++ tiene obligatoriamente una función main(…) que es el punto de inicia por
donde todo programa comienza a ejecutarse. La declaración de la función principal puede tener
argumentos entre sus paréntesis tal como en la siguiente expresión (línea 11 del Programa I: Estructura
general de un programa C++):
int main(int argc, char** argv)
O si la función principal no utilizará argumentos puede tener cualquiera de los formatos:
int main( )
int main(void)
La primera instrucción de la función principal del Programa I: Estructura general de un programa C++
es una llamada (invocación) de otra función:
SetConsoleTitle ("Welcome to C++ Programming");
La función SetConcoleTitle se encuentra definida en el archivo de cabecera <windows.h> y cambia el
título de la consola donde se muestra la salida del programa. El dato se pasa como una cadena de
caracteres: "Welcome to C++ Programming".
A continuación ejecuta la sentencia:
std::cout << "\n\tBienvenido a la programación en C++";
"\n\tBienvenido a la programación en C++"; Marco Antonio Ayala @marantaya Escuela de Física (2016)
"\n\tBienvenido a la programación en C++"; Marco Antonio Ayala @marantaya Escuela de Física (2016)

En tal sentencia cout es un objeto definido en <iostream>, y dentro del espacio de nombres std. El objeto cout muestra o envía mensajes generalmente al dispositivo estándar de salida (el monitor). Utiliza el operador << que es llamado en este contexto, . Después del operador se encuentra el valor que se enviará como salida: "\n\tBienvenido a la programación en C++", en este caso una constante de cadena de caracteres (una secuencia de caracteres encerrados entre comillas dobles).

La instrucción de la línea 16, std::cin.get(); utiliza la función miembro de cin para esperar
La instrucción de la línea 16, std::cin.get(); utiliza la función miembro de cin para esperar que se
ingrese un valor (una entrada) desde el teclado por parte del usuario y la procesa hasta que el usuario
presiona [Enter]. El efecto es que se genera una pausa antes de ejecutar la sentencia de retorno y finalizar
la función.
Una sentencia (statement) o instrucción es el elemento individual de código más pequeño que puede
dar una orden a la computadora. La instrucción está compuesta por una secuencia de elementos que por sí
solos no pueden dar una orden; la secuencia debe terminar con un carácter separador o finalizador de
sentencias.
En C++ las instrucciones están separadas por un punto y coma, omitirlo es un error de sintaxis pues el
compilador no entiende la instrucción; en otras palabras se ha cometido una violación a las reglas
sintácticas del lenguaje.
Un comentario es cualquier información que se añade al archivo fuente para proporcionar
aclaraciones de cualquier tipo.
El compilador ignora todo el texto que se incluye como comentario. No es obligatorio agregar
comentarios al código, pero es una buena práctica incluir comentarios significativos en el programa
fuente.
El objetivo de agregar comentarios a un programa es con el fin de entender y comprender más
fácilmente más adelante en el tiempo, para lo que el programa fue diseñado, además es mucho más
factible hacerle modificaciones (ya sea por el mismo programador o por otras personas que necesiten
modificarlo).
Es muy común incluir en la parte superior del programa fuente información tal como: nombre del
archivo, nombre del programador, fecha de creación, fechas de modificación, una breve descripción del
programa, etc.
Existen dos formas de incluir comentarios en C++:
Comentarios tipo bloque. Este tipo es heredado por el C++ a partir del C. Comienzan por la
secuencia de caracteres /* y terminan por el par */. Todo lo que se encuentre entre ellos será
ignorado por el compilador. Son utilizados para guardar compatibilidad con el C y para incluir
comentarios extensos de varias líneas.
Comentarios de una línea. Son exclusivos de C++; se define el comienzo de estos tipos de
comentarios por una doble pleca o barra invertida (double slash) //. Todo lo que viene des-pués
de estos caracteres hasta el final de la línea es ignorado por el compilador.
Ejemplos de comentarios en C++:
/* Este es un tipo de comentario tipo bloque
al estilo del C estándar de Kernigan y Ritchie */
// Este es un comentario exclusivo de C++
Para cada uno de los siguientes casos, diga si los cambios realizados producen algún tipo de
error o dan una salida diferente. Si es así, ¿Cuáles son los mensajes de error o la salida que se
así, ¿Cuáles son los mensajes de error o la salida que se Marco Antonio Ayala @marantaya

Marco Antonio Ayala @marantaya

Escuela de Física (2016) Universidad de El Salvador

mensajes de error o la salida que se Marco Antonio Ayala @marantaya Escuela de Física (2016)
obtiene? Explique porqué ocurre dicho error (o errores) o porqué la salida es diferente. 1.
obtiene? Explique porqué ocurre dicho error (o errores) o porqué la salida es diferente.
1.
Elimine los caracteres de la línea 1, /*
2.
Borre la línea #include <iostream>
3.
Quite la línea #include <cstdlib>
4.
Elimine la línea #include <windows.h>
5.
Cambie el nombre del archivo incluido <windows.h> a <windows>
6.
Cambie el nombre del archivo incluido <iostream> a <iostream.h>
7.
Quite el nombre std:: en la sentencia std::cout << "\n\tBienvenido a la programación en
C++";
8.
Elimine el operador de inserción << en la misma sentencia
9.
Cambie las comillas dobles por comillas simples
10.
Elimine la letra n de la secuencia de caracteres "\n\t
11.
Elimine la letra t de la secuencia de caracteres "\n\t
12.
Borre el punto y coma al final de la sentencia
13.
Quite los parámetros int argc, char** argv dentro de los paréntesis de la funcion main.
14.
Borre la palabra int antes del nombre main
15.
Cambie la palabra int que está antes de main por la palabra void
16.
Quite los paréntesis en la sentencia std::cin.get();
17.
Elimine la llave de apertura al inicio del cuerpo de main. Haga lo mismo con la llave que
está al final del cuerpo de main.
18.
Elimine el carácter de almohadilla # a cualquiera de las directivas del procesador.
El siguiente programa solicita dos cantidades por parte del usuario. Realiza la operación de suma y
luego muestra el resultado.
Cuando se hace necesario almacenar información debe contarse con un mecanismo para guardarla y
poder acceder a ella posteriormente. La manera de hacerlo es por medio de la declaración de objetos que
permiten asignar un nombre a una zona de memoria.
En el Programa II: Sumar dos cantidades enteras, se declaran tres objetos de tipo entero: dos ellos
para almacenar los valores leídos y el tercero para guardar el resultado de la suma:
int number1, number2, suma;
Como siguiente acción se realiza la lectura de datos por medio del objeto cin que puede extraer datos
del flujo de entrada asociado al dispositivo estándar (teclado)
std::cin >> number1;
std::cin >> number2;
El objeto cin está definido en la librería incluida <iostream>,
y dentro del espacio de nombres std.
Utiliza el operador >> que se conoce como porque toma de manera secuencial
datos del flujo de entrada y lo coloca en el objeto que se encuentra después del operador.
Justo antes de las sentencias de lectura de datos se ha colocado, utilizando cout, un mensaje que se
mostrará en la consola de salida y que sirve como información al usuario para instruirle el tipo de
información que debe de ingresar.
Programa II: Sumar dos cantidades enteras
debe de ingresar. Programa II: Sumar dos cantidades enteras 1 /* Marco Antonio Ayala @marantaya Escuela

1

/*

Marco Antonio Ayala @marantaya

Escuela de Física (2016) Universidad de El Salvador

Sumar dos cantidades enteras 1 /* Marco Antonio Ayala @marantaya Escuela de Física (2016) Universidad de
2 * Created on October 26, 2013, 9:16 PM 3 * IDE/Compiler: NetBeans 7.3.1/g++ 4.8.1
2
*
Created on October 26, 2013, 9:16 PM
3
* IDE/Compiler: NetBeans 7.3.1/g++ 4.8.1 x64
4
* File: SumData.cpp
5
*/
6
7
#include <iostream>
8
#include <cstdlib>
9
10
#include <limits>
#include <windows.h>
11
12
13
14
15
16
17
18
19
int main(int argc, char** argv) {
int number1, number2, suma;
SetConsoleTitle("Sumar dos Cantidades Enteras");
std::cout << "\n\tSUMA DE DOS CANTIDADES ENTERAS\n";
std::cout << "\tPrimera cantidad: ";
std::cin >> number1;
std::cout << "\tSegunda cantidad: ";
std::cin >> number2;
20
21
suma = number1 + number2;
22
23
24
// muestra el resultado
std::cout << "\n\n\t\t" << number1 << " + " << number2 << " = " << suma;
25
26
std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
27
std::cout << "\n\n\tPresione [Enter] para continuar
std::cin.get();
return 0;
";
28
29
30
}
La línea 21 del programa anterior, con la sentencia:
suma = number1 + number2;
Se indica a la computadora que debe de realizar la suma de los datos previamente almacenados en los
objetos number1 y number2, y que el resultado debe de asignarlo (guardarlo) en el objeto de la izquierda
(suma).
El carácter + que combina a los objetos number1 y number2 se le conoce como operador y los objetos
combinados como operandos. Los tres elementos forman una expresión que realiza la evaluación y lo que
resulta se coloca en el objeto de la izquierda por medio del operador de asignación =.

En la línea 26 se tiene la sentencia:

std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

Usa la función miembro de cin para ignorar caracteres del flujo de entrada estándar (asociado
Usa la función miembro de cin para ignorar caracteres del flujo de entrada estándar (asociado a cin), y
se ignorarán tanto caracteres según el numero obtenido de la expresión que compone el primer
parámetro: std::numeric_limits<std::streamsize>::max() o si se encuentra el carácter de fin de línea '\n'.
En el primer parámetro la función max() que está definida en el archivo de cabecera <limits> devuelve
el valor máximo que puede representar los tipos de datos de C++, en este caso se aplica para un tipo
streamsize (tamaño de flujo). La operación se realiza utilizando la plantilla numeric_limits que también
está definida en la librería <limits>.
La sentencia anterior es recomendable colocarla antes de std::cin.get(); para vaciar los posibles datos
que puedan existir en el flujo de entrada (valores que pudieron haber quedado cuando se realizaron
sentencias de entrada). Si no se vacía el flujo de entrada, la función miembro std::cin.get(); no esperará a
que el usuario presione la tecla [Enter] debido a que extrae un carácter de los que ya se encuentra en el
flujo de entrada.
Para cada uno de los siguientes casos, diga si los cambios realizados producen algún tipo de
error o dan una salida diferente. Si es así, ¿Cuáles son los mensajes de error o la salida que se
obtiene? Explique porqué ocurre dicho error (o errores) o porqué la salida es diferente.
1.
Elimine la línea de código #include <limits>
2.
Cambie el nombre del archivo de cabecera <limits> a <limits.h>
3.
Cambie la sentencia suma = number1 + number2; por suma = number1 - number2; ¿Cómo
clasificaría ese error?
4.
Ejecute el programa, ingrese una cantidad de punto flotante en vez de una entera cuando se
pida la primera cantidad.
5.
Ejecute el programa, ingrese una cantidad de punto flotante en vez de una entera cuando se
pida la segunda cantidad.