C++ es una mejoría sobre muchas de las
características de C, y proporciona capacidades de P.O.O.
(Programación Orientada a Objetos) que promete mucho para
incrementar la productividad, calidad y re-utilización del
software.
En C, la unidad de programación es la función,
con lo cual, se trata de una programación orientada a la acción.
En C++, la unidad de programación es la clase a
partir de la cual, los objetos son producidos. Se trata, pues, de
una programación orientada al objeto.
Las bibliotecas estándar de C++ proporcionan un
conjunto extenso de capacidades de entrada/salida. C++ usa
entradas/salidas de tipo seguro; no podrán introducirse datos
equivocados dentro del sistema.
Se pueden especificar entradas/salidas de tipos
definidos por el usuario, así como de tipos estándar. Esta
extensibilidad es una de las características más valiosas de este
lenguaje de programación.
C++ permite un tratamiento común de
entradas/salidas de tipos definidos por usuario. Este tipo de
estado común facilita el desarrollo de software en general y de la
re-utilización de software en particular.
Realiza la siguiente evaluación diagnostica:
Para comenzar esta sección debemos de conocer
los aspectos mas indispensables para comenzar la programación y
estos son los siguientes.
Qué es la programación?
Mucho del comportamiento y pensamiento humano se caracteriza por
secuencias lógicas. Desde la infancia usted ha estado aprendiendo
cómo actuar, cómo hacer las cosas. Y ha aprendido a esperar cierto
comportamiento de otras personas.
Mucho de lo que hace todos los días lo hace de manera
automática. Por fortuna no es necesario que piense conscientemente
que todo paso requerido en un proceso tan simple como dar vuelta a
la página:
1. Levantar la mano.
2. Mover la mano a la derecha del libro.
3. Asir la esquina derecha de la página.
4. Mover la mano de derecha a izquierda
hasta que la página esté colocada de modo que pueda leer lo que
está sobre la otra página.
5. Soltar la página.
Piense en cuántas neuronas debe encender y cuántos músculos
deben responder, todo en cierto orden o secuencia, para mover su
brazo y su mano. Sin embargo, lo hace de manera inconsciente.
Mucho de lo que hace de manera inconsciente lo tuvo que aprender
una vez. Observe cómo un bebé se concentra en poner un pie antes
que el otro mientras aprende a caminar. Luego, observe a un grupo
de niños de tres años que juegan a la roña.
En una escala más amplia, las matemáticas nunca se podrían haber
desarrollado sin secuencias lógicas de pasos para resolver
problemas y demostrar teoremas. La producción en masa nunca habría
funcionado sin operaciones que tienen lugar en cierto orden. La
civilización se basa en el orden de las cosas y acciones.
Planear o calendarizar el desempeño de una tarea o suceso.
Computadora
Dispositivo
programable que puede almacenar, recuperar y procesar datos.
Programación en computadora
Proceso de planificar una secuencia de pasos para que los
desarrolle una computadora.
Programa
Es un conjunto de instrucciones o estipulaciones (también
llamadas código) ejecutadas por la CPU de la computadora.
Estas instrucciones pueden ser escritas en
muchos lenguajes diferentes. Luego deben ser convertidas a un
lenguaje comprensible para la máquina.
Algoritmo
Series de pasos para resolver problemas. Los
pasos de una solución (instrucciones) permanecen iguales, ya sea
que esté resolviéndolos por computadora o a mano.
Funciones
Son la expresión de los algoritmos en algún lenguaje de
programación específico.
Se vuelven a utilizar las funciones cuando se
necesitan. No es necesario reescribir cada vez las líneas de
código representadas por la función.
Compilador
Un compilador es un
programa que traduce código fuente escrito en un lenguaje de
alto nivel como C++, a un lenguaje legible por la computadora
llamado código objeto, lenguaje de destino o incluso lenguaje
ensamblador.
La construcción de un compilador involucra la
división del proceso en una serie de fases que variará con su
complejidad. Generalmente estas fases se agrupan en dos tareas: el
análisis del programa fuente y la síntesis del programa objeto.
El proceso de compilación toma los archivos .cc,
los preprocesa y los traduce en archivos objeto.
A continuación, el conjunto de archivos objeto es procesado por un
linker. Este programa combina los archivos, añade las bibliotecas
necesarias y crea un ejecutable.
Análisis
Se trata de la comprobación de la
corrección del programa fuente, según la definición del lenguaje
en términos de teoría de lenguajes formales. Incluye las fases
correspondientes al análisis léxico (que consiste en la
descomposición del programa fuente en componentes léxicos),
análisis sintáctico (agrupación de los componentes léxicos en
frases gramaticales ) y análisis semántico (comprobación de la
validez semántica de las sentencias aceptadas en la fase de
análisis sintáctico).
Síntesis
Su objetivo es la generación de la salida
expresada en el lenguaje objeto y suele estar formado por una o
varias combinaciones de fases de generación de código (normalmente
se trata de código intermedio o de código objeto) y de
optimización de código (en las que se busca obtener un programa
objetivo lo más eficiente posible, según su complejidad
computacional o complejidad de Kolmogórov (En la
teoría de la computación, la complejidad de Kolmogórov es el
tamaño o cantidad de información del programa de computadora más
corto que produce cierto resultado): tiempo de ejecución,
espacio durante ejecución, espacio para ser almacenado fuera de
ejecución, etc).
Alternativamente, las fases descritas para las tareas de análisis
y síntesis se pueden agrupar en:
Analizador o front-end: es la parte que analiza el código fuente,
comprueba su validez, genera el árbol de derivación y rellena los
valores de la tabla de símbolos. Esta parte suele ser
independiente de la plataforma o sistema para el cual se vaya a
compilar, y está compuesta por las fases comprendidas entre el
análisis léxico y la generación de código intermedio.
Generador o back-end: es la parte que genera el código máquina,
específico de una plataforma, a partir de los resultados de la
fase de análisis, realizada por este generador.
PARADIGMAS DE PROGRAMACIÓN
Según los conceptos en que se basa un lenguaje de programación
tenemos distintas maneras de aproximarnos a la resolución de los
problemas y diferentes estilos de programación. Podemos clasificar
los lenguajes de programación en varios tipos:
— Imperativos
— Orientados a Objetos
— Funcionales
— Lógicos
Las dos primeras opciones se basan en la abstracción de los
tipos de datos. Básicamente se trata de representar las
características variables de los objetos mediante tipos que el
ordenador pueda tratar, como por ejemplo números enteros o
caracteres alfanuméricos. Nuestro programa será una colección de
algoritmos que opere sobre los datos que hemos modelado.
Estructuras de Programación
Estructura de Secuencia:
La computadora ejecuta líneas de código en el orden en que están
escritas.
Estructuras de Selección: Se
construyen en base a una declaración condicional. Si la condición
es verdadera, ciertas líneas de código son ejecutadas. Si es
falsa, esas líneas no se ejecutan.
Estructuras de Repetición: Se
construyen en base a instrucciones condicionales. Si la condición
es verdadera un bloque de uno o más comandos se repite hasta que
la condición es falsa.
¿Cómo se escribe un programa?
Una computadora no es inteligente. No es capaz
de analizar un problema y proponer una solución.
Un humano (el programador) debe analizar el problema, desarrollar
una secuencia de instrucciones para resolver el problema y luego
comunicarlo a la computadora. ¿Cuál es la ventaja de usar una
computadora si no puede resolver problemas? Una vez que se ha
escrito la solución como una secuencia de instrucciones para la
computadora, ésta puede repetir la solución de manera muy rápida,
una y otra vez. La computadora libera a la gente de las tareas
repetitivas y tediosas.
Para escribir una secuencia de instrucciones que
efectuará una computadora, se debe ir por un proceso bifásico:
resolución de problema e implementación
Pasos para la automatización de un
problema
Planteamiento del Problema
Análisis del Problema
Algoritmo de Resolución
Programación
Ejecución por Computadora
La salida de flujo (entrada/salida) puede ser
ejecutada mediante el operador de inserción de flujo : <<.
Se hace la homonimia del operador << para extraer elementos
de datos de tipos incorporados, para extraer cadenas y para
extraer valores de apuntadores.
Fase
de resolución del problema
Análisis y especificación. Entender
(definir) el problema y lo que debe hacer la solución.
Solución general (algoritmo).
Desarrollar una secuencia lógica de pasos que resuelve el
problema.
Verificar. Seguir los pasos
exactamente para ver si la solución resuelve en realidad el
problema.
Fase de implementación
1. Solución concreta (programa). Traducir
el algoritmo en un lenguaje de programación.
2. Prueba. Ver que la computadora
siga las instrucciones. Después, comprobar de manera manual los
resultados. Si encuentra errores, analice el programa y el
algoritmo para determinar la fuente de errores, y luego hacer
correcciones.
Una vez que se ha escrito el programa,
entra a la tercera fase: mantenimiento.
Fase de mantenimiento
1. Uso. Utilice el programa.
2. Mantenimiento. Modifique el programa para satisfacer
requisitos de cambio o corregir cualquier error que aparezca al
usarlo.
El siguiente segmento es para aquellos que
tienen Windows y no CentOS 9 stream, es la forma de instalación de
compilador C++, en windows, es muchos casos confusa y extensa,
pero intentaremos hacerlo sencillo, y porque windows no tiene
compilador de C++, nativo, para que lo tengas necesitas comprar, y
no es barato, ya sea de Borland, o C++.
Para los ejemplos a usar estaremos usando un
Framework (CodeBlock para la instalación se hace referencia a la
pagina correspondiente de cada compilador con CodeBlock,
la referencia esta hacia el sistema LINUX CentOS Stream 9, pero se
puede usar en Windows, (hay algunos problemas de instalación de
CodeBlock en Windows, si se presentan problemas, se puede intentar
instalar CodeBlocks en 32 bits, en windows), puede usar NetBeans
8,9 o Apache Netbeans 10,11,12.x, o superior, si tienes windows 7
u 8, usa la instalación de Netbeans 8), utilizamos los
compiladores para windows que estan en el programa de paqueteria
de lenguaje C++, de MinGW la instalación de este
software se explicara en los videos qu estan debajo de estas
lineas, ya que implica un proceso extenso y tardado, cuando usas
Windows, y si, este "sistema" se caracteriza por ser muy
impredecible en cuanto a la compilación en C++.
(hare una demostración de instalación de
los mencionados en windows, en no pocas ocasiones produce
problemas)
Si utilizas windows se complica algo, de igual forma te dejo los
enlaces para CodeBlocks de x64, (revisa tu sistema si lo acepta) y
el de x32.
para descargar CodeBlock desde este servidor usa este link, este
ya tiene incluido el MinGW, para CodeBlock, pero es recomendable
instalarlo por separado, (compilador de C++, libre GNU) codeblocks-20.03mingw-setup
si no funcionara o presenta problemas, borralo
(desde panel de control) y usa este otro, también tiene el MinGW
pero este es de 32 bits: codeblocks-13.12mingw-setup-RC1
son para 64 bits y 32 bits respectivamente, o
visita la pagina de Code::Blocks
Otra alternativa es usar NetBeans
o Apache NetBeans, con cualquier
fremework que mencionare puedes trabajar, si usas Windows se
recomienda instalar MinGW minimal, para usar con NetBeans, (de
hecho al instalar codeblocks, y ya tiene incluido el Mingw pero no
es funcional para Apache NetBeans, ya que windows no tiene su
propio compilador de C++, y LINUX ya lo tiene incluido) y debemos
instalar, y tambien el JDK, porque es un soporte para Apache
Netbeans, crear un path, para MinGW, para que localice el
compilador de C++, también puede ser compilado en linea (CLI),
podemos crear el código fuente con un editor de texto en ASCII sin
mayor problema, como puede ser block de notas, Vim, Sublime, Atom,
Notepad++, en cualquier sistema (LINUX, Windows "en Windows se
requiere instalar un compilador en linea de comandos"), la forma
de realizarlo en LINUX es: g++ -Wall origen.cpp -o destino, la
opción -Wall es para que envié mensajes de precaución o error en
el proceso de compilación, y significa (Warning all), también se
puede usar el programa cygwin es un software GNU que
permite simular una máquina LINUX / UNIX directamente en Windows,
el entorno es un CLI, si desea desarrollar desde linea de comandos
te sugiero pasar al directorio de MinGW y el directorio de bin,
ahí están los compiladores (gcc para lenguaje C, y g++ para
compilar en C++), en el ultimo video se muestra como entrar y
confirmar que ahí están los compiladores.
Debido a problemas con el software para realizar los programas
en C++ estoy colocando en los links siguientes las descargas de
los programas a usar en windows, para el caso en LINUX el
procedimiento esta en la unidad 2 de Gestión de sistemas
operativos y virtualizacion en el titulo Netbeans, así como
CodeBlocks, y como sabemos es muy sencillo de instalar en LINUX y
no presenta tantos problemas de instalación.
Para netbeans 8.2 funciona bien para win 7 - win 10 (con windows
11 aun no lo he probado) con sus respectivos soportes de jdk 8 de
x64 y x32.
aquí el video de instalación de Apache NetBeans (sugiero usar la
versión 17, en lugar de la versión 18, esta presentando problemas
a esta fecha 08/2023)
Para el compilador que necesitaras para usarlo en Apache
Netbeans, el paquete que lo instala se llama MinGW el proceso dura
mucho tiempo y he recortado el video así que, lo que veas es mas
extenso dependiendo de la velocidad de tu computadora y si windows
no se pone lento, Video instalación MinGW,
si no logras descargar el MinGW esta en este lugar.
selecciona en : Apache-NetBeans-17-bin-windows-x64.exe
(SHA-512, PGP ASC), y como puedes observar
solo esta para x64, ya no hay soporte para x32.
Intenta descargarlo desde la pagina que te mencione pero por si
no lo lograras por alguna razón, te dejo el link para que lo
descargues aquí, pero
intenta descargarlo desde la pagina del Apache Netbeans.
Aquí esta el video de instalación de
Cygwin, y la forma de ingresar al compilador en linea de
comandos de MinGW, es conveniente que vayas realizando los
ejercicios con algunos de los 3 métodos, los resultados en CLI,
pueden diferir de los realizados en Apache NetBeans y de
Code::Block, y se debe al tipo de interfase usada, por si te
interesa tenerlo a Cygwin y que te vayas entrenado en los comandos
de LINUX/UNIX solo es un pequeño ejemplo, ya teniendo instalados
el framework de CodeBlock, NetBeans y/o Cygwin (opcional) ,
procedemos a iniciar el curso.
si tienes windows 7 u 8.0 /8.1 puedes usar esta versión que trae
incluido java de netbeans 8.2
Elementos de programas C++
Los programadores desarrollan soluciones para
problemas por medio de un lenguaje de programación. Examinamos las
reglas y símbolos que conforman el lenguaje de programación C++.
Asimismo, se revisan los pasos requeridos para crear un programa y
hacer que funcione en una computadora.
Aplicaciones y usos de C++
Las aplicaciones del lenguaje C++ son muy
extensas. Podemos nombrar que navegadores WEB, Sistemas
operativos, Bases de datos, bibliotecas, aplicaciones gráficas,
nubes, videojuegos, compiladores, etc están escritos o tienen
bastante de su estructura, programada C ++. Vamos a hablar de
algunas de estas aplicaciones:
Bases de Datos: MySQL, una de las bases de datos más utilizadas
está escrita en C++.
Navegadores WEB: Utilizan C++ porque necesitan rapidez a la hora
de mostrar los resultados en pantalla.
Sistemas operativos: La columna principal tanto
de Windows, como Linux o Mac OS, están escritas en C++. Su
potencia y rapidez lo hace un lenguaje de programación ideal para
programar un sistema operativo.
Compiladores: los compiladores de muchos lenguajes de
programación están escritos en C++.
Videojuegos: C++ es utilizado aún en el mundo de
los videojuegos, bien para programar motores gráficos o para
alguna parte concreta del videojuego.
También tiene otras aplicaciones como en máquinas médicas,
relojes inteligentes, etc. por su capacidad de estar cerca del
lenguaje máquina que otros lenguajes de alto nivel.
Por todos estos usos y aplicaciones podemos concluir que la
importancia del lenguaje C++ es muy grande y está presente en
muchos sitios.
Estructura de un programa C++
Hay cuatro estructuras básicas para expresar
acciones en un lenguaje de programación: secuencia, selección,
ciclo y subprograma. Se dice que los subprogramas permiten
escribir por separado partes del programa y luego ensamblarlas en
una forma final. En C++, los subprogramas se denominan
funciones,(función: Subprograma en C++).
Un programa C++ es una colección de una o más funciones. Cada
función realiza alguna función particular y, de manera colectiva,
todas cooperan para resolver un problema completo. (algunos
autores los llaman subprogramas y otros funciones, pero hacen lo
mismo el nombre es de lo de menos).
Cada programa C++ debe tener una
función llamada main().
La ejecución del programa comienza siempre
con la función main. Se puede pensar en main() como el
maestro, y las otras funciones como los sirvientes. Cuando
main(), quiere que la función Square realice una tarea, main()
llama (o invoca) a Square. Cuando la función Square completa
la ejecución de sus sentencias, de manera obediente devuelve
el control al maestro, main , para que éste continúe la
ejecución.
La función main es imprescindible en cualquier programa
C/C++ representa el punto de inicio de su ejecución. Por lo
general, su declaración adopta la forma:
int main();
aunque en realidad, el módulo de inicio la invoca con dos
parámetros (recibidos a su vez del SO), denominados
tradicionalmente argc y argv, contracciones de "argument
count" y "argument vector" respectivamente. El primero es un
entero que representa el número de comandos que se pasan; el
segundo es un puntero a una matriz de cadenas literales de
distintas longitudes (es decir: puntero a matriz de punteros);
cada una de estas cadenas representa en último extremo los
comandos iniciales que se quieren pasar al programa,
generalmente para controlar aspectos de su comportamiento. Así
pues, la declaración más genérica de main es del tipo:
int main(int argc, char* argv[])
Nota: el Estándar establece que el compilador debe aceptar
para main cualquiera de las dos formas: int main() y int
main(int argc, char* argv[]).
Restricciones
La función main() adolece de ciertas limitaciones que la
diferencian del resto de funciones C++:
No puede ser invocada explícitamente a lo largo del
programa, es invocada de forma automática por el módulo de
inicio
No puede obtenerse su dirección, por lo tanto no pueden
declararse punteros a ella:
int (* pmain)() = &main; // Error!!
No puede ser sobrecargada
No puede ser declarada como inline
main debe estar en el espacio global de una de las unidades
de compilación del programa, lo que significa que no puede
pertenecer a una clase.
Valor devuelto por main
En muchos sistemas operativos el valor
devuelto por la función main es utilizado como control de
estado para el entorno desde el que se ha ejecutado el
programa (este valor es considerado el estado de retorno del
programa). En UNIX, MS-DOS y MS Windows, los 8 bits más bajos
del valor devuelto son pasados al programa invocante o al
intérprete de comandos. Este "estado de retorno" se utiliza en
ocasiones para cambiar el curso de un programa, un proceso por
lotes o un guión para el ejecutor de comandos.
Algunos compiladores pueden generar un aviso
de error si se intenta compilar un programa cuya función main
no devuelva un int. Por contra, algunas plataformas pueden
provocar fallos cuando estos programas arrancan o a su
terminación, ya que esperan un int (valor entero positivo) de
retorno.
En los programas C++ no es necesario devolver nada desde la
función main, aunque en realidad la definición de esta, sea
int main(). La razón es que el Estándar garantiza que si main
llega a su final alcanzando el corchete de cierre "}" sin
haber encontrado una sentencia return, el compilador debe
devolver automáticamente un 0 indicando un final correcto, de
forma que en ausencia de ningún retorno el compilador
proporciona automáticamente un return 0;
Nota: no obstante lo anterior, el
comportamiento concreto varía de un compilador a otro. Por
ejemplo, un programa en el que se alcanza el corchete de
cierre de la función main sin ninguna sentencia de retorno
compila sin dificultad ni aviso de ningún tipo en Borland C++
5.5, mientras que MS Visual C++ 6.0 avisa: warning C4508:
"main" : function should return a value; "void" return type
assumed.
En cualquier caso, es práctica de buena
programación incluir un valor de retorno para la función main.
Tradicionalmente 0 significa una terminación correcta del
programa, cualquier otro valor es señal de terminación anormal
(error o excepción).
Si el programa termina por una invocación a
la función exit, el valor devuelto por main es el argumento
pasado a exit. Por ejemplo, si el programa contiene la llamada
exit(1), el valor devuelto es 1.
Existen solamente tres valores completamente
estándar y portables que puedan utilizarse como retorno para
la función main, o como argumento para la función exit:
El clásico entero de valor 0.
La constante simbólica EXIT_SUCCESS
definida en <stdlib.h>
La constante EXIT_FAILURE definida en
<stdlib.h>
Si se utiliza cualquiera de los dos valores 0 o EXIT_SUCCESS
se garantiza que el compilador los trasladará a un código que
sea considerado terminación correcta por el Sistema Operativo.
Si se utiliza EXIT_FAILURE el compilador lo trasladará a un
código que será considerado como terminación errónea por el
Sistema Operativo.
Algunos sistemas, como Unix, MS-DOS y Windows, truncan el
entero pasado a exit o devuelto por main, a un unsigned char,
con objeto de utilizarlos en el fichero de órdenes del
intérprete de comandos, en un fichero de ejecución por lotes,
o en el proceso que invocó el programa. Algunos programadores
utilizan valores positivos para indicar diferentes razones de
fallo, excepción o finalización del programa, pero estos usos
no son necesariamente portables ni funcionan en todas las
implementaciones. Sin embargo C++ proporciona la posibilidad
de devolver valores que son totalmente portables mediante la
función atexit, por lo tanto return puede ser return 0; o
bien, return EXIT_SUCCESS; // El programa terminó la
ejecución debidamente.
NOTA: PARA LA EVIDENCIA DE TRABAJO
1) PUEDES USAR LOS TRES SISTEMAS DE
DESARROLLO QUE TE PRESENTO
2) PUEDES USAR 1 SOLO, DE LOS PROCESOS
DE DESARROLLO.
(EN ESTE CASO INDICARME POR MEDIO DEL
CORREO CUAL USARAS, EL SISTEMA DE DESARROLLO PUEDE SER EN
LINUX, windows, MacOS, PREFERENTEMENTE Y TENDRAS MAS PUNTOS
SI LO REALIZAS DESDE LINUX O MacOS.
3) EN EL CASO DE USAR WINDOWS Y USES
CYGWIN PARA EMULAR UNA TERMINAL DE UNIX, LOS RESULTADOS
PUEDEN SER ALGO DIFERENTES A LO ESPERADO
4) AL LLEGAR AL FINAL DE ESTA UNIDAD,
ENVIA POR CORREO, LOS ARCHIVOS DE LOS EJERCICIO SIN
COMPILAR, ES DECIR LOS QUE TIENEN EXTENSION .CPP, CON TU
NOMBRE Y FECHA DE REALIZACION, (EN EL INTERIOR DEL ARCHIVO)
SI LOS COPIASTE DE UN COMPAÑERO, ME DARE CUENTA MUY FÁCIL,
REVISARE LOS EJERCICIOS EN LINUX, Y AHI PUEDE VERSE SI ES
COPIA DE OTRO.
Entrada
y salida de datos en C++. Uso de cin, cout, scanf y printf
La entrada y salida de datos en C++ es simple
(al menos para los casos más comunes). Con esto hago una
comparación entre C++ y Java, pues leer una entrada del usuario
por teclado en C++ es bastante simple mientras que en Java implica
una serie de conceptos adicionales que la hacen un tanto más
complicada.
Por suerte para nosotros en esta sección veremos cómo leer por
teclado en C++, en otras palabras, asignar a una variable el valor
que el usuario escriba por el teclado. Adicional a esto veremos
también cómo mostrar texto por pantalla en C++, es decir, salida
de datos.
Vamos a comenzar primero con aprender a mostrar texto por pantalla
en C++.
Los programas en C++ por lo general incluirán la
instrucción iostream (ver Nota 1, al final de esta pagina) que es
una biblioteca que contiene la función pre formada de la
instrucción cout, esto es que las instrucciones que se dan a los
programas ya están diseñadas y están en bibliotecas de "funciones"
esta funciones las realizan los diseñadores del lenguaje de
programación, para usar la función cout debemos "llamarla" desde
su biblioteca, para que sea incluida en nuestro programa que
estamos realizando, y para ello usamos la estructura #include <biblioteca>.
Si usas la directiva #include <iostream.h>
o #include <iostream> en sus programas, automáticamente la
iostream pone a su disposición los objetos cin, cout, clog y cerr
en el ámbito estándar (std), de tal manera que usted puede
comenzar a enviar o recibir información a través de los mismos sin
siquiera preocuparse de su creación.
Asi que cuando, queremos pedirle algún dato al
usuario primero debemos hacerle saber lo que queremos que ingrese
y para hacérselo saber debemos mostrarle un mensaje con las
indicaciones, por tal motivo es importante primero saber mostrar
texto en pantalla en C++ y luego a leer texto por teclado en C++.
include no son necesariamente intercambiables.
#include <archivo>
Este tipo de include intenta localizar el archivo en los
directorios del sistema. Si el archivo en cuestión no es posible
encontrarlo la compilación terminará con un error.
#include "archivo"
Este otro include busca el archivo en la carpeta donde se
encuentra el archivo actual. Si la búsqueda resulta infructuosa
entonces se intenta localizar el archivo en los directorios del
sistema. Este include es, por tanto, más completo que la versión
con brackets.
Pese a que un proyecto puede compilar perfectamente si todos los
includes se escriben con comillas, no es una práctica
especialmente recomendable. Hay que tener en cuenta que las
compilaciones en c++ pueden ser largas hasta el aburrimiento.
Obligar al compilador a realizar búsquedas genéricas no ayuda a
que el tiempo de compilación se reduzca. Incluir las librerías del
sistema con brackets reduce el abanico de búsqueda y eso repercute
en un tiempo de compilación sensiblemente menor (obviamente cuanto
más grande sea el proyecto más se notará este efecto).
Por otro lado, distinguir entre includes locales
(con comillas) y del sistema (con brackets) aumenta ligeramente la
legibilidad del código. Permite saber, de un rápido vistazo, si el
archivo en cuestión se encuentra en el directorio del proyecto o
si, en cambio, se corresponde con una librería externa.
Salida de texto por pantalla en C++
Mostrar texto por pantalla en C++ es muy simple. Para imprimir
una salida de texto en C++ se hace uso de la instrucción cout (la c es de lenguaje c, out
(salida), por lo que cout salida del lenguaje c), junto con <<. Es importante tener en cuenta
que la instrucción cout siempre va acompañada de << para
controlar el flujo de datos que sale. No te fijes mucho en ellos,
solo ten siempre presente que cout viene acompañado de <<
para tener cout << como resultado.
Como primer ejemplo usaremos lo siguiente: (lo llamaremos
ejercicio1.cpp)
En CodeBlock haz clic aquí para que observar el vídeo de como
iniciamos en CodeBlock.
deberás crear un directorio para guardar
los ejercicios, y sus programas ejecutables, recuerda que es
posible que los resultados en CLI pueden ser algo diferentes a
los que explicamos aquí, el nombre del directorio para los
archivos generados en Code::Blocks puede ser algo asi:
prog_code_block, el de de NetBeans genera sus propios
directorios en base al proyecto que realices, y los de CLI
puedes poner como nombre progs_c++, pero tu tienes la última
palabra de poner los nombres que mejor te sientas que
organices tus archivos.
LAS EVIDENCIAS SERAN POR EJERCICIO, LA
EJECUCION DEL PROGRAMA CAPTURA DE PANTALLA, Y CODIGO FUENTE QUE
REALIZASTE, ES DECIR LA IMAGEN QUE OBTUVISTE Y EL CODIGO FUENTE
QUE USASTE PARA REALIZAR LA OPERACIÓN, AMBOS EN EL CORREO,
COMPRIMIDOS CON ZIP O RAR, CON SU NOMBRE, Y EJERCICIO
DESARROLLADO, EJEMPLO: agripino_salazar_martinez_ejercicio1.zip
Ó agripino_salazar_martinez_ejercicio1.rar, para revisarlos y yo compilarlos, en sus
carpetas de evidencias de cada uno. (NO QUIERO LOS EJECUTABLES,
PORQUE EN LA MAYORIA DE LOS SISTEMAS DE CORREOS NO PERMITE EL
ENVIO DE EJECUTABLES CON EXTENSION .EXE, EN LOS DE LINUX NO HAY
PROBLEMA, SI QUIEREN ENVIARLOS O NO ESTA BIEN.
Y como se realiza en linea de comando (usamos el editor nano,
pero pueden usar vi, vim) (CLI)
Para compilar el programa principal y poder crear un archivo
ejecutable se utilizará la siguiente instrucción.
g++ -Wall ejemplo.cpp -o salida
este comando incluye la bandera -Wall esta bandera habilita los
mensajes de advertencias en el código.El programa es:
//programa ejercicio1.cpp
// estos símbolos de // significan comentarios
// no se usan como parte del programa pero son útiles cuando estas
diseñando
// para conocer como estas desarrollando tu programa y así
encontrar secciones que necesitas o
//bien operaciones en el programa
#include "iostream.h" // esta linea indica que debemos de
incluir una biblioteca para poder usar cout , ya es una función
creada previamente
using namespace std;
int main(int argc, char* argv[])
{
//Se muestra un mensaje por pantalla.
cout << "Hola Mundo" << " Desde el
Inicio ." << "\n"; // se pueden concatenar los mensajes
return 0;
}
Nota: en algunas instalaciones dependiendo de la
forma de esta, es posible que la linea #include "iostream.h"
marque un error al iniciar la compilación, si es el caso use
#include "iostream" para que sea corregido el problema de la
asignación del .h, por lo tanto deberás de omitir esta extension,
esto se debe a la ruta (path) donde se encuentran los headers
(encabezados) de las bibliotecas.
Para CodeBlocks
Para NetBeans
Para CLI con g++
En este caso realizamos un archivo de texto con
el editor nano, o vim el cual tiene características para marcar
por colores las instrucciones especificas.
La compilación en linea de comando (CLI) LINUX, UNIX es de la
siguiente forma:
Teniendo el programa fuente (archivo con extensión .cpp) se
compila de este forma g++ -Wall ejercicio1.cpp -o ejercicio1
g++ es el compilador de LINUX (es el alias tradicional de
GNUC++,
un conjunto libre de compiladores de C++.
Forma parte del GCC, GNU Compiler Collection.
Para ejecutar el programa llamado ejercicio1 se escribe
./ejercicio1, que es la forma de ejecutar los ejecutables en UNIX
/ LINUX
El resultado:
El ejemplo que acabas de ver es bastante sencillo.
Debes saber de los espacios de nombres de C ++.
En programación, no podemos tener variables, funciones, etc. con
el mismo nombre. Entonces, para evitar esos conflictos, usamos
espacios de nombres (namespace).
Entonces, para un espacio de nombres, podemos tener un nombre
único y ese mismo nombre también se puede usar en otro espacio de
nombres. El siguiente ejemplo muestra dos espacios de nombres.
namespace A
{
int x = 5;
void printX()
{
// instrucciones de la función inicia aquí
cout<<x<<endl;
}
}
namespace B
{
int x=10;
void printX()
{
// instrucciones de la función inicia aquí
cout<<x<<endl;
}
}
Hay un carácter que es "\n" que permite el salto
la siguiente renglón, y endl, puede realizar lo mismo pero
adicionalmente borra el buffer que esta usando el sistema para
almacenar el mensaje, así que se puede usar endl; o "\n"
Esto es que podemos usar las mismas variables en
el programa pero el "espacio de trabajo" sera diferente por lo
cual las variables tienen ámbitos de acción diferentes.
"Usando using namespace
std" significa que usamos el espacio de nombres llamado
std. “Std” es una abreviatura de estándar. Eso significa que
usamos todas las cosas con en el espacio de nombres "std". Si no
queremos usar esta línea de código, podemos usar las cosas en este
espacio de nombres como este. std :: cout, std :: endl.
Si no se utiliza este espacio de nombres, el
compilador busca cout, cin y endl, etc. El programa no puede
identificarlos y, por lo tanto, arroja errores.
iostream es un archivo (bliblioteca) que tiene
funciones definidas como cout, endl, etc. Si necesitamos usarlos,
debemos agregar ese archivo (biblioteca). Entonces, básicamente,
#include "iostream" significa copiar y pegar el código en ese
archivo en el programa final que contendrá las funciones para
manejo de datos. Pero si intentamos usar cout, endl en nuestro
código sin especificar el espacio de nombres, arrojará un error,
porque estos están definidos en el espacio de nombres std en el
archivo iostream.h (la terminacion .h significa header
"encabezado") y no encuentra la biblioteca de estas funciones.
(Nota #include
<iostream.h> y #include "iostream.h" cual es la diferencia
de < > y de " ", #include <archivo> Este tipo de
include intenta localizar el archivo en los directorios del
sistema. Si el archivo en cuestión no es posible encontrarlo la
compilación terminará con un error. Ahora bien si, #include
"archivo" este otro include busca el archivo en la carpeta donde
se encuentra el archivo actual. Si la búsqueda resulta
infructuosa entonces se intenta localizar el archivo en los
directorios del sistema, donde se esta registrado por medio del
path. Este include es, por tanto, más completo que la versión
con brackets.)
Entonces, a modo de
resumen, por qué necesita tanto el archivo de encabezado como el
espacio de nombres para ejecutar un programa simple de C ++,
porque el programa necesita conocer la definición de las
funciones (que va a realizar). Está definido en el archivo de
encabezado. Por lo tanto, se debe incluir el archivo de
encabezado (#include "iostream.h"), también puede ser de esta
forma : #include "iostream", y se necesita un espacio de
nombres (using namespace std;)
porque si se usa una funcionalidad como cout, pero no está
definida en el alcance actual (es lo que se esta estipulando en
ese momento del encabezado), el compilador necesita saber dónde
verificar. por lo que es necesario incluir el espacio de
nombres. Porque estamos escribiendo el código fuera del espacio
de nombres estándar.
Tal como habrás notado el operador "<<" se
usa para concatenar (unir) dos cadenas de texto por eso el
resultado es el obtenido. Luego se usa "\n" que indica un salto de
línea. No es obligatorio pero es recomendable.
return 0;
o en su defecto
return EXIT_SUCCESS;
esta puede parecer extraño, esto indica que el
programa regresa al SO un codigo de main(), (que ya se explico
anteriormente) que tiene valores de 0 a 255, si regresa un 0
es que todo esta bien, (si el programa regresa un valor distinto 0
que puede ocurrir antes de finalizar el programa este se
detendría, dependiendo del el valor que regrese al SO, 1, 2, 3...
etc cada uno de ellos representa un mensaje en concreto, siendo 0
que todo esta correcto.
También están presentes { } estos indican que
hay un ámbito de acción (área de ejecución especifica, puede haber
varios de ellos y cada uno indican un área particular de
ejecución)
Ejemplo 2 de impresión de texto por pantalla en C++, usando cout
compilamos y ejecutamos, el nombre es ejercicio2.cpp
//programa ejercicio2.cpp
#include <iostream.h> // esta linea indica que debemos de
incluir una biblioteca para poder usar cout , ya es una función
creada previamente
#include <string.h> // corresponde a la
biblioteca predefinida para uso de series de caracteres
using namespace std;
int main(int argc, char* argv[])
{
//El valor de esta variable se mostrará en
pantalla
string salida1 = "Ejemplo de salida";
//Este valor también se mostrará en pantalla.
int numero = 2;
//Estos valores se concatenarán en una única
salida
string salida2 = "Desde Programacion
C++.";
//Se concatenan y muestran los valores por
pantalla con cout<<
cout << salida1 << " " <<
numero << ". " << salida2 << "\n";
return 0;
}
Ahora incluimos el concepto de variable en :
string salida1, int numero = 2, string salida2.
Una variable es un espacio en la memoria, en el
cual el programador asigna un valor determinado por el tipo de
dato que el lenguaje de programación va soportar. Y son necesarios
para tratar datos.
Para CodeBlocks
Para Netbeans:
Nota: debemos de cerrar el proyecto anterior antes de seguir:
1.- Seleccionar el proyecto anterior (ejercicio1), y clic con el
botón derecho
2.- y seleccionar Close del menu que se despliega:
Debera de realizar esto cuando termine el programa para preparar
el nuevo programa, de lo contrario se iran agregando en el panel,
lo que se extendara demasisdo, comenzamos con el nuevo ejercicio:
En CLI
En este ejemplo de salida por pantalla hemos visto que también
es posible usar la instrucción cout para mostrar en pantalla el
valor de las variables así sean numéricas o cadenas de texto.
También vimos que podemos concatenar los valores de esas variables
entre sí y también concatenarlas con otros valores directamente
(espacios, puntos, símbolos, etc.).
Ahora, veamos los mismos ejemplos, pero
usando la función printf de C++, la cual también es útil para
imprimir valores por pantalla le llamaremos ejercicio3.cpp
// programa ejercicio3.cpp
#include <iostream.h>
using namespace std;
int main(int argc, char* argv[])
{
//Se muestra un mensaje por pantalla.
printf("Hola Mundo");
printf(" Desde Curso C++");
printf("\n");
//Alternativamente
printf("Hola Mundo Desde Curso C++.\n");
return 0;
}
Es posible que al compilar muestre un
error, adelante explicamos como corregirlo y el porque
del error, sin embargo en versiones mas recientes la biblioteca,
que falta esta incluida en iostream, pero aun así prueba este
programa. (en C, es necesario usar otros encabezados para poder
usar printf)
Para CodeBlock
Para NetBeans
En (CLI)
mostrara un error el compilador en las lineas:
printf("Hola Mundo");
printf(" Desde Curso C++");
modifique el programa a esta forma si se presenta el error, pero
aun así estudiemos este código:
// programa ejercicio3.cpp
#include <iostream.h>
#include <stdio.h> // este es
el cambio significa que incluya la biblioteca de Standard Input
Output
#include
"stdio.h" // tambies es posible de esta otra forma
using namespace std;
int main(int argc, char* argv[])
{
//Se muestra un mensaje por pantalla.
printf("Hola Mundo");
printf(" Desde Curso C++");
printf("\n");
//Alternativamente
printf("Hola Mundo Desde Curso C++.\n");
return 0;
}
Esto se debe al compilador usado
Para CodeBlock
Para NetBeans
Para CLI
Como puedes ver, al ejecutar el código, el
resultado sería el mismo del ejemplo de cout: "Hola Mundo Desde
Curso C++", con su respectivo salto de línea al final. Sin
embargo, el código es bastante diferente, pues printf no
nos permite concatenar valores directamente en un solo llamado,
así que debemos hacer llamadas sucesivas para imprimir cada parte
del mensaje. Por supuesto, podrías simplemente hacer un solo
llamado a printf con el mensaje completo y sería mucho
más sencillo.
Adicionalmente, los llamados a printf requieren que los valores
estén al interior de los paréntesis (), pues printf es más que una
función, que una instrucción propia heredada de C.
Es cuestión de gustos, pero siempre me ha parecido que cout
simplifica bastante las cosas.
Veamos ahora el segundo ejemplo usando printf, porque la cosa se
complica:
Ejemplo 2 de impresión de texto por pantalla en C++, usando
printf, le llamaremos ejercicio4.cpp
int main(int argc, char* argv[]) // recordemos que puede ser int
main() o simplemente main(), cuando no se define en C++ lo
asigna como int al elemento asignado
{
// la biblioteca string
permite el uso de cadenas de caracteres
string salida1 = "Ejemplo de salida"; //El
valor de esta variable se mostrará en pantalla
int numero = 2; //Este valor también se
mostrará en pantalla.
string salida2 = "Desde Curso C++"; //Estos
valores se concatenarán en una única salida
//Se concatenan y muestran los valores por
pantalla con parámetros de printf
printf("%s %d. %s \n", salida1.c_str(),
numero, salida2.c_str());
return 0;
}
Para CodeBlocks
Para NetBeans
Para CLI
Prueba el código anterior comentando la
siguientes lineas:
//#include <string.h>
//#include <stdio.h>
Evidencia enviar una
captura de pantalla con el resultado de comentar estas lineas, y
porque sucede esto.
En este ejemplo usando printf, puedes ver que
inicialmente todo es igual, pero al momento de imprimir, todo
cambia. Cuando necesitas pasar valores a printf, lo haces con un
"%" seguido de una letra. En el caso de un string se usa s (%s) y en el caso de un número, se usa
d (%d). Y luego, se pasa como una
serie de argumentos, cada uno de los valores a usar en ese mismo
orden.
Ahora bien, la cosa es aún más compleja en el caso de string,
porque printf no soporta el uso de string, así que debemos pasar de un apuntador a una serie de char. Por
suerte, eso se consigue llamando a la función "c_str()" propia de
string.
c_str devuelve una const char* que apunta a una cadena terminada
en cero (es decir, una cadena de estilo C). Es útil cuando se
quiere pasar el "contenido" de una std::string a una función que
espera trabajar con una cadena estilo C.
Ya tenemos claro cómo mostrar texto por pantalla en C++ ahora
haremos uso de este concepto y veremos cómo leer texto por teclado
en C++. Veamos:
Entrada o lectura de datos en C++
Tal como mencioné hace un momento, la lectura de
datos en C++ es bastante simple. Leer datos por teclado en C++ se
hace usando el comando cin >> es importante notar el uso de
los dos signos >> que son usados para controlar el flujo de
datos. No te preocupes mucho por ellos, solo ten en cuenta que
cada vez que vaya a usar la instrucción cin debes agregarle
>> para quedar con un cin>>. Utiliza (in)
entrada y como estamos programando en C++ le añadimos la letra C
al comienzo quedando así cin>> (sin olvidar los >>).
Veamos unos ejemplos simples para leer datos en C++. Recuerda como
dije más arriba que lo ideal para leer datos es indicarle al
usuario qué es lo que esperamos que ingrese por lo que en estos
ejemplos usaremos también lo recién aprendido (mostrar texto por
pantalla), lo llamaremos ejercicio5.cpp, al escribir su monbre
completo solo tomara los datos hasta que encuentre un espacio.
int main(int argc, char* argv[])
{
cout << "Hola! Este es un ejemplo en
C++" << "\n" << "Por favor ingrese su nombre: ";
//La instrucción \n es un salto de línea
Mostrando los textos separados
string nombre; //En esta variable estará almacenado
el nombre ingresado.
cin >> nombre; // lee el nombre desde el
teclado
cout << "\n" << "Bienvenido al sistema
" << nombre << ". Gracias por usar nuestra
aplicación" << "\n";
return 0;
}
Para CodeBlocks
Para NetBeans
Para CLI
En este ejemplo hemos hecho un pequeño sistema
de bienvenida personalizado para el usuario leyendo el valor por
teclado de su nombre, (notese que solo recibe el primer grupo de
caracteres hasta el espacio despues lo demas queda ignorado).
En el comando cin, y después >>, el nombre
de la variable en la cual se almacenará el valor que el usuario
ingrese. Por tal motivo primero se declaró una variable llamada
nombre y luego se usó cin >> nombre indicando que lo que el
usuario ingrese se almacenará en dicha variable.
Ejemplo 2 de lectura de datos en C++, usando cin, usaremos el
nombre de ejercicio6.cpp
cuando se usan múltiples operadores para exhibir
información de esta manera, C++ la presenta tal como se ve en la
instrucción es decir de izquierda a derecha.
Cuando se se usa cin para leer datos del teclado cadena de
caracteres tal como nombre, cin usa los espacios para separar las
cadenas de texto, para leer texto separadas por espacios use
getline, el cuan se usara mas adelante, este programa sera
ejercicio6.cpp
Para CodeBlock
Para NetBeans
Para CLI: (se vera
una variacion en el momento de salida del resultado)
pero podemos hacer un pequeño programa para poder usar dos
textos separados usando cin. // programa test1.cpp
// cin para dos textos
// programa test1.cpp
#include <iostream.h>
using namespace std;
int main(void) // en C++ el concepto de no existencia o no
atribución de un tipo en una variable o declaración. Es decir, una
función declarada como void
// no devolverá
ningún valor, en este caso no recibe ningun valor como parametro
{
char nombre[64];
char apellido[64];
cout << "Su nombre y apellido: ";
cin >>nombre>>apellido;
cout << "Hola "<<nombre <<" "<<apellido;
}
Para CodeBlocks
Para NetBeans
Para CLI
Se plantea que tienes un caso similar al anterior, pero en esta
ocasión se están solicitando números y luego realizando
operaciones matemáticas con ellos.
Vamos ahora a hablar un
poco del uso de scanf para leer valores y algunas
dificultades que esto presenta.
Uso de scanf para leer valores y cadenas de
texto (string) en C++
El operador scanf al igual que printf
fueron ideados para el lenguaje C (no para C++), por lo cual su
uso es más primitivo y, en cierto modo, complejo. Leer datos con
scanf implica comprender un poco el concepto de punteros y
particularmente en el caso de string, se complica aún más, pues
debemos convertir ese string en un array (arreglo de datos, matriz
) definido por caracteres (char).
Vamos a ver un único ejemplo sobre el uso de scanf y string en C++
para quedar claros acerca de estas dificultades llamaremos a este
programa ejercicio7.cpp
int main(int argc, char* argv[])
{
char temporal[100];
printf("Tu nombre?\n");
scanf("%100s", temporal);
string nombre = temporal;
printf("Te doy la bienvenida %s", nombre.c_str());
return 0;
}
Para CodeBlocks
Para NetBeans
Para CLI
Se ve, que necesitamos seguir usando la sintaxis
tipo "%s" para leer una serie de caracteres, pero en esta ocasión
debimos además especificar el tamaño del mismo (100).
Adicionalmente, en los siguientes argumentos de scanf, pasamos
entonces el nombre de la variable a la cual asignar el valor
ingresado por el usuario
Ahora, es un código un tanto curioso. Y siendo
sincero, el uso de string es completamente innecesario en ese
código (por desgracia). Tanto scanf como printf nos obligan a usar
tipos muy primitivos, (#include "stdio.h") como char, así que si
queremos usar string es poco lo que podemos hacer, pues aunque en
nuestro código finalmente hemos usado string, en realidad se trata
de un array de 100 caracteres (char) disfrazado.
El código funciona y te permitirá entonces leer
valores por medio de scanf y asignarlos a una variable. Esto
funciona muy bien con números, pero con string o básicamente en
este caso un array de caracteres, debemos lidiar con tamaños
constantes (como el 100 que tenemos ahi).
Algunas recomendaciones y comentarios al leer y escribir datos
en C++
Primero que todo, aunque los puedes usar, no recomiendo para
nada el uso de scanf y printf, pues complican demasiado el código
y pierdes mucha flexibilidad. En realidad, tanto scanf como printf
son de C y no de C++, así que deberías usar siempre cout y cin en
lugar de printf y scanf (respectivamente), no tienes razones para
complicarte la vida sin necesidad.
Finalmente, recuerda siempre que cin va acompañado de ">>",
mientras que cout usa "<<" (notar que van en sentido
contrario). En realidad, cin dirige el flujo de datos hacia la
variable (por ello va a la derecha ">>"), mientras que cout
lo dirige hacia la salida del sistema (por eso va hacia la
izquierda "<<").
Una vez más, el uso de printf y scanf no es recomendable, porque
además de ser bastante más complejos, pueden incluso acarrear a
problemas de seguridad en tus programas. La complejidad de estas
librerías es simplemente innecesaria en los tiempos actuales.
Para utilizar entradas/salidas de flujo, se debe incluir el
archivo de cabecera iostream.h o iostream
Aunque la mayoría de los programas C++ que pueden encontrarse
utilizan los flujos I/O cin y cout, también se
definen los flujos I/O cerr y clog se describen
estos flujos:
FLUJO
PROPOSITO
EJEMPLO
cin
Entrada de teclado
cin >> nombre;
cout
Salida de pantalla
cout<<"Hola mundo";
cerr
Salida a dispositivo de error
standard
cerr<<"error critico";
clog
Salida almacenada
temporalmente a error estandard
clog << "mensaje de
error";
Salida
con formato
Para dar formato a los datos que se muestran por
pantalla, C++ asocia con el stream de salida un conjunto de
manipuladores que permiten modificar la forma en la que son
visualizados los resultados.
Un manipulador equivale a una llamada a una función.
Algunos de los manipuladores más comunes son los siguientes:
dec
conversión a decimal
hex
conversión a hexadecimal
oct
conversión a octal
skipws
extrae un espacio en blanco inicial
endl
se imprime un "\n" y
se vacía el buffer de salida
flush
se vacía el buffer de salida
setw(int w)
establece
la anchura mínima de campo
setprecision(int p)
establece el número de cifras significativas, por defecto 6.
setfill(char ch)
establece el carácter de relleno
left
la salida se alinea a la
izquierda
rigth
la salida se alinea a la derecha
internal
se alinea el signo y los caracteres
indicativos de la base por la izquierda y las cifras por la
derecha
showbase
se muestra la base de los valores numéricos
showpoint
se
muestra el punto decimal
uppercase
los caracteres de formato aparecen en mayúsculas
showpos
se
muestra el signo (+) en los valores positivos
scientific
notación científica para coma flotante
fixed
notación normal de C++ para coma flotante
setiosflag(long i)
establece una lista de flags de formato
resetriosflag(long i) suprime
una lista de flags de formato
Los manipuladores pueden tener argumentos o no tenerlos. Los
manipuladores sin argumentos (endl, flush, etc.) están definidos
en iostream. Los que tienen argumentos están declarados en
iomanip.
Un manipulador sólo afecta al stream (cin, cout, etc.) al que se
aplica.
Un manipulador en C++ se utiliza de la forma:
cout << hex << 100;
cout << setw(10) << “Hola” << endl;
El efecto de los manipuladores permanece en el stream
correspondiente hasta que se cambian por otro manipulador, a
excepción de setw(n) que hay que introducirlo en el flujo antes de
cada dato al que se le quiere aplicar ese ancho de campo.
// manipuladores1.cpp
//*********************************************************
// Ejemplo de uso de manipuladores setfill y setw
//*********************************************************
#include <iostream>
#include <iomanip> // define
diferentes manipuladores
using namespace std;
int main(void)
{
cout << setfill('.'); // manipulador de relleno,
aqui deberas de revisar en windows si funciona con " o ', en
linux es con '
//el carácter de relleno será el
punto (.)
cout << "Listado de calificaciones\n" <<
endl;
cout << "Roberto Aniorte" << setw(20)
<< "8.5" << endl;
cout << "Andrea Gutierrez" << setw(19)
<< "6.9" << endl;
cout << "Isabel Sanchez" << setw(21) <<
"5.7" << endl;
cout << "Anastasio Castro" << setw(19)
<< "7.5" << endl;
cout << "Barbara Lopez" << setw(22) <<
"7.8" << endl;
cout << "Martin Garcia" << setw(22) <<
"9.1" << endl;
cout << setfill('\0'); // se restablece el
carácter de relleno
cout << endl;
return 0;
}
Para CodeBlocks
Para NetBeans
Para CLI
Ahora revisa el siguiente código, y comenta que podría suceder,
también observa como esta el diseño, y las instrucciones:
// manipuladores2.cpp
#include <iostream>
#include <iomanip>
using namespace std;
Analiza el siguiente código, ya deberías de suponer
acertadamente que sucederá
// manipuladores3.cpp
// programa que lee un radio y calcula
// la longitud de la circunferencia
// el área del círculo
// y el volumen de la esfera correspondiente a ese radio
#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;
int main(void)
{
double PI = 3.1416;
double radio;
cout << "Introduce el valor del radio : ";
cin >> radio;
cout << fixed << setprecision(2); // notación en coma flotante
// con 2 decimales
cout << endl << "Longitud de la circunferencia:
" << 2*PI*radio;
cout << endl << "Area del circulo: " <<
PI*pow(radio,2);
cout << endl << "Volumen de la esfera: ";
cout << (4.0/3)*PI*pow(radio,3) << endl; //pow
es potencia
return 0;
}
La función pow retorna el resultado de x elevado a la y.
Para CodeBlocks
Para NetBeans
Para CLI
Las operaciones de entrada y salida tiene varias ventajas (C++)
:
Independencia de la plataforma: cada compilador
dispone de diferentes versiones de cada biblioteca para cada
plataforma. Tan sólo se cambia la definición de las clases y
bibliotecas, pero la estructura, parámetros y valores de retorno
son iguales. Los mismos programas compilados para diferentes
plataformas funcionan del mismo modo.
Encapsulación: para el programa
todos los dispositivos son de entrada y salida se tratan del mismo
modo, es indiferente usar la pantalla, el teclado o ficheros.
Buffering: el acceso a
dispositivos físicos es lento, en comparación con el acceso a
memoria. Las operaciones de lectura y escritura se agrupan,
haciéndolas en memoria, y las operaciones físicas se hacen por
grupos o bloques, lo cual ahorra mucho tiempo.
Clases predefinidas para streams
Un stream es una abstracción para referirse a
cualquier flujo de datos entre una fuente y un destinatario. Los
streams se encargan de convertir cualquier tipo de objeto a texto
legible por el usuario, y viceversa. Pero no se limitan a eso,
también pueden hacer manipulaciones binarias de los objetos y
cambiar la apariencia y el formato en que se muestra la salida.
C++ declara varias clases estándar para el manejo de streams:
streambuf: manipulación de buffers.
ios: entradas y salidas, incluye en su
definición un objeto de la clase streambuf.
istream: derivada de ios, clase especializada
en entradas.
ostream: derivada de ios, clase especializada
en salidas.
iostream: derivada de istream y ostream, se
encarga de encapsular las funciones de entrada y salida por
teclado y pantalla.
fstream: entrada y salida desde ficheros.
Las clases base son streambuf e ios, las demás se derivan de
estas dos.
La clase streambuf proporciona un interfaz entre la memoria y
los dispositivos físicos.
Los streams predefinidos proveen varias funciones miembros para
el manejo de datos, algunas de estas funciones son:
Algunas de ellas son la siguientes:
ios::flags (longflags)
Establece los indicadores de formato. El
parámetro flags establece algunos de los siguientes valores
combinados con el operador OR | ios::left alinea a la izquierda ios::right alinea a la derecha ios::scientific formateo a notación científica ios::fixed coma flotante formato fijo.
ios::good()
Devuelve un valor diferente a 0, si todos los
bits de error incluido el de fin de archivo están
desactivados.
ios:eof()
Devuelve un valor distinto de cero (0) si se
encuentra el final de archivo (eof).
ios::bad()
Devuelve un valor distinto de cero (0) si
encuentra un error irrecuperable.
ios::fail()
Devuelve un valor distinto de cero (0) si
ocurre un error excepto eof.
ios::clear (int
st=0)
si st es igual a cero (0) desactiva todos los
indicadores de error; en otro caso los indicadores de error
son activados de acurdo con las siguientes mascaras que
pueden ser combinadas con el operador OR | : ios::goodbit No se activan los indicadores de error ios::eofbit Se activa el indicador del fin de
archivo ios::failbit Se activa indicador de error recuperable
(error de formato o conversión) ios::badbit Se activa el indicador de error
irrecuperable.
cout.flush()
Vacia el buffer de salida
cin.get(char &c)
Extrae un carácter de entrada estandard
cin.getline (char
*pc, int n , char d="\n")
Extrae caracteres hasta que se produzca una
de las siguientes condiciones: se encontró el delimitador
"d" que coresponde a un fin de linea con enter, se han
extraído n-1 caracteres, se encontró el final del archivo
(eof).
cin.ignore (intcont = 1,intdelim=EOF)
Extrae y desecha hasta cont
caracteres. En cualquier caso la extracción finaliza cunado
se encuentra el carácter delim o cuando se alcanza
el final de archivo. Si delim = EOF, solo la
condición finaliza cuando EOF provoca la terminación. El
carácter de delimitación también se extrae.
Ejemplo:
//funciones miembro de manipuladores
// manipuladores4.cpp
#include <iostream>
#include <iomanip>
using namespace std;
int main(void)
{
double
coef[]={5198.0,3.21,46.32,506.5,2002.38};// crea una lista de
números con decimales
string
edo[]={"Guanajuato","Jalisco","Queretaro","San_Luis_Potosi","Michoacan"};
//crea una lista de nombres
//estos ejemplos anteriores corresponden 1 a 1
cout << "Tamaño del arreglo coef "
<<sizeof(coef);
cout << "Tamaño del arreglo edo " <<
sizeof(double);
// salida de resultados
cout << setiosflags(ios::fixed); //formato fijo
for (int i =0;i<sizeof(coef)/sizeof(double); ++i) // esto es un
ciclo mas adelante se explicara mas afondo
{
cout <<
setiosflags(ios::left) //justificacion a la izquierda
<< setw(15)
// ancho para cadena de caracteres
<<
setfill('.') // relleno de caracteres "."
<<
edo[i] //imprime el estado
<<
resetiosflags (ios::left) // resetea la alineación a la izquierda
<< setw(10)
// ancho de las cantidades
<<
setprecision(2) // dos decimales
<< coef[i]
<< endl; //presenta cantidad y endl
}
return 0;
}
La función sizeof()
Para reservar memoria se debe saber exactamente el número de bytes
que ocupa cualquier estructura de datos. Tal y como se ha
comentado con anterioridad, una peculiaridad del lenguaje C es que
estos tamaños pueden variar de una plataforma a otra. ¿Cómo
sabemos, entonces, cuántos bytes reservar para una tabla de, por
ejemplo, 10 enteros? El propio lenguaje ofrece la solución a este
problema mediante la función sizeof().
La función recibe como único parámetro o el nombre de una
variable, o el nombre de un tipo de datos, y devuelve su tamaño en
bytes. De esta forma, sizeof(int) devuelve el número de bytes que
se utilizan para almacenar un entero. La función se puede utilizar
también con tipos de datos estructurados o uniones.
Para CodeBlocks
Para NetBeans
Para CLI
En este caso hay un aviso del uso de manejo de expresiones con
signo y sin signo, pero realiza la compilación de forma correcta.
Pero puedes decir porque marca el error y sin embargo sigue la
compilación .....
Tipos de datos
primitivos en C++. Declaración y asignación a variables
Conceptualmente, desde el punto de vista de un programador, una variable es un dato cuyo valor puede cambiar
a lo largo de la ejecución de un programa.
En un nivel más lógico, una variable ocupa un espacio de memoria
para contener sus valores durante la ejecución de un programa.
Cada variable debe pertenecer a un tipo determinado dando también
el tamaño del espacio de memoria ocupado por la variable, y el
modo en que se manipulará esa memoria.
De momento veremos los tipos fundamentales (básicos), que son:
void, char, int, float y double; en C++ se incluye también el tipo
bool. También existen ciertos modificadores, que permiten ajustar
ligeramente ciertas propiedades de cada tipo; los modificadores
pueden ser: short, long, signed y unsigned, y pueden combinarse
algunos de ellos.
¿Cómo se declara una variable en C++?
La sintaxis para una variable es la siguiente: [modificadores]
[tipo de variable] [nombre de la variable] [=] [valor];
En la declaración de una variable se debe colocar como mínimo el
tipo de dato, el nombre y el punto y coma al final de la línea,
los modificadores son opcionales, es decir no es necesario
ponerlos y tampoco es obligatorio asignarle un valor a la variable
de inmediato. Si no se pone ningún modificador, el compilador
tomará nuestra variable como signed, es decir podría ser positivo
o negativo.
En el momento de asignar un nombre a una variable se deben seguir
algunas normas:
1. El nombre de una variable nunca debe
comenzar con un numero.
2. No debes incluir algunos caracteres como símbolos
matemáticos, guiones (el guión bajo"_" si es permitido), comas,
punto y coma, comillas, signos de interrogación o espacios en
blanco.
3. Deben tener un máximo de 40 caracteres
Todas las palabras claves de C++ están en minúsculas. En C++,
las mayúsculas y minúsculas son diferentes, a eso se le llama
sensibles.
A continuación se muestra dos tablas de palabras reservadas en
C++ :
C y C++
auto
break
case
char
const
continué
default
do
double
else
enum
extern
float
for
goto
if
int
long
register
return
short
signed
sizeof
static
struct
switch
typedef
union
unsigned
void
volatile
while
C++ únicamente
asm
Medio definido por la puesta en práctica de
lenguaje de ensamble a lo largo de C++. ( Vea los
manuales correspondientes a su sistema).
catch
Maneja una excepción generada por un throw.
class
Define una nueva clase. Pueden crearse
objetos de esta clase.
delete
Destruye un objeto de memoria creado con new.
friend
Declara una función o una clase que sea un
"amigo" de otra clase. Los amigos pueden tener acceso
a todos los miembros de datos y a todas las funciones
miembro de una clase.
inline
Avisa al compilador que una función
particular deberá ser generada en línea, en vez de
requerir de una llamada de función.
new
Asigna dinámicamente un objeto de memoria en
la memoria adicional disponible para el programa en
tiempo de ejecución. Determina automáticamente el
tamaño del objeto.
operator
Declara un operador "homónimo".
private
Un miembro de clase accesible a funciones
miembro y a funciones friend de la clase de
miembros private.
protected
Una forma extendida de acceso private;
también se puede tener acceso a los miembros protected
por funciones miembro de clases derivadas y amigos
de clases derivadas.
public
Un miembro de clase accesible a cualquier
función.
template
Declara cómo construir una clase o una
función, usando una variedad de tipos.
this
Un apuntador declarado en forma implícita en
toda función de miembro no static de una
clase. Señala al objeto al cual esta función miembro
ha sido invocada.
throw
Transfiere control a un manejador de
excepción o termina la ejecución del programa si no
puede ser localizado un manejador apropiado.
try
Crea un bloque que contiene un conjunto de
números que pudieran generar excepciones, y habilita
el manejo de excepciones para cualquier excepción
generada.
virtual
Declara una función virtual.
Algunos ejemplos de nombres correctos:
FechaNacimiento
variable12
nombre_variable
contador
ACUMULADOR
Algunos ejemplos de nombres incorrectos:
12variable
float
register
variable nueva
nueva-variable
Tipos de Datos en C++
bool: El
tipo de dato bool, tiene un tamaño de 8 bits y un rango entre 0 y
1, en pocas palabras es cero o es uno (falso o verdadero). Este
tipo de dato, es comúnmente usado en condicionales o variables que
solo pueden tomar el valor de falso o verdadero. Las variables de
tipo bool no suelen llevar modificadores, pues son innecesarios,
ya que su rango es solo 0 y 1.
int: El
tipo de dato int, tiene un tamaño de 32 bits y un rango entre
-2.147.483.648 y 2.147.483.647
Este tipo de dato, es usado para números enteros
(sin cifras decimales).
A continuación alguna combinaciones con los
modificadores:
short int: Tiene un tamaño de
16 bits y un rango entre -32.768 y 32.767.
unsigned short int: Tiene un
tamaño de 16 bits y un rango entre 0 y 65535.
unsigned int: Tiene un tamaño
de 32 bits y un rango entre 0 y 4.294.967.295.
long long int: Tiene un
tamaño de 64 bits y un rango entre -9.223.372.775.808 y
9.223.375.775.807.
unsigned long long int:
Tiene un tamaño de 64 bits y un rango entre 0 y 2exp64.
float: El tipo de dato float
tiene un tamaño de 32 bits, es usado comúnmente en números con 6 o
menos cifras decimales. Tiene un rango entre 1,17549*(e^-38) hasta
3,40282*(e^+38).
double: El tipo de dato double
tiene un tamaño de 64 bits, es usado para números de menos de 15
cifras decimales. Tiene un rango entre 2,22507*(e^-308) hasta
1,79769*(e^308).
long double: Tiene un
tamaño de 96 bits y una precisión de 18 cifras decimales. Tiene un
rango entre 3,3621*(e^-4932) hasta 1,18973*(e^4932).
char: Las variables del tipo
char, son digamos las variables problema del lenguaje C y C++,
puesto que tienen una gran cantidad de restricciones y
complicaciones, bastante molestas.
Las variables de tipo char, en C y C++ son
consideradas vectores, se les debe declarar un tamaño máximo,
entre corchetes "[ ]" lo cual restringe un poco al no saber qué
tamaño podría llegar a tener una cadena de caracteres, y aunque
hay formas de evadir esto, es bastante complicado. Es recomendable
usar las variables de tipo string para las cadenas de caracteres,
incluidas en la librería string.h que son bastante fáciles de
usar. La sintaxis para declarar un char es la siguiente: char
nombre_char[tamañoMax]; o simplemente char nombre = "valor" notar
que va entre comillas simples.
Instrucciones de Asignación
Es una línea de código, que le asigna a una variable
cualquiera un valor cualquiera, preferiblemente adecuado al tipo
de dato o a las necesidades de dicha asignación. Una asignación
tiene la siguiente sintaxis: nombre_variable = valor, con esto
le estamos diciendo a nuestro programa que la variable llamada
"nombre_variable", tendrá ahora como nuevo valor a "valor". Así
entonces por ejemplo, al escribir contador = 0; estamos diciendo
que la variable contador tendrá como nuevo valor 0, es de tener
en cuenta que al realizar una asignación, si la variable tenía
algún otro valor antes de esto, dicho valor se perderá y
cambiaría por el nuevo que le hemos ordenado.
Las asignaciones no solo se realizan entre variables y valores
constantes, también se realizan entre variables, por ejemplo
variable1 = variable2, de este modo, la "variable1", tendrá
ahora el valor que tiene en ese momento la "variable2", es
recomendable realizar estas asignaciones entre variables del
mismo tipo, es decir entre una variable de tipo entero y otra de
tipo entero, aunque está permitido hacer asignaciones entre
variables de diferente tipo (numérico), esto genera una
advertencia porque puede causar perdida en la precisión de los
datos, por ejemplo al pasar de float a int.
Variables
y constantes en C++.
Asignación de valores, uso de #define y
const en C++
Las variables son altamente imprescindibles al
momento de programar, de hecho sería imposible conseguir una
aplicación con una funcionalidad básica sin usar variables; por
esta misma razón es necesario aprender a usarlas bien y lo tenemos
muy fácil, pues su uso es bastante sencillo e intuitivo, tanto
para declararlas como para asignarles valores.
Las variables son posiciones en memoria donde
estarán guardados los diferentes valores que le damos o que toman
duranet ejecución los datos que usamos y normalmente estarán
disponibles a lo largo de la ejecución de nuestro programa. Para
asignar valores a una variable en una gran variedad de lenguajes
que incluye a C++ se usa el operador "=" seguido del valor que le
daremos a la variable (no todos usan el "=" para esto). Veamos un
ejemplo completo con todos los posibles usos que le damos a una
variable. El programa se llamara ejemplo8.cpp
//programa ejercicio8.cpp
#include <iostream>
using namespace std;
int main()
{
char x = 'a'; // Declaramos y asignamos en la
misma línea, vea que se asigna con los simbolos ' '
int num; //Declaramos el entero en una línea
num = 5; //Le asignamos un valor en otra
línea
int num2 = 8; //Asignacion y declaracion en
una sola instruccion
float numero; //Un numero decimal
numero = 3.5; //Le asignamos un valor al
decimal
float res = numero + num2; //Sumamos dos
variables y las asignamos a res
//ejemplo como: 3.5 + 8 = 11.5
res = res + num; //Al valor actual de res le
sumamos el valor de num
//ejemplo : 11.5 + 5 = 16.5
bool valor = false; //Variable booleana
valor =
true; // Pueden
ser true o false, antes se indico como flase, ahora paso a true
res = res*2; //Duplicamos el valor de res
16.5*2 = 33
cout << valor << endl; // mostara
un numero 1 porque true es 1, y false 0
cout << res << endl; //Mostramos
el valor de res por pantalla
return 0;
}
Para CodeBlocks
Para NetBeans
Para CLI
Que puede observar en este ultimo
programa, realice un comentario sobre esto.
En el código anterior hemos visto las multiples
formas en que se puede declarar una variable, cómo asignarle un
valor, incluso vimos que es posible asignarle el valor de una
variable a otra, o realizar operaciones entre los valores de
variables y asignar el resultado a una variable nueva, vimos que
es posible usar el valor de una misma variable y cambiar su propio
valor (res = res*2).
Constantes en C++, const y #define
Los datos constantes, mal llamadas por algunos
"variables constantes" (realmente no son variables) tienen un
valor fijo durante toda la ejecución del programa, es decir, este
valor no cambia ni puede ser cambiado a lo largo de la
ejecución de nuestro programa. Las constantes son muy
útiles para especificar el tamaño de un vector y para algunas
otras cosas, como facilidad de uso y confiabilidad del código.
Para declarar una constante, se hace despues de declarar las
librerías y antes de las funciones, la sintaxis es la siguiente:
#define nombre_constante valor. Veamos algunos detalles y luego
unos ejemplos sencillos del uso de las constantes en C++
En C++ se pueden definir constantes de dos forma, ambas válidas
para nosotros. La primera es por medio del comando #define
nombre_constante valor y la segunda es usando la palabra clave
const, veamos ahora cada una de estas formas en detalle.
Uso de #define para declarar constantes en
C++
La instrucción #define nos permite declarar constantes (y
algunas cosas más) de una manera rápida y sencilla. Hay que tener
en cuenta que al declarar constantes con #define debemos hacerlo
despues de los #include para importar librerías pero antes de
declarar nuestras funciones y demás. Veamos un ejemplo:
Ejemplo de uso de #define en C++ para declarar constantes
(programa ejercicio9.cpp)
//programa ejercicio9.cpp
#include <iostream>
using namespace std;
#define PI 3.1416; //Definimos una constante llamada PI
//vea
donde declara despues de using namespafe std; y antes de int
main()
int main()
{
cout << "Mostrando el valor de PI: "
<< PI;
return 0;
}
Para CodeBlocks
Para NetBeans
Para CLI
Notemos que ha sido bastante fácil, sin embargo
no todo es bueno. Realmente al usar la instrucción #define en C++
no estámos creando una constante realmente, estamos creando una
expresión y por tal motivo hay algunas cosas que se complican,
veamos (ejercicio9bis.cpp) :
//programa ejercicio9bis.cpp
#include <iostream>
using namespace std;
#define PI 3.1416; //Definimos una constante llamada PI
//vea donde declara despues de
using namespafe std; y antes de int main()
int main()
{
cout << "Mostrando el valor de PI: "
<< PI << endl;
return 0;
}
Si intentamos ejecutar el código anterior obtendremos un error
al haber usado el operador << justo despues de PI, esto
sucede porque PI no es tratado exactamente como una variable
cualquiera sino como una expresión, así que realmente aunque
podemos usar #define para declarar constantes no es la mejor
opción.
Para CodeBlocks
Para Netbeans
Para CLI
Veamos ahora cual es realmente la forma más
adecuada de declarar constantes en C++, esto se hace por medio de
la instrucción const, veamos:
Uso de const para declarar constantes en C++
La instrucción const nos permite declarar constantes de una
manera más adecuada y acorde. Las constantes declaradas con const
poseen un tipo de dato asociado (como debería ser siempre) y se
declaran al interior de nuestro código como un tipo cualquiera.
Veamos un ejemplo:
Ejemplo de uso de const en C++ para declarar constantes (programa
ejercicio10.cpp)
//programa ejercicio10.cpp
#include <iostream.h>
using namespace std;
int main(int argc, char* argv[])
{
const float PI = 3.1416; //Definimos
una constante llamada PI
cout << "Mostrando el valor de PI: "
<< PI << endl;
return 0;
}
Para CodeBlocks
Para NetBeans
Para CLI
Notemos que de igual forma ha sido bastante
fácil y mejor aún ha sido mucho más intuitivo y sencillo para
nosotros. Se puede ver que la declaración es muy similar a la de
una variable cualquiera y que ya no tenemos complicaciones al
intentar añadir la instrucción endl; que es un salto de linea con
retroceso, se encuentra en la librería 《iostream.h iostream》
aplicable para C++, sirve para hacer mas estética la presentación
de los datos que se imprimen en consola mediante un COUT o CERR.
Veamos que realmente la variable no puede
cambiar:
(programa ejercicio11.cpp)
// programa ejercicio11.cpp
#include <iostream.h>
using namespace std;
int main(int argc, char* argv[])
{
const float PI = 3.1416; //Definimos
una constante llamada PI
cout << "Mostrando el valor de PI: "
<< PI << endl;
PI = 2; //Esto generará un error pues PI es
de solo lectura (constante)
return 0;
}
Para CodeBlocks
Para Netbeans
Para CLI
Si intentamos ejecutar el código anterior obtendremos un error
al intentar cambiarle el valor a PI, pues lo hemos definido como
una constante y el compilador no nos permitirá cambiarle en ningún
momento el valor.
¿Cuándo usar una variable o una constante
en C++?
En general, la definición de variable y constante nos da una muy
buena idea de cuándo usar una u otra. Básicamente, si un valor
puede cambiar en cualquier momento (aunque la probabilidad de que
eso suceda sea baja) entonces deberá ser una variable, en lugar de
una constante.
Un ejemplo para soportar lo anterior sería el nombre del usuario.
Podríamos pensar que un nombre no va a cambiar, y es probable que
no lo haga. Sin embargo nada nos asegura que así sea, pues aunque
es improbable es posible. Adicionalmente, nuestro programa puede
cambiar de usuario y por ende su nombre podría variar mientras el
programa se ejecuta. Por lo tanto NO debería ser una constante.
Por otro lado, hay valores que no van a cambiar a lo largo del
tiempo. Por ejemplo, la velocidad de la luz se ha acordado siempre
como la misma, así que debería ser una constante para evitar que
sea cambiada de cualquier modo durante la ejecución del programa.
Valores como el número PI, el código de estado de una página no
existente (404), son valores que son convenciones existentes y que
NO deberían cambiar, por lo cual se los declara como constantes.
Finalmente, el uso de constantes en C++ (y en cualquier otro
lenguaje de programación) ayuda mucho a mejorar la comprensión del
código que escribimos pues no es lo mismo que nuestro código
ponga:
if (velocidad == 299792458)
A que diga
if (velocidad == VELOCIDAD_LUZ)
Pues en el segundo caso, queda muy claro que
estamos comparando la variable velocidad con la de la luz que es
una constante. Por supuesto, anteriormente tendríamos que haber
declarado la constante VELOCIDAD_LUZ con su respectivo valor (tal
como se explicó anteriormente).
En resumen podemos decir que const
se considera:
La palabra clave const indica una variable que
es de solo lectura (es decir, no se puede cambiar en tiempo de
ejecución). No indica una constante de tiempo de compilación. Por
lo tanto, se aplican todos los atributos habituales de las
variables; específicamente, se le asigna espacio de almacenamiento
direccionable.
Veamos lo que se quiere decir cuando se utiliza
const. En realidad es muy simple: const significa que algo no está
modificable, por lo que un objeto de datos que se declarado con
const como parte de su especificación tipo no debe ser asignado a
ninguna manera durante la carrera de un programa. Es muy probable
que la definición del objeto contenga un inicializador (de lo
contrario, ya que no puede asignarle, ¿cómo obtendrá alguna vez?),
Pero este no siempre es el caso. Por ejemplo, si estaba accediendo
a un puerto de hardware en una dirección de memoria fija y
prometió solo para leer de él, entonces sería declarado como const
pero no inicializado.
Tomando la dirección de un objeto de datos de un tipo que no es const y ponerla en un puntero a la
versión const calificado del mismo tipo es a la vez seguro y
explícitamente permitidas ; podrá usar el puntero para
inspeccionar el objeto, pero no modificarlo. Poner la dirección de
un tipo const en un puntero al tipo
no calificado es mucho más peligroso y consecuentemente prohibido
(aunque puede evitar esto por usando un molde).
El calificador const
se usa en la lista de parámetros de una función para especificar
que un argumento pasado a la función no es modificable en dicha
función (constante). También puede ser utilizado para declarar las
llamadas "variables constantes". Estas pueden ser colocadas en
cualquier parte en que se espere una expresión constante. También
en archivos de cabecera (archivos tipo .h).
La variable constante debe ser inicializada al
declararse.
Otro uso común para el calificador const
es para poder declarar un apuntador constante.
Tabla con expresiones de declaración de constantes:
DECLARACION
NOMBRE ES...
const tipo
nombre = valor;
Tipo
constante.
tipo *const nombre = valor;
Apuntador
constante a tipo.
const tipo
*nombre = valor;
(Variable)
apuntador a la constante tipo.
const tipo *const nombre = valor;
Apuntador
constante a tipo constante.
Ambito de acción.
Cuando usamos { y } estamos definiendo un
ambito donde la variables y/o funciones tiene acción fuera
de estos indicadores estas variables y/o funciones ya no tienen
acción, si queremos que estos elementos funciones, variables, etc.
puedan ser usadas en todo el programa debemos considerar usarlas
en el primer { y } o bien que sean procedimientos
(subrutinas las trataremos mas adelante) que sean llamadas cuando
sea necesario.
Los condicionales en C++.
Uso declaración y sintaxis en C++
Los condicionales en C++, son una estructura de
control esencial al momento de programar.
Tanto C como C++ y la mayoría de los lenguajes
de programación utilizados actualmente, nos permiten hacer uso de
estas estructuras para definir ciertas acciones condiciones
especificas en nuestro algoritmo. Un condicional, permite
establecer una serie de condiciones al interior de nuestro
programa, que nos ayudan a determinar que acciones llevará cabo
dadas ciertas circunstancias, por ejemplo si queremos decidir
cuándo dar acceso a un usuario, dependiendo de si el nombre de
usuario y contraseña son correctos, para algo como esto, es útil
un condicional, nos permite verificar si determinada condición se
cumple (en este caso si la contraseña y el nombre de usuario son
correctos) y de acuerdo a que se cumpla o no, llevar a cabo un
conjunto de acciones. Los condicionales aumentan la "expresividad"
de un software, es decir nos permiten considerar diferentes
situaciones con antelación, evitando o permitiendo sortear
diferentes tipos de situaciones que son del interés de nuestra
aplicación.
Existen diferentes tipos de condicionales, cada
uno tiene una utilidad y funcionalidad diferente, que consideran
diferentes situaciones que se pueden llegar a presentar durante la
ejecución de un algoritmo. Depende entonces del conocimiento que
tengamos acerca de cada uno de los condicionales saber determinar
correctamente cuando es necesario implementar uno u otro. Tenemos
a nuestra disposición los siguientes tipos de condicionales en
C++:
Condicional If en C++
Condicional if-else en C++
Condicional Switch en C++
Cada uno de estos condicionales tiene ciertas
características que lo hacen útil para algunos casos específicos,
a lo largo de los contenidos veremos cada uno de estos al
detalle, aprendiendo durante el proceso los componentes de un
condicional, sintaxis de los condicionales y esas características
particulares que permiten decidir cual usar en qué momento,
veremos también el concepto de condicionales anidados, y algunas
otras cositas.
Te recuerdo, que aunque intentaré profundizar bastante en cada
concepto, lo haré enfocándome hacia el uso de los condicionales en
el lenguaje C++ y no tanto hacia la parte de la lógica de estas
estructuras condicionales en particular.
Muy bien, ahora que sabemos un poco acerca de
las estructuras de control condicionales (o simplemente
condicionales) y que además sabemos que existen varios tipos de
estos, podemos comenzar a aprender y dominar cada uno de estos
tipos de condicionales en C++, vamos a hacerlo en orden, para no
enredarnos, así que vamos a la sección de Condicional if en C++,
Condicional
if en C++.
Declaración, uso y sintaxis del if en C++
Los condicionales if, son una estructura de
control condicional, también llamadas estructuras selectivas de
casos simples (porque solo definen un posible flujo), las cuales
nos permiten tomar cierta decisión al interior de nuestro
algoritmo, es decir, nos permiten determinar qué acciones ejecutar
según cierta condición sea verdadera, por ejemplo determinar si un
número es mayor que 10 y de acuerdo a esto mostrar un mensaje (o
cualquier acción que sea necesaria).
Básicamente, un condicional if, es una
estructura que nos posibilita definir las acciones a ejecutar si
se cumple cierta condición y de ese modo modificar la ejecución de
tareas en un programa según se necesite.
¿Cómo funciona un Condicional If?
Para comprender mejor cómo funciona el
condicional if, una muy buena forma es partiendo de un ejemplo.
Supongamos que queremos verificar si el resultado de una suma
ingresada por el usuario es correcto o no. Para este ejemplo, el
condicional if, es el encargado de verificar si el resultado
ingresado corresponde o no a la respuesta correcta de la suma. El
condicional if, funciona verificando la condición ingresada y de
acuerdo a su valor de verdad (falso o verdadero) lleva a cabo o no
una serie de instrucciones.
Espero haber sido claro, sino, no te preocupes, pues veremos ya
mismo algunos ejemplos para entender todo mejor.
Sintaxis del Condicional If en C++:
La sintaxis de un condicional if, es bastante simple e incluso
creo que intuitiva. Vamos entonces a ver rápidamente como es la
estructura para ir luego a unos ejemplos.
Veamos en forma grafica el uso de if:
Vamos ahora a ver línea por línea del código para comprender
todo y quedar claros. Posteriormente veremos un ejemplo con
valores reales.
if(condición a evaluar) //Por ejemplo X <= 10
{
....
....
Bloque de Instrucciones si se cumple la
condición....
....
....
}
....
Bloque de Instrucciones restante DEL ALGORITMO....
....
if(condición a evaluar) //Por ejemplo X <=
10
{
....
....
Bloque de Instrucciones si se cumple la
condición....
....
....
}
....
Bloque de Instrucciones restante DEL ALGORITMO....
....
Línea 1: (if(condición a
evaluar) //Por ejemplo X <= 10)
En esta línea está prácticamente todo
lo esencial del condicional, aquí le hemos dicho al
interior del argumento del condicional if, cual es la
condición que se debe cumplir para que se ejecute el
primer bloque de instrucciones, esta línea es en efecto
esencial ya que nos da la pauta para que el algoritmo
determine si ejecutará o no el bloque de instrucciones al
interior de las llaves.
Línea 2:( { )
En la línea 2 tenemos una llave
abriendo "{" lo cual como seguramente ya sabrás indica que
allí comienza el bloque de instrucciones que se ejecutarán
si se cumple la condición dada. Esta llave no es del todo
obligatoria, sin embargo si no la ponemos solo se
ejecutara dentro de nuestro ciclo la primera línea
inmediatamente posterior a la declaración del condicional,
de modo que si deseamos que se ejecuten varias líneas
dentro de nuestro condicional, debemos usar las llaves.
....
....
Bloque de Instrucciones si se cumple
la condición....
....
...
En estas líneas es donde estarán todas las operaciones
que queramos llevar a cabo en caso de cumplirse la
condición, este bloque podrá tener la cantidad de líneas
necesarias incluso, como veremos más adelante dentro de
estas podría haber uno o más condicionales en su interior,
así que podrías tener lo que se conoce como condicionales
anidados (ya veremos eso más adelante).
Línea 8: ( } )
En esta línea hacemos uso de la llave cerrando "}", una
vez más como seguramente ya sabrás esta nos indica que
allí termina el bloque del condicional y se dará por
terminada la ejecución de este para continuar ejecutando
el resto del programa.
Línea 9 a 11
....
Bloque de Instrucciones restante DEL ALGORITMO....
....
Estas líneas contienen la estructura restante del
algoritmo, quise ponerlas allí, para que quede claro que
sin importar si la condición se cumple o no, el algoritmo
siempre va a ejecutar estas líneas, es decir las líneas
que se encuentran después de la llave de cierre de un
condicional, siempre se ejecutarán sin importar si la
condición se cumpla o no.
No te preocupes si no comprendiste muy bien lo que acabo de
escribir, estoy seguro que con un par de ejemplos que veremos a
continuación, te va a quedar todo claro
Ejemplos de Condicional If-else en C++
A continuación vamos a ver unos cuantos ejemplos
para comprender de manera adecuada el uso de los condicionales if
en C++.
Ejemplo 1: Verificación de valores en C++
Vamos a retomar el ejemplo anterior, deseábamos
un sistema, en el cual un usuario nos ingresaba el resultado de
una suma mostrara en pantalla y verificábamos si el resultado
ingresado era el correcto a esta operación. En caso de ser
correcto, el sistema muestra un mensaje de felicitación.
Solución Ejemplo 1:
Debemos entonces determinar cuál va a ser nuestra condición a
evaluar, en este ejemplo, la condición debe ser que la respuesta
ingresada, sea igual al resultado de la suma, veamos entonces como
realizar esto:
int resultado =
0;
//inicializamos la variable resultado con 0, esto es muy
importante al comenzar los programas en general
cout << "Cuanto es 39+50?
"; //presentamos la pregunta
cin >>
resultado;
// introducimos el resultado
if(resultado ==
39+50)
// se evalua el resultado (dato introducido con la condicion de
igualdad "==" en este aspecto la suma se realiza en memoria
{
cout << "Respuesta Correcta.
Felicitaciones!\n"; // si coinciden se muestra el
mensaje de Felicitación, si no es correcto no muestra nada
}
veamos el resultado del programa (ejercicio12.cpp)
cuando introducimos un valor que no es el correcto, no esta
coniderado en el programa un mensaje cuando existe un error, solo
termina el programa.
Ahora si introducimos el valor correcto:
Para CodBlocks
Nos felicita ya que la condición se ha cumplido
y cuando no es lo correcto:
Para NetBeans
cuando no es lo correcto:
Para CLI
Efectivamente, los condicionales son
extremadamente útiles pues permiten definirle a nuestro software
múltiples vías de ejecución contemplando así todas las
posibilidades.
Condicional if else en C++.
Declaración uso y sintaxis del if else en
C++
Los condicionales if-else, son una estructura de
control, que nos permiten tomar cierta decisión al interior de
nuestro algoritmo, es decir, nos permiten determinar que acciones
tomar dada o no cierta condición, por ejemplo determinar si
la contraseña ingresada por el usuario es válida o no y de acuerdo
a esto darle acceso al sistema o mostrar un mensaje de error.
Se les conoce también como estructuras
selectivas de casos dobles (porque definen ambas
posibilidades en la ejecución --si se cumple y si no se cumple
--).
En resumen, un condicional if-else es una
estructura que nos posibilita definir las acciones que se deben
llevar a cabo si se cumple cierta condición y también determinar
las acciones que se deben ejecutar en caso de que no se cumpla;
generando así una separación o bifurcación en la ejecución del
programa, ejecutando ciertas acciones u otras a partir de la
evaluación de una condición dada.
¿Cómo funciona un Condicional If-Else?
Para comprender mejor cómo funciona el
condicional if-else, una muy buena forma es partiendo de un
ejemplo.
Imaginemos que en nuestro programa, deseamos
implementar un sistema de logeo de usuario, comprobando si la
información suministrada coincide con unos los valores correctos y
en este caso mostrar un mensaje de bienvenida, y en caso de que
no, se mostrará un mensaje de error. Como podemos imaginar, es
entonces necesario hacer que nuestro algoritmo, tome una decisión,
de acuerdo a los valores ingresados por el usuario, y definir los
dos casos posibles en caso de fallo o en caso de que no. Es para
esto que sirve el condicional if-else, nos permite definir una
condición que se debe cumplir y de acuerdo a su cumplimiento o no
tomar una acción correspondiente.
Sintaxis del Condicional If-Else en C++:
La sintaxis de un condicional if-else, es en principio similar a la del
condicional if, pero adicionando una nueva "estructura" que es else, el cual indica la acción o conjunto
de acciones a llevar a cabo, en caso de que la condición del if no
se cumpla.
Cabe resaltar que el
else siempre se pone inmediatamente después del if, en caso de ser necesario, el else es
incapaz de funcionar por sí solo, siempre debe ir acompañado por
un if. Veamos entonces como es la sintaxis de este:
Vamos ahora a ver línea por línea el anterior código para
comprender todo y quedar claros. Posteriormente veremos un ejemplo
con valores reales.
if(condición a evaluar) //Por ejemplo 50
<= 10
{
....
....
Bloque de Instrucciones si se cumple la
condición....
....
....
}
else
{
....
....
Bloque de Instrucciones si NO se cumple
la condición....
....
....
}
Línea 1:
if(condición a evaluar) //Por ejemplo 50 <= 10
En esta línea está prácticamente todo lo esencial del
condicional, aquí le hemos dicho al interior del argumento
del condicional if, cual es la condición que se debe cumplir
para que se ejecute el primer bloque de instrucciones, esta
línea es en efecto esencial ya que nos da la pauta para que
el algoritmo determine que bloque de instrucciones ejecutar.
Línea 2:
En la línea 2 tenemos una llave abriendo "{" lo cual como
seguramente ya sabrás indica que allí comienza el bloque de
instrucciones que se ejecutarán si se cumple la condición
dada. Esta llave no es del todo obligatoria, sin embargo si
no la ponemos solo se ejecutará dentro de nuestro
condicional la primera línea inmediatamente posterior a la
declaración del condicional, de modo que si deseamos que se
ejecuten varias líneas dentro de nuestro condicional,
debemos usar las llaves
Línea 3 a 7:
En estas líneas es donde estarán todas las operaciones que
queramos llevar a cabo en caso de cumplirse la condición,
este bloque podrá tener la cantidad de líneas necesarias
incluso, como veremos más adelante dentro de estas podría
haber uno o más condicionales en su interior, así que
podrías tener todo un condicional dentro de un condicional
dentro de otro condiconal... y así sucesivamente jejeje.
Línea 8:
En esta última línea hacemos uso de la llave cerrando "}",
una vez más como seguramente ya sabrás esta nos indica que
allí termina el bloque del condicional y se dará por
terminada la ejecución de este para continuar ejecutando el
resto del programa, cabe notar que esta línea dará paso a la
ejecución del bloque de instrucciones del else, en caso de
que la condición dada no se haya cumplido.
Línea 9 a 16:
else
{
....
....
Bloque de Instrucciones si NO se cumple
la condición....
....
....
}
Estas líneas contienen la estructura else, que es la que
indica que existe un bloque de instrucciones que se debe
ejecutar en caso de que la condición dada no se cumpla. Este
bloque al igual que el del condicional if, se abre y se
cierra con llaves, recuerda que estas pueden ser opcionales,
sin embargo siempre recomiendo usarlas como una buena
práctica de programación.
Ejemplos de Condicional If-else en C++
A continuación vamos a ver unos cuantos ejemplos para comprender
de manera adecuada el uso de los condicionales if-else en c++.
Ejemplo 1: Sistema de logeo en C++
Vamos a retomar el ejemplo anterior, deseamos implementar un
sistema de logeo de usuario, es decir, queremos que el usuario nos
ingrese un una contraseña y deseamos comprobar si coincide con el
valor pre establecido. En caso de que los datos sean correctos se
mostrará un mensaje de bienvenida, y en caso de que no, se
mostrara un mensaje de error y finalizará el programa.
Solución Ejemplo 1:
Debemos entonces determinar cuál va a ser nuestra condición a
evaluar, en este ejemplo, la condición debe ser que la contraseña,
sea idéntica a la establecida en nuestro sistema, veamos entonces
como realizar esto:
int main(int argc, char* argv[])
{
string password = ""; ///se inicializa como
elemento vació, anteriormente hable de esto
cout << "Ingrese la contraseña: ";
cin >> password;
if(password == "myClave")
{
cout << "Contraseña correcta. Bienvenido";
}
else
{
cout << "Contraseña incorrecta.";
}
return 0;
}
Para CodeBlocks
cuando se introduce la contraseña incorrecta:
y cuando es correcta
Para NetBeans
cuando se introduce la contraseña incorrecta:
y cuando es correcta
Para CLI
Presentaremos un programa algo mas elaborado donde incluiremos
sentencias de if - else, este
programa lo llamaremos ejercicio14.cpp, tomemos en cuenta los
siguientes requisitos:
Planteamiento del Problema
Ejemplo 1:
Dados tres números calcule:
La suma de los tres
El promedio de los tres
El producto de los tres
Además determine:
El menor de los tres
En la linea if ((num1 <= num2) && (num1
<= num3))
Vemos que hay algo nuevo, que es <=, es un operador de
relación y && es un operador lógico, a continuación
explicamos que significan estos símbolos:
El programa toma decisiones
En ocasiones se desea que se ejecuten un
conjunto de declaraciones si una condición es verdadera, y otro
grupo si la condición es falsa. Es decir, deseamos que el programa
tome decisiones y responda de acuerdo a ellas.
Para que el programa tome una decisión,
generalmente realiza algún tipo de prueba, una comparación. Para
ello utilizará los llamados operadores relacionales:
Operador
Relación
==
… igual a
…
!=
…
distinto de …
>
… mayor
que …
<
… menor
que …
>=
… mayor o
igual que …
<=
… menor
o igual que …
!
… NO
&&
Y
||
O
Operadores
lógicos.
Muy utilizados en Informática, Lógica
proposicional y Álgebra booleana, entre otras disciplinas. Los
operadores lógicos nos proporcionan un resultado a partir de que
se cumpla o no una cierta condición, producen un resultado
booleano, y sus operandos son también valores lógicos o
asimilables a ellos (los valores numéricos son asimilados a cierto
o falso según su valor sea cero o distinto de cero). Esto genera
una serie de valores que, en los casos más sencillos, pueden ser
parametrizados con los valores numéricos 0 y 1. La combinación de
dos o más operadores lógicos conforma una función lógica.
Los operadores lógicos son tres; dos de ellos
son binarios, el último (negación) es unario. Tienen una doble
posibilidad de representación en el estándar C++ actual: la
representación tradicional que se indica a continuación, y la
natural introducida recientemente que se detallan.
Y lógico && AND
O lógico || OR
Negación lógica ! NOT
Las expresiones conectadas con los operadores
&& y || se evalúan de izquierda a derecha,
y la evaluación se detiene tan pronto como el resultado verdadero
o falso es conocido (muchos programas tienen una lógica que se
basa en este propiedad).
Operador Y lógico (&&)
También denominado por su nombre en inglés (generalmente en
mayúsculas) AND lógico. Devuelve un valor lógico true
"verfdadero" si ambos operandos son
ciertos. En caso contrario el
resultado es false "falso".
Sintaxis
expr-AND-logica && expresion-OR-inclusive
Comentario:
La operatoria es como sigue: El primer operando
(de la izquierda) es convertido a bool. Para ello, si es una
expresión, se evalúa para obtener el resultado (esta computación
puede tener ciertos efectos laterales). A continuación, el valor
obtenido es convertido a bool cierto/falso siguiendo las reglas de
conversión estándar. Si el resultado es false, el proceso se
detiene y este es el resultado, sin que en este caso sea necesario
evaluar la expresión de la derecha.
Si el resultado del operando izquierdo es cierto, se continúa
con la evaluación de la expresión de la derecha, que también es
convertida a bool. Si el nuevo resultado es true, entonces el
resultado del operador es true. En caso contrario el resultado es
false.
Operador O lógico (||)
Este operador binario devuelve true si alguno de los
operandos es cierto. En caso contrario devuelve false.
Sintaxis
expr-OR-logica || expresion-AND-logica
Comentario
Este operador sigue un funcionamiento análogo al anterior. El
primer operando (izquierdo) es convertido a bool. Para ello, si es
una expresión, se evalúa para obtener el resultado (esta
computación puede tener ciertos efectos laterales). A continuación
el valor obtenido es convertido a bool cierto/falso siguiendo las
reglas de conversión estándar. Si el resultado es true, el
proceso se detiene y este es el resultado, sin que en este
caso sea necesario evaluar la expresión de la derecha.
Si el resultado del operando izquierdo es false, se continúa con
la evaluación de la expresión de la derecha, que también es
convertida a bool. Si el nuevo resultado es true, entonces el
resultado del operador es true. En caso contrario el resultado es
false.
Operador NO lógico: ( !)
Este operador es denominado también negación lógica y se
representa en el texto escrito por la palabra inglesa NOT (otros
lenguajes utilizan directamente esta palabra para representar el
operador en el código).
Sintaxis
! expresion-cast
Comentario
El operando expresion-cast (que puede ser una expresión que se
evalúa a un resultado es convertido a tipo bool, con lo que solo
puede ser uno de los valores cierto/falso. A continuación el
operador cambia su valor: Si es
cierto es convertido a falso y viceversa.
Resulta por tanto, que el resultado de este operador es siempre un
tipo bool, aunque al existir una conversión estándar por la que un
cero es convertido a false, y cualquier valor distinto de cero a
true, coloquialmente se dice que este operador convierte un
operando 0 en 1 y uno no-cero en 0. En otras palabras: este
operador devuelve cierto (true) si la expresión se evalúa a
distinto de cero, en caso contrario devuelve falso (false).
Representación explícita
Los operadores lógicos entre valores lógicos &&, ||, !; la
relación de desigualdad !=; algunos de los operadores lógicos
entre bits (&, |, ^, ~) y sus expresiones compuestas (&=,
|=, ^=), tienen una representación realmente difícil de leer, con
la desventaja adicional que sus símbolos no siempre están
fácilmente accesibles en ordenadores con teclados distintos del
estándar USA. Para resolver este problema, el estándar C++ ha
introducido nuevas formas para su representación; las denominamos
formas explícitas o naturales, en razón de que se parecen más a
las palabras correspondientes del lenguaje natural. Las nuevas
formas constituyen palabras-clave, y la tabla de equivalencias es
la siguiente:
Palabra clave
Símbolo
Descripción
and
&&
Operador Y lógico
or
/
Operador O lógico
not
!
Operador negación lógica
bitand
&
Operador AND entre bits
xor
^
Operador OR exclusivo entre
bits
bitor
/
Operador OR inclusivo entre
bits
compl
~
Operador complemento a uno de
bits
and_eq
&=
Asignación compuesta (AND
entre bits)
xor_eq
^=
Asignación compuesta (XOR
entre bits)
or_eq
=
Asignación compuesta (OR entre
bits)
not_eq
!=
Operador relacional de
desigualdad
En el operador logico (and) &&
Regla: Su Verdad depende de sus dos enunciados. Es verdadera
solo si ambas verdaderas, y es falsa cuando al menos uno de los
enunciados es falsa.
En el operador (or) ||
Regla: Es verdadera si al menos una de las dos es verdadera.
En el operador (not) !
Regla: Lo verdadero se vuelve falso, y lo falso se vuelve
verdadero.
Código del programa (ejercicio14.cpp)
//programa ejercicio14.cpp
#include <iostream.h>
using namespace std;
int main(int argc, char* argv[])
{
int num1, num2, num3; // variables de entrada:
números que introduce el usuario
int suma, promedio, producto, menor; //
variables de proceso y salida para los requisitos del programa
cout << "Digite tres numeros enteros
diferentes: \n";
cin >> num1
>> num2 >> num3; // lee tres numeros enteros
// Suma los tres
numeros
suma = num1 + num2 + num3;
// Promedio de los tres
numeros
promedio = (num1 + num2 + num3) / 3;
// Producto de los tres
numeros
producto = num1 * num2 * num3;
// localizamos el
numero menor
if ((num1 <= num2) && (num1 <=
num3)) // el operador && significa el operador logico (Y)
cuando ambas condiciones son verdaderas
// el resultado es verdadero pero si una de ellas es falso el
resultado es falso
menor = num1;
else
if ((num2 <= num1) && (num2 <=
num3))
menor = num2;
else
menor = num3;
cout << "La suma
es igual a: " << suma << endl;
cout << "El
promedio es igual a: " << promedio << endl;
cout << "El
producto es igual a: " << producto << endl;
cout << "El menor
numero es: " << menor << endl;
return 0;
}
Para Codeblocks
Para NetBeans
Para CLI
como se trata de un programa mas elaborado veremos que se
realiza un análisis mas a detalle usando un diagrama de flujo. Los
programas de computadora tienen como finalidad resolver problemas
específicos y el primer paso consiste en definir con precisión el
problema hasta lograr la mejor comprensión posible.
Diagrama
de flujo:
Un diagrama de flujo o flujo grama es una forma
de representar gráficamente los pasos para resolver un problema en
específico. Estos diagramas utilizan una serie de símbolos con
significados especiales y son la representación gráfica de los
pasos de un proceso.
En computación es un primer enfoque con lo que
sería la programación formal.
Aspectos a tomar en cuenta para crear un
buen diagrama de flujo:
° Existe siempre un camino que permite llegar a una solución
(finalización del algoritmo).
° Existe un único inicio del proceso.
Desarrollo del Diagrama de Flujo:
Acciones previas a la realización del diagrama de flujo:
°Definir qué se espera obtener del diagrama de flujo.
°Establecer el nivel de detalle requerido
°Determinar los límites del proceso a describir.
Los pasos a seguir para construir el
diagrama de flujo son:
Si el nivel de
detalle definido incluye actividades menores, listarlas
también.
Identificar y
listar los puntos de decisión.
Construir el
diagrama respetando la secuencia cronológica y asignando los
correspondientes símbolos.
Asignar un título
al diagrama y verificar que esté completo y describa con
exactitud el proceso elegido
Ventajas de Diagramas de flujo:
Favorecen la comprensión del proceso a través de mostrarlo como un
dibujo. El cerebro humano reconoce fácilmente los dibujos. Un buen
diagrama de flujo reemplaza varias páginas de texto.
Permiten identificar los problemas y las oportunidades de mejora
del proceso. Se identifican los pasos redundantes, los flujos de
los re-procesos, los conflictos de autoridad, las
responsabilidades, los cuellos de botella, y los puntos de
decisión.
También dentro del ámbito laboral más allá de la ingeniería
muestran la interacción de cliente-proveedor así como la
información que en ellas se realizan, facilitando a los empleados
el análisis de las mismas para futuros procesos o capacitaciones
más rápidas dentro de un entorno general de trabajo.
Son una excelente herramienta para capacitar a los nuevos
empleados y también a los que desarrollan la tarea, cuando se
realizan mejoras en el proceso.
Simbología de un diagrama de flujo
Los principales símbolos convencionales que se emplean en los
diagramas de flujo son los siguientes:
Pseudocódigo:
Un pseudocódigo (falso lenguaje), es una serie
de instrucciones a seguir pero utilizando palabras léxicas y
gramaticales referidos a los lenguajes de programación, pero sin
llegar estar estrictamente correcta su sintaxis de programación;
ni tener la fluidez del lenguaje coloquial. Permitiendo codificar
un programa con mayor agilidad que en cualquier lenguaje de
programación. Forma parte de las distintas herramientas de la
ingeniería de software y es, netamente, lenguaje de tipo
informático.
La estructura de un pseudocódigo puede ser
de tres tipos:
◦ Selectiva doble
(anidamiento).- Esta realiza una instrucción u otra según la
respuesta de la condición planteada
◦ Selectiva múltiple.- Esta realiza
instrucciones para distintos comportamientos de las condiciones,
que sería como trabajar varias selectivas dobles.
◦ Selectiva múltiple-casos.- Esta
realizara para un cierto tipo de or declarado en un inicio y
dependiendo cual sea será el tipo de comportamiento a realizar
Al igual que en el caso del diagrama de flujo existen ciertas
reglas para que sea un buen pseudocódigo:
1.-Tenga un único punto de inicio
2.-Tenga un número finito de posibles puntos de término
Las principales características de este lenguaje son:
Se puede ejecutar en un ordenador (con un IDE
como por ejemplo SLE, LPP, PilatoX, Maruga Script, Seudocódigo o
Psentl. Otros Ides de consideración son Inter-P y Algor)
Es una forma de representación sencilla de
utilizar y de manipular.
Facilita el paso del programa al lenguaje de
programación.
Es independiente del lenguaje de programación
que se vaya a utilizar.
Es un método que facilita la programación y
solución al algoritmo del programa.
Todo documento en pseudocódigo debe permitir la descripción de:
Instrucciones primitivas: Asignación (5→A), Entrada de
datos, Salida de datos.
Instrucciones de proceso: Ciclos, Operaciones con datos
Instrucciones compuestas: Desplegar algo
en pantalla, ocupar una dirección como referencia y trabajar con
ella
Instrucciones de descripción: mensajes para usuario de
que seguiría dentro del programa.
Prueba de escritorio:
Una prueba de escritorio es la comprobación lógica, de un
algoritmo de resolución.
Para desarrollar la prueba de escritorio, se utilizara el
siguiente procedimiento:
Con datos de prueba, se seguirán cada uno de los
pasos propuestos en el algoritmo de resolución. Si la prueba de
escritorio genera resultados óptimos, quiere decir que el
algoritmo posee una lógica adecuada, en caso contrario el
algoritmo tendrá que ser corregido
Ejemplo:
suma :entero
entrada :entero
menor :entero leer entrada menor
= entrada suma = 0.
Aquí presentamos el diagrama de flujo del programa que nos
ocupa:
Ejemplo 2:
Planteamiento del Problema Se necesita un programa que permita
manejar transacciones de una cuenta.
El saldo inicial de la cuenta debe ser de 0.00
El programa debe solicitar al usuario que indique si desea
realizar un depósito o un retiro.
Si el usuario elige hacer un retiro, se solicita un valor y debe
verificarse que haya saldo suficiente para retirar.
De no ser así se envía un mensaje al usuario notificando esa
situación.
Si hay saldo suficiente, se resta el valor ingresado al saldo.
Si el usuario elige hacer un depósito se solicita un valor y ese
valor se suma al saldo.
Al final de cada transacción se pregunta al usuario si desea
realizar otra transacción.
Si contesta afirmativamente, se repiten las
acciones anteriores. Si no, se termina el programa, mostrando el
saldo final de la cuenta.
Para este programa incluiremos un elemento nuevo llamado while
(mientras que)
Ciclo while
en C++.
Estructura y sintaxis. Cómo y para que usar un ciclo while en
C++
Los ciclos while son también una estructura
cíclica, que nos permite ejecutar una o varias líneas de código de
manera repetitiva sin necesidad de tener un valor inicial e
incluso a veces sin siquiera conocer cuando se va a dar el valor
final que esperamos, los ciclos while, no dependen
directamente de valores numéricos, sino de valores booleanos, es
decir su ejecución depende del valor de verdad de una condición
dada, verdadera o falso, nada más. De este modo los ciclos while,
son mucho más efectivos para condiciones indeterminadas, que no
conocemos cuando se van a dar.
¿Cómo funciona un Ciclo While?
Para comprender mejor el funcionamiento del
ciclo while, pongamos un buen ejemplo, imaginemos que por algún
motivo, queremos pedirle a un usuario una serie de números
cualquiera y que solo dejaremos de hacerlo cuando el usuario
ingrese un número mayor a 100. Como vemos, aquí no podríamos
utilizar un ciclo for, pues no tenemos ni idea de cuándo al
usuario se le va a ocurrir ingresar un número mayor que 100, es
algo indeterminado para nosotros, sin embargo el ciclo while nos
permite ejecutar una acción de forma infinita hasta que se cumpla
alguna condición especifica, en nuestro caso sería que el numero
ingresado sea mayor a 100. De modo que si el usuario nos ingresa
de manera sucesiva los siguientes numero 1,50,99, 49, 21, 30, 100
..., nuestro programa no finalizara, pues ninguno de estos números
es mayor que 100, sin embargo si nos ingresara el numero 300, el
programa finalizaría inmediatamente.
Vamos a ver ahora como es la sintaxis de un ciclo while en C++,
así estaremos listos para usarlos en nuestros programas de ahora
en adelante cada vez que lo necesitemos.
Sintaxis del Ciclo While en C++:
(REFIERASE AL EJEMPLO DE WHILE AL FINAL DEL
TEXTO)
La sintaxis de un ciclo while es simple y
"legible", pues simplemente requerimos tener clara una condición
para detenerla. En realidad, en la mayoría de los lenguajes de
alto nivel la manera de escribir un ciclo while (la sintaxis) es
incluso muy similar, así que con tan solo tener bien clara una
condición de finalización para el ciclo tendremos prácticamente
todo hecho.
while(condición de finalización) //por ejemplo numero == 100
{
....
....
Bloque de Instrucciones....
....
....
}
para la demostración de while usemos esta pequeño programa se
llamara ejercicio15.cpp:
//programa ejercicio15.cpp
#include <iostream.h>
using namespace std;
int main(int argc, char* argv[])
{
char linea[256];
long numero_de_linea=0;
cout <<"para salir presione crtl+c \n";
// para detener el proceso de captura de lineas
while (!cin.eof())
//el ciclo continua hasta que no haya caracteres disponibles,
eof() final de archivo
{
cout <<
++numero_de_linea << "\t"; //muestra el numero de linea e
incrementa el valor para el siguiente ciclo y un salta de
tabulador
cin.getline(linea,sizeof(linea)); // lee una linea de texto
cout << linea
<< endl; //muestra el contenido de la linea por
medio cin.getline
}
return 0;
}
Para CodeBlocks
Para NetBeans
Para CLI
Vamos entonces a ver línea por línea el siguiente código para
comprender todo y quedar claros. Posteriormente veremos el ejemplo
planteado y su solución.
Línea 1:
En esta línea está prácticamente todo lo esencial de un ciclo
while. La sintaxis es bastante simple. Tenemos al interior de los
paréntesis una condición cualquiera, es decir por ejemplo "==.
>, <, >=, <=, !=" o algunas mas que se nos puedan
ocurrir, esta condición que especifiquemos allí, es la que
permitirá que el ciclo se siga ejecutando hasta que en algún
momento esta misma condición deje de cumplirse, de esta forma si
por ejemplo estamos verificando que un numero_cualquiera == 50, el
ciclo se ejecutara solo cuando numero_cualquiera sea igual a 50,
en cuanto su valor cambie a cualquier otro el ciclo while
finalizara y continuara con el resto de la ejecución del programa.
De esta forma, es evidente que la condición que allí ingresemos
siempre deberá tomar un valor booleano (true o false).
Línea 2:
En la línea 2 tenemos una llave abriendo "{" lo cual como sabemos
indica que allí comienza un bloque de instrucciones que se
ejecutaran cada vez que el ciclo de un "giro". Esta llave no es
del todo obligatoria, sin embargo si no la ponemos solo se
ejecutara dentro de nuestro ciclo while la primera línea
inmediatamente posterior a la declaración del ciclo, de modo que
si deseamos que se ejecuten varias líneas dentro de nuestro ciclo,
debemos usar las llaves
Línea 3 a 7:
En estas líneas es donde estarán todas las operaciones que
queramos llevar a cabo de manera iterativa durante la ejecución
del ciclo, este bloque podrá tener la cantidad de líneas
necesarias incluso, como veremos más adelante dentro de estas
podría haber uno o más ciclos, así que podrías tener todo un
programa dentro de un ciclo.
Línea 8:
En esta última línea hacemos uso de la llave cerrando "}", una vez
más como seguramente ya debemos saber esta nos indica que allí
termina el bloque del ciclo while y se dará por terminada la
ejecución de este para continuar ejecutando el resto del
algoritmo.
en el ejemplo hacemos que la variable tt se
inicialice con el valor de 9, en el ciclo while indicamos que tt
!=0, que significa que la variable tt se compara y que se ejecute
el ciclo mientas la condicion se cumpla, entonces siempre se
efectuara el ciclo ya que tt sera diferente de 0.
aquí el diagrama de flujo:
Código fuente del programa (ejercicio16.cpp)
//programa ejercicio16.cpp
#include <iostream.h>
using namespace std;
int main(int argc, char* argv[])
{
int saldo = 0;
int tt = 9;
int valor = 0;
while ( tt != 0)
{
cout << "Tipo de
Transaccion (1=Deposito, 2=Retiro, 0=Salir del Programa): ";
cin >> tt;
if (tt == 2)
{
cout << "\n Valor de Transaccion: ";
cin >> valor;
if (valor > saldo)
cout << "Transaccion invalida. Fondos insuficientes"
<< endl;
else
saldo = saldo - valor;
}
else
if (tt == 1)
{
cout << "\n Valor de Transaccion: ";
cin >> valor;
saldo = saldo + valor;
}
else
if (tt != 0)
cout << "Tipo de Transaccion inválida" << endl;
}//termina while
cout << "Saldo Final: " << saldo << endl;
return 0;
}
Para CodeBlocks
Para NetBeans
Para CLI
Efectivamente, los condicionales son
extremadamente útiles pues permiten definirle a nuestro software
múltiples vías de ejecución contemplando así todas las
posibilidades durante la ejecución.
Condicional
switch en C++. Declaración uso y sintaxis de switch en C++
¿Qué es Condicional Switch?
Los condicionales Switch, son una estructura de
control condicional, que permite definir múltiples casos que puede
llegar a cumplir una variable cualquiera, y qué acción tomar en
cualquiera de estas situaciones, incluso es posible determinar qué
acción llevar a cabo en caso de no cumplir ninguna de las
condiciones dadas.
¿Cómo funciona el Switch?
La mejor forma de entender el funcionamiento de
algo, es viendo un ejemplo de esto, de este modo, me parece que
para comprender de forma adecuada como funciona un condicional
Switch, es bueno hacerlo poniendo un ejemplo.
Imaginemos entonces que nuestro programa consta
de un menú de opciones digamos 3 opciones, cada una representada
con un número correspondiente, es decir la opción uno corresponde
al número 1, la dos al 2 y así sucesivamente, queremos entonces
que de acuerdo a un número ingresado por el usuario ejecutemos una
acción correspondiente y en caso de que no corresponda a ninguna
de las posibles opciones, mostrar un mensaje de error cualquiera.
De este modo, podemos identificar 3 casos
distintos para nuestro switch o en otras palabras, hemos
identificado tres condiciones posibles que puede llegar a cumplir
nuestra variable: el caso uno corresponde a que el valor ingresado
por el usuario sea el 1, es decir ejecutar la opción 1, el caso 2
el número 2, etc. adicionalmente hemos encontrado la opción que se
ejecutará por defecto en caso de no suceder ninguno de estos
casos, es decir si el usuario ingresa por ejemplo 10, mostraremos
un mensaje de error cualquiera.
Espero que haya sido un tanto claro con esto, si
no es así, recuerda que puedes preguntar en la sección de
comentarios y con gusto te voy a responder o incluso modificar
esta sección para responder tu cuestión, de igual forma, vamos a
ver ya mismo unos ejemplos para entender mucho mejor de lo que he
estado hablando.
Sintaxis del Condicional Switch en C++:
La sintaxis de un condicional Switch es bastante
distinta a la de un condicional típico, sin embargo es bastante
intuitiva y fácil de comprender, es solo cuestión de
acostumbrarse. Veamos a continuación la estructura general de un
condicional Switch y luego unos cuantos ejemplos.
switch(opción) //donde opción es la variable a
comparar
{
case valor1: //Bloque de instrucciones 1;
break;
case valor2: //Bloque de instrucciones 2;
break;
case valor3: //Bloque de instrucciones 3;
break;
//Nótese que valor 1 2 y 3 son los valores que puede
tomar la opción
//la instrucción break es necesaria, para no ejecutar todos los
casos.
default: //Bloque de
instrucciones por defecto;
//default, es el bloque que se ejecuta en caso de
que no se de ningún caso
}
Vamos ahora a ver línea por línea el anterior
código para comprender todo y quedar claros. Posteriormente
veremos un ejemplo con valores reales.
Línea 1:
Aquí, tenemos la declaración del condicional
switch, estamos diciendo que lo que viene a continuación es esto,
entre los paréntesis, el switch recibe la variable que vamos a
usar para comparar en cada uno de los casos.
Línea 2:
En la línea 2 tenemos una llave abriendo "{" lo
cual como hemos visto en secciones anteriores, indica que allí
comienzan los bloques de instrucciones que se ejecutarán para cada
caso.
Línea 3:
En esta línea tenemos una parte vital del
condicional switch, aquí tenemos definido un caso posible que
puede cumplir nuestra variable, la sintaxis es simple, usamos la
instrucción "case" para indicar que allí comienza un caso, luego
indicamos el valor que puede tomar la variable, puede ser un
numero, una cadena de caracteres o lo que necesitemos, de esto se
siguen dos puntos ":" y después de estos ponemos la o las
instrucciones a ejecutar para este caso, como ejemplo, podríamos
tener algo como esto : case "Hola": cout << "Usted ha
escrito Hola";.
Línea 4:
Esta línea contiene la instrucción break, es una instrucción
simple, pero fundamental al interior del condicional Switch, esta
instrucción indica que hasta allí va el bloque de instrucciones
del caso inmediatamente anterior a este, de este modo evitamos que
el algoritmo ejecute los demás casos, a modo de ejercicio, podrías
intentar ejecutar el código del ejemplo que veremos más adelante y
quitar las instrucciones break, con esto podrás comprobar que si
el usuario ingresa por ejemplo un 1, se ejecutarán todos los
casos, es por esto que el break es fundamental.
Línea 5 a 8
Estas líneas contienen una repetición de las instrucciones de
las líneas 3 y 4, evidentemente cada una contiene un caso
distinto, ten en cuenta que se pueden definir todos los casos que
sean necesarios al interior del switch.
Líneas 9, 10 y 12
Estas líneas como deberías saber ya, contienen diferentes
comentarios sobre el código.
Línea 11
Esta línea cambia un poco con respecto a las anteriores, sin
embargo conserva la misma esencia, en vez de poner el comando
"case", usamos el comando "default", y luego los 2 puntos ":",
notemos que no se pone ningún valor a evaluar, pues esta es la
acción que se ejecuta en caso de que no lleguemos a entrar en
ninguno de los casos.
Línea 13:
En esta línea hacemos uso de la llave cerrando "}", una vez más
como seguramente ya sabrás esta nos indica que allí termina el
bloque del condicional y se dará por terminada la ejecución de
este para continuar ejecutando el resto del programa.
Ejemplo 1:
Primero, determinemos los casos a ejecutar,
tenemos tres casos posibles (suponiendo que nuestro menú está
compuesto por 3 opciones) el caso 1 para la opción 1, el dos para
la 2 y así sucesivamente. Nuestro caso por defecto (default) sería
el caso de error, que sucede cuando no se ingresa alguna de las 3
opciones. Veamos entonces como hacer esto:
Programa completo (ejercicio17.cpp)
//programa ejercicio17.cpp
# include <iostream.h>
using namespace std;
int main(int argc, char* argv[])
{
cout << "Ingrese la Opcion a ejecutar: (
1 2 3 ) ";
int opcion = 0;
cin >> opcion;
switch(opcion)
{
case 1: cout <<
"Usted ha seleccionado la opcion 1";
break;
case 2: cout <<
"Usted ha seleccionado la opcion 2";
break;
case 3: cout <<
"Usted ha seleccionado la opcion 3";
break;
default: cout <<
"Usted ha ingresado una opcion incorrecta";
}
return 0;
}
Para CodeBlocks
Para NetBeans
Para CLI
Ejemplo 2:
Menú de opciones en C++, usando char
Vamos a retomar el ejemplo anterior, pero en esta ocasión vamos
a usar caracteres (char) de C++, para determinar las opciones
ingresadas por el usuario, se debwe de considerar porque hay
situaciones donde se requires usar las caracteres.
int main(int argc, char* argv[])
{
cout << "Ingrese la Opcion a ejecutar: (a
b c) ";
char opcion;
cin >> opcion;
switch(opcion)
{
case 'a': cout <<
"Usted ha seleccionado la opcion a"; //debemos de verificar si la
opcion con la letra es con ' ' o bien con " ", depende del
compilador
break;
case 'b': cout <<
"Usted ha seleccionado la opcion b";
break;
case 'c': cout <<
"Usted ha seleccionado la opcion c";
break;
default: cout <<
"Usted ha ingresado una opcion incorrecta";
}
return 0;
}
Para CodeBlocks
Para NetBeans
Para CLI
Eso es todo. Como ves, en esencia es el mismo código, pero debes
asegurarte de poner las diferentes opciones entre comillas simples
(' ' o en su caso " "), puesto que la comparación es entre
caracteres.
Detalles sobre el condicional switch en C++
En C++, NO puedes usar otra cosa diferente a número en cada
case. Si necesitas comparar cadenas de texto u otros tipos de
datos, seguramente un condicional como el if o if-else sean una
mejor alternativa
Los caracteres también se pueden usar, pues en
esencia se pueden representar como números enteros (el lenguaje se
encarga de eso por ti). Sin embargo, como indiqué, otros tipos de
datos no son recomendables
La sentencia default es opcional, así que
si no lo deseas no la debes poner. Sin embargo, es recomendable
hacerlo, para así controlar todas las opciones posibles y que tu
programa no quede a la "suerte" en ciertos casos.
Dentro de cada case
eres libre de poner varias líneas de código, incluso otras
estructuras como condicionales o ciclos. Sin embargo, es
preferible mantener tu código ordenado y no poner muchas.
Recomendaría no poner más de 5 y preferiblemente solo una. Si
deseas hacer tareas complejas al interior de un case de un switch
en C++, posiblemente sea mejor hacer esas tareas en una función y
llamar a esa función desde el case o simplemente usar un if-else.
Así que, efectivamente, los condicionales switch
y de hecho todos los condicionales en sí, son extremadamente
útiles pues permiten definirle a nuestro software múltiples vías
de ejecución contemplando así todas las posibilidades durante la
ejecución. Me gustaría hacer una leve aclaración, el condicional
switch encuentra su utilidad al momento de tener más de una
posibilidad de valores para una variable cualquiera, evidentemente
si nuestra variable solo puede adquirir un valor útil para
nosotros, nuestra alternativa inmediata debería ser un if o un
if-else, no un switch que resulta un poco mas engorroso de
escribir, sin embargo cuando tenemos varias posibilidades es mejor
un switch que tener condicionales anidados o un condicional
después de otro.
Ciclos for
(REFIERASE AL EJEMPLO DE FOR AL FINAL DEL TEXTO)
La sentencia for permite ejecutar una sentencia
simple o compuesta, repetidamente un número de veces conocido. Su
sintaxis es la siguiente:
for ([v1=e1 [, v2=e2]...];[condición];[progresión-condición])
sentencia;
v1, v2, ... representan variables de control que serán iniciadas con
los valores de las expresiones e1, e2, ...;
condición es cualquier expresión numérica,
relacional o lógica que se evalúa a un valor verdadero o falso; si
se omite, se supone verdadera;
progresión-condición es una o más expresiones separadas por
comas cuyos valores evolucionan en el sentido de que se cumpla
la condición para finalizar la ejecución de la sentencia for;
sentencia es una sentencia simple o compuesta.
La ejecución de la sentencia for sucede de la siguiente forma:
1. Se inician las variables v1, v2, ...
2. Se evalúa la condición de finalización del bucle obteniéndose
un resultado verdadero o falso:
a) Si el resultado es verdadero (resultado true
o distinto de 0), se ejecuta el bloque de sentencias, se evalúa la
expresión que da lugar a la progresión de la condición y se vuelve
al punto 2.
b) Si el resultado es falso (resultado false o 0), la ejecución
de la sentencia for se da por finalizada y se pasa el control a la
siguiente sentencia del programa.
Por ejemplo, la siguiente sentencia for imprime los números del
1 al 100. Literalmente dice: desde i igual a 1, mientras i sea
menor o igual que 100, incrementando la i de uno en uno, escribir
el valor de i.
int i;
for (i = 1; i <= 100; i++)
cout << i << " ";
El siguiente ejemplo imprime los múltiplos de 7
que hay entre 7 y 112. Se puede observar que, en este caso, la
variable se ha declarado e iniciado en la propia sentencia for por
lo que tan sólo puede utilizarse en el mismo, también se le conoce
como ámbito de acción (esto no se puede hacer en una sentencia
while; las variables que intervienen en la condición de una
sentencia while deben haber sido declaradas e iniciadas antes de
que se procese la condición por primera vez).
for (int k = 7; k <= 112; k += 7)
cout << k << " ";
En el ejemplo siguiente se puede observar la utilización de la
coma como separador de las variables de control y de las
expresiones que hacen que evolucionen los valores que intervienen
en la condición de finalización.
int f, c; /se declaran f c como enteros
for (f = 3, c = 6; f + c < 40; f++, c += 2) // f se la asigna el
valor de 3, c se le asigna 6, observese la (,) después del 3, f+c se
suman estas 2 variables (valor de 9)
// f+c actua como valor inicial del ciclo, se compara contra un
valor menor a 40, y el ciclo se repite mientras sea menor
// a 40, f incrementa en 1 (f++), en cada ciclo, c+=2, suma el 2 en
cada ciclo, a esto se le llama asignación de valor
cout << "f = " << f << "\tc = " << c
<< endl;
Nota las asignaciones.- En C++ existe la
posibilidad de abreviar las asignaciones en las que la variable x,
implicada esté a la izquierda y a la derecha de la asignación
junto a una expresión exp, como se ilustra en la Tabla
Operador
Descripción
Equivalente
Ejemplo
x +=exp
Suma
x
= x +exp
x
+= 7
x -=exp
Resta
x
= x -exp
x
-= b
x *=exp
Producto
x
= x *exp
x
*= b + 1
x /=exp
División
x
= x /exp
x
/= 2
x &=exp
Andbit
a bit
x
= x &exp
x
&= flg
x |=exp
Orbit
a bit
x
= x |exp
x
|= 0xf7
x >>=exp
Desplazamiento a la derecha
x
= x >>exp
x
>>= 1
x <<=exp
Desplazamiento a la izquierda
x
= x <<exp
x
<<= 1
Abreviaturas de asignaciones
Dada una variable x existen cuatro operaciones especiales para
incrementarla y decrementarla, como se ilustra en la Tabla
Operador
Descripción
Equivalente aislado
1
Equivalente aislado
2
Equivalente aislado
3
Valor
++x
Preincremento
x
= x + 1
x++
x
+= 1
x
+ 1
--x
Predecremento
x
= x - 1
x--
x
-= 1
x
- 1
x++
Postincremento
x
= x + 1
++x
x
+= 1
x
x--
Postdecremento
x
= x - 1
--x
x
-= 1
x
Asignaciones de incremento y
decremento
En el caso, de ++x primero se incrementa el valor de la variable
en 1, luego se carga el valor de la variable ser usado.
En el caso, de x++ primero se carga el valor 1 de la variable
para ser usado. Después se incrementa esta variable en 1.
En el caso, de --x primero se decrementa el valor de la variable
en 1, luego se carga el valor de la variable ser usado.
En el caso, de x-- primero se carga el valor 1 de la variable
para ser usado. Después se decrementa esta variable en 1.
Tal y como se muestra en esta tabla,
aisladamente todas los incrementos son equivalentes, al igual que
todas las decrementaciones.
En el lenguaje C++ la asignación es un operador y la operación de
asignación puede formar parte de una expresión que sea parte de
otra asignación. El valor de una asignación será siempre el de su
parte derecha.
Expresión
Descripción
Valor
x = v;
Asignación:xrecibe
el valorv
v
x = x + v;
Asignación:xse
incrementa env
x +
v
x += v;
Asignación:xse
incrementa env
x +
v
++x;
Preincremento:xse
preincrementa en1
x +
1
--x;
Predecremento:xse
predecrementa en1
x -
1
x++;
Postincremento:xse
postincrementa en1
x
x--;
Postdecremento:xse
postdecrementa en1
x
y = x += v;
Asignaciones: se evalúan
de derecha a izquierda;xrecibe
el valor anterior dexincrementado
env;yrecibe
el valor anterior dexincrementado
env
x +
v
Ejemplos de valor de
asignaciones
//programa ejercicio19.cpp
# include <iostream.h>
using namespace std;
int main(int argc, char* argv[])
{
int n,i;
int suma;
cout << "Suma desde 0 hasta n.\n ";
cout << "Introduce un número n: ";
cin >> n;
for(i=suma=0;i<=n;i++)
{
suma=suma+i;
}
cout <<"Suma desde 0 hasta "<<
n << " " << " y la suma de estos " << suma;
}
Para CodeBlocks
Para NetBeans
Para CLI
Ejercicio20.cpp
//programa ejercicio20.cpp
# include <iostream.h>
using namespace std;
int main(int argc, char* argv[])
{
cout << "Suma desde 7 hasta 112, con incrementos de 7 \n";
for (int k = 7; k <= 112; k += 7) // inicia en 7, el ciclo
hasta <=112, con incrementos de 7 en 7, k+=7
{
cout << k
<< " ";
}
}
Para CodeBlocks
Para NetBeans
Para CLI
programa ejercicio21.cpp
//programa ejercicio21.cpp
# include <iostream.h>
using namespace std;
int main(int agrc, char* argv[])
{
int f, c; //se declaran f c
como enteros
for (f = 3, c = 6; f + c < 40; f++, c += 2)
// f se la asigna el valor de 3, c se le asigna 6, observese la (,)
después del 3, f+c se suman estas 2 variables (valor de 9)
// f+c actua como valor inicial del ciclo, se compara contra un
valor menor a 40, y el ciclo se repite mientras sea menor
// a 40, f incrementa en 1 (f++), en cada ciclo, c+=2, suma el 2 en
cada ciclo, a esto se le llama asignación
// de valor
cout << "f = " << f <<
"\tc = " << c << endl;
return 0;
}
Para CodeBlocks
Para NetBeans
Para CLI
Sentencia
Do-While
La sentencia Do-While es una estructura de
control de iteración en la que se prueba la condición de ciclo al
final (parte baja) del ciclo. Este formato garantiza que el cuerpo
del ciclo se ejecute por lo menos una vez. La sintaxis para
Do-While es la siguiente:
do
Sentencia
while (expresion);
Como es usual en C++, la sentencia consta de una sola sentencia
o un bloque. Asimismo, observe que Do-While termina con punto y
coma.
do
{
Sentencia1 ;
Sentencia2 ;
SentenciaM;
SentenciaN ;
} while (
Expresión );
significa “Ejecute las sentencias entre do y while siempre que
la expresión aún tenga el valor true (verdadero) al final del
ciclo”.
Compárese un ciclo While y uno Do-While que hace la misma tarea.
ejercicio 22
//programa ejercicio22.cpp
/* Uso de la sentencia DO...WHILE. */
# include <iostream.h>
using namespace std;
int main(int argc, char* argv[])
{
/* Muestra un menú si no se
pulsa 4 */
char seleccion;
do
{
cout <<
"1.- Comenzar\n";
cout <<
"2.- Abrir\n";
cout <<
"3.- Grabar\n";
cout <<
"4.- Salir\n";
cout <<
"Escoge una opción: ";
cin >>
seleccion;
switch(seleccion){
case '1':cout <<"Selecionaste la Opción 1 Comenzar \n";
break;
case '2':cout <<"Seleccionaste la Opción 2 Abrir \n";
break;
case '3':cout <<"Seleccionaste la Opción 3 Grabar \n";
}
} while(seleccion!='4'); // se realiza
mientras sea diferente de 4
return 0;
}
Para CodeBlocks
Para NetBeans
Para CLI
Ahora haga la siguiente modificación, observa el símbolo } en rojo, programa ejercicio22.cpp
//programa ejercicio22.cpp
/* Uso de la sentencia DO...WHILE. */
# include <iostream.h>
using namespace std;
int main(int argc, char* argv[])
{
/* Muestra un menú si no se
pulsa 4 */
char seleccion;
do
{
cout <<
"1.- Comenzar\n";
cout <<
"2.- Abrir\n";
cout <<
"3.- Grabar\n";
cout <<
"4.- Salir\n";
cout <<
"Escoge una opción: ";
cin >>
seleccion;
switch(seleccion){
case "1":cout <<"Selecionaste la Opción 1 Comenzar \n";
break;
case "2":cout <<"Seleccionaste la Opción 2 Abrir \n";
break;
case "3":cout <<"Seleccionaste la Opción 3 Grabar \n";
}
while(seleccion!="4");
}
return 0;
}
puedes explicar porque falla la compilación del programa.
EVIDENCIA FINAL PARA UNIDAD DE POO,
DEBERÁN DE REALIZAR UN PROGRAMA QUE
USE AL MENOS 2 SENTENCIAS DE CICLO YA SEA FOR, WHILE, DO WHILE,
SWITCH, UN CONDICIONAL, OPERADOR LOGICO, EL TEMA LIBRE COMO UDS,
LO QUIERAN DESARROLLAR, IGUAL QUE LA EVIDENCIAS, ENVIEN SOLO EL
CODIGO FUENTE, Y UNA IMAGEN DE COMO SE COMPORTA, EL NOMBRE SERA
: final_unidad1.cpp TENDRA VALOR DE 40% DE LA CALIFICACIÓN DE LA
UNIDAD 1, CONSIDERANDO LOS EJERCICIOS REALIZADOS DURANTE LA
UNIDAD
Normas para elegir una sentencia de
iteración
Las siguientes son normas para ayudarlo a decidir cuándo usar
cada una de las tres sentencias de iteración (While, Do-While y
For).
1. Si el ciclo se controla por conteo, la sentencia For es
natural. Concentrar las tres acciones de control de ciclo,
inicializar, probar e incrementar o disminuir un lugar (el
encabezado de la sentencia For) reduce las posibilidades de
olvidar incluir una de ellas.
2. Si el ciclo es controlado por suceso cuyo cuerpo se debe
ejecutar por lo menos una vez, es apropiada una sentencia
Do-While.
3. Si el ciclo se controla por suceso y nada se sabe acerca de la
primera ejecución, use una sentencia While (o tal vez una For).
4. En caso de duda, use una sentencia While.
5. Un ciclo infinito con sentencias Break en ocasiones aclara el
código pero con mucha frecuencia refleja un diseño de ciclo
carente de disciplina. Utilícelo sólo después de la consideración
adecuada de While, Do-While y For.
REFERENCIAS
https://www.programarya.com/Cursos/C++/Sistema-de-Tipos/Variables-y-Constantes
https://multiprogrammers.activo.mx/t20-estructura-de-control-bucles-y-bifurcaciones
https://www.ecured.cu/Operadores_l%C3%B3gicos
https://www.programarya.com/Cursos/C++/Condicionales
https://www.programarya.com/Cursos/C++/Condicionales/Condicional-if-else
https://www.programarya.com/Cursos/C++/Condicionales/Condicional-switch
https://www.programarya.com/Cursos/C++/Ciclos
Enciclopedia del lenguaje C++ Francisco Ceballos (pag. 145)
https://www.zator.com/Cpp/E_Ce.htm
https://www.zator.com/Cpp/E4_4_4.htm
https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C%2B%2B/Streams
http://conclase.net/c/curso/APE5
https://hetpro-store.com/TUTORIALES/compilar-cpp-g-linux-en-terminal-leccion-1/
Fuente: https://concepto.de/diagrama-de-flujo/#ixzz6szb1rbgr
https://www.aprenderaprogramar.com/index.php?option=com_content&view=article&id=322:instrucciones-condicionales-si-entonces-sino-if-then-else-ejemplos-en-pseudocodigo-cu00142a&catid=28&Itemid=59
http://lsi.vc.ehu.es/pablogn/docencia/FdI/FdIc/labs/a1/htm/asig.html
entradas y salidas de C++
http://agora.pucp.edu.pe/inf2170681/3-1.htm
Notas:
1) iostream es un componente de la biblioteca estándar (STL) del
lenguaje de programación C++ que es utilizado para operaciones de
entrada/salida. Su nombre es un acrónimo de Input/Output Stream. El
flujo de entrada y salida de datos en C++ (y su predecesor C) no se
encuentra definida dentro de la sintaxis básica y se provee por
medio de librerías de funciones especializadas como iostream.
iostream define los siguientes objetos:
cin : Flujo de entrada
cout : Flujo de salida
cerr : Flujo de error no almacenado.
clog : Flujo de error almacenado.
Todos los objetos derivados de iostream forman parte del espacio de
nombres std.
Ejemplos de codigos de programa:
While:
//******************************************************************
// Programa Hola.cpp
// Este programa demuestra un ciclo controlado por conteo
//******************************************************************
#include <iostream.h>
using namespace std;
int main (int argc, char* [argv])
{
int loopCount;
// Variable de control de
ciclo
loopCount =
1;
// Inicialización
while
(loopCount <=
10)
// Prueba
{
cout << "¡Hola!" << endl;
loopCount = loopCount + 1; //
Incremento
}
return 0;
}
For:
//******************************************************************
/* Programa tablas.cpp*/
/* Uso de la sentencia FOR. */
//******************************************************************
#include "iostream"
using namespace std;
int main (int argc, char* [argv])
{
int num,x,result;
cout << "Introduce un número: ";
cin >> num;
for (x=0;x<=10;x++){
result=num*x;
cout <<
"\n" << num<< " por " << x << " = " <<
result;
}
}
**************************************************************************
Paradigma: aquel
modelo, patrón o ejemplo que debe seguirse en determinada
situación.
Para NetBeans
