ENTRADA Y SALIDA ESTANDAR C++

Un programa en C++ puede realizar operaciones de entrada y salida de varias formas

distintas. A continuación describiremos lo que se conoce como flujos. Un flujo de
entrada no es más que la serie de entradas que alimentan un ordenador para que el
programa las utilice. En esta sección supondremos que la entrada proviene del teclado.
Asimismo, un flujo de salida es la serie de salidas que el programa genera. En esta
sección supondremos que las salidas se envían a la pantalla de un terminal.
Salidas con cout.

Los valores de variables se pueden enviar a la pantalla empleando cout. Es posible

enviar a la pantalla cualquier combinación de variables y cadenas.
Por ejemplo:

cout << num_dulces << “dulces\n”;

Esta instrucción le dice a la computadora que despliegue dos cosas: el valor de la
variable num_dulces y la cadena “dulces\n”. Esta instrucción es equivalente a:
cout << num_dulces ;
cout << “dulces\n”;

Se pueden incluir expresiones aritméticas, como se muestra en el siguiente ejemplo:

cout << “El precio total es: “ << (precio1 + precio2);

El doble símbolo << se conoce como operador de inserción.

En los ejemplos anteriores hemos utilizado una secuencia de carácteres especial ‘\n’.
Esta secuencia indica al ordenador que salte a una nueva línea en la salida.
Existen otros secuencias especiales. Todas ellas empiezan con ‘\’ y se les llama
secuencias de escape. No deben aparecer espacios entre ‘\’ y el carácter.
Algunas secuencias de escape:
\n nueva línea

BUCLES C++
Los bucles o ciclos en C++. Declaración, uso y sintaxis de un ciclo en C++
Los ciclos o también conocidos como bucles, son una estructura de control esencial al momento de
programar. Tanto C como C++ y la mayoría de los lenguajes utilizados actualmente, nos permiten hacer
uso de estas estructuras. Un ciclo o bucle permite repetir una o varias instrucciones cuantas veces lo
necesitemos, por ejemplo, si quisiéramos escribir los números del uno al cien no tendría sentido escribir
cien líneas mostrando un numero en cada una, para esto y para muchísimas cosas más, es útil un ciclo,
permitiéndonos hacer una misma tarea en una cantidad de líneas muy pequeña y de forma
prácticamente automática.
Existen diferentes tipos de ciclos o bucles, cada uno tiene una utilidad para casos específicos y depende
de nuestra habilidad y conocimientos poder determinar en qué momento es bueno usar alguno de ellos.
Tenemos entonces a nuestra disposición los siguientes tipos de ciclos en C++:

Ciclo for en C++

Ciclo while en C++
Ciclo do-while en C++

FOR
Los ciclos for son lo que se conoce como estructuras de control de flujo cíclicas o simplemente
estructuras cíclicas, estos ciclos, como su nombre lo sugiere, nos permiten ejecutar una o varias líneas
de código de forma iterativa, conociendo un valor especifico inicial y otro valor final, además nos
permiten determinar el tamaño del paso entre cada "giro" o iteración del ciclo.

WHILE
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 a diferencia de los ciclos for,
con los cuales se debe tener claro un principio, un final y un tamaño de paso.

DO WHILE
Los ciclos do-while son una estructura de control cíclica, los cuales nos permiten ejecutar una o varias
líneas de código de forma repetitiva sin necesidad de tener un valor inicial e incluso a veces sin siquiera
conocer cuando se va a dar el valor final, hasta aquí son similares a los ciclos while, sin embargo el ciclo
do-while nos permite añadir cierta ventaja adicional y esta consiste que nos da la posibilidad de ejecutar
primero el bloque de instrucciones antes de evaluar la condición necesaria, de este modo los ciclos do-
while, son más efectivos para algunas situaciones especificas. En resumen un ciclo do-while, es una
estructura de control cíclica que permite ejecutar de manera repetitiva un bloque de instrucciones sin
evaluar de forma inmediata una condición especifica, sino evaluándola justo después de ejecutar por
primera vez el bloque de instrucciones.

OPERADORES EN C++
¿Qué es un OPERADOR?
“Un operador es un elemento de programa que se aplica a uno o varios operandos en una expresión
o instrucción. Los operadores que requieren un operando, como el operador de incremento se
conocen como operadores unarios. Los operadores que requieren dos operandos, como los
operadores aritméticos (+,-,*,/) se conocen como operadores binarios. Un operador, el operador
condicional (?:), utiliza tres operandos y es el único operador ternario de C++” [1].
Existen 6 tipos de operadores según su función, que son aritméticos, relacionales, de asignación,
lógicos, de dirección y de manejo de Bits.
OPERADORES ARITMÉTICOS
Los operadores aritméticos se usan para realizar cálculos y operaciones con números reales y
punteros [2]. Básicamente permiten hacer cualquier operación aritmética que se necesite. Los
operadores más comunes son [3]:
Operador Acción Ejemplo Resultado

- Resta X = 5 - 3 X vale 2
+ Suma X = 5 + 3 X vale 8
* Multiplicación X = 2 * 3 X vale 6
/ División X = 6 / 3 X vale 2
% Módulo X = 5 % 2 X vale 1
-- Decremento X = 1; X-- X vale 0
++ Incremento X = 1; X++ X vale 2

La operación modulo corresponde a obtener el residuo de la división, de modo que al dividir 5 entre
2 tendremos como resultado 2 y como residuo 1, por tanto 5 % 2 corresponde al 1 que sobra de la
división exacta.Es necesario hacer una observación acerca de los operadores de incremento y
decremento, ya quedependiendo de su ubicación con respecto a la variable, se tienen acciones
diferentes. Si el operadorprecede a la variable, se conoce como pre-incremento o pre-decremento y se
dice que el operadorestá en su forma prefija. Por el contrario, si el operador es posterior a la variable
se encuentra en laforma posfija y se le llama pos-incremento o pos-decremento según el caso.
“Cuando un operador de incremento o decremento precede a su variable, se llevará a cabo la
operación de incremento o de decremento antes de utilizar el valor del operando”, tal y como se
muestra en el siguiente ejemplo:

int x,y;
x = 2004;
y = ++x;
/* x e y valen 2005. */
En el caso de los post-incrementos y post-decrementos pasa lo contrario: se utilizará el valor actual
del operando y luego se efectuará la operación de incremento o decremento” [3].

int x,y
x = 2004;
y = x++;
/* y vale 2004 y x vale 2005 */
Tal y como se presentó anteriormente, también existen operadores para los punteros, sin embargo
estos solo aplican para aquellos apuntadores a matrices, arreglos o listas de elementos, y aunque se
muestran a continuación, se explicaran de una mejor forma en el material de apuntadores o punteros
“Los operadores relacionales, también denominados operadores binarios lógicos y de comparación,
se utilizan para comprobar la veracidad o falsedad de determinadas propuestas de relación (en
realidad se trata respuestas a preguntas). Las expresiones que los contienen se denominan
expresiones relacionales. Aceptan diversos tipos de argumentos, y el resultado, que es la respuesta a
la pregunta, es siempre del tipo cierto/falso, es decir, producen un resultado booleano.
Si la propuesta es cierta, el resultado es true (un valor distinto de cero), si es falsa será false (cero).
OPERADORES LÓGICOS C++
“Los operadores lógicos 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). Por el contrario, las operaciones entre bits producen valores arbitrarios.
Los operadores lógicos son tres, dos de ellos son binarios y el último (negación) es unario:
Operador Acción Ejemplo Resultado

&& AND Lógico A && B Si ambos son verdaderos se

obtiene verdadero(true)
|| OR Lógico A || B Verdadero si alguno es verdadero
! Negación Lógica !A Negación de a

AND lógico
Devuelve un valor lógico true si ambos operandos son ciertos. En caso contrario el resultado es false.
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 (recuérdese que en el diseño de C++ prima
la velocidad).
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.

OR Lógico
Este operador binario devuelve true si alguno de los operandos es cierto. En caso contrario devuelve
false. 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
(recuérdese que en el diseño de C++ prima la velocidad).
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.

NOT Lógico
Este operador es denominado también No lógico 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). El operando (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 unaconversió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 otraspalabras: este operador devuelve cierto (true) si la
expresión se evalúa a distinto de cero, en caso contrario devuelve falso (false).
VECTORES EN C++
¿Cómo se puede manejar un vector?
Ejemplo:

#include <iostream>

using namespace std;

int main()
{
int v[] = { 45, 23, 22, 12, 11, 10, -1 };
for(int i = 0; v[ i ] != -1; ++i) {
cout << v[ i ] << endl;
}

return 0;
}
Un posible programa que maneje un vector es éste, publicado ya la semana pasada.
Los vectores son espacios contíguos en memoria, de manera que podemos acceder a sus elementos
utilizando el nombre del vector, los corchetes, y la posición.

v[ 0 ] = 11;
cout << v[ 0 ] << endl;
En el programa anterior, se utiliza un centinela para indicar el fin del vector, puesto que en C/C++ (al
contrario que en Java) no tenemos de un "miembro" length que nos indique el número de elementos.

De hecho, es bastante típico crear constantes que nos indiquen el número de elementos que contiene
un vector:

#include <iostream>

using namespace std;

const int MaxElementos = 6;

int main()
{
int v[] = { 45, 23, 22, 12, 11, 10 };
for(int i = 0; i < MaxElementos; ++i) {
cout << v[ i ] << endl;
}

return 0;
}
VECTORES DE TIPO COMPLEJO
Finalmente, no es necesario que el tipo del vector (o matriz) sea un tipo básico, como int. También
puede ser una estructura. Por ejemplo:

#include <iostream>

using namespace std;

const int MaxDimensiones = 2;

struct Complejo {
int a;
int b;
};

void muestra(Complejo v[][MaxDimensiones])

{
for(int i = 0; i < MaxDimensiones; ++i) {
for(int j = 0; j < MaxDimensiones; ++j) {
cout << v[ i ][ j ].a << '+' << v[ i ][ j ].b << 'i' << endl;
}
}
}

int main()
{
Complejo v[MaxDimensiones][MaxDimensiones];

v[0][0].a = 1; v[0][0].b = 2;
v[0][1].a = 6; v[0][1].b = 7;
v[1][0].a = 88; v[1][0].b = 99;
v[1][1].a = 56; v[1][1].b = 78;

muestra( v );

return 0;
}

En este ejemplo se utilizan los números complejos para ilustrar una estructura usada dentro de un vector.
ESTRUCTURAS C++
Las estructuras de datos en C++ se pueden entender como un tipo de dato compuesto (no complejo).
Las estructuras de datos permiten almacenar de manera ordenada una serie de valores dados en una
misma variable. Las estructuras de datos más comunes son los vectores o arreglos y las matrices,
aunque hay otras un poco más diferentes como son el struct y las enumeraciones.

En esta serie de contenidos aprenderemos de éstas con detalle. Las estructuras de datos han sido
creadas para solucionar una gran variedad de problemáticas que no eran solucionables (o al menos no
muy fácilmente) con los tipos de datos primitivos. Tal como mencioné hace un momento las estructuras
de datos se pueden ver como una agrupación o estructuración para una serie de tipos de datos
primitivos (aunque también pueden poseer tipos de datos complejos) que pueden ser fácilmente
utilizadas e identificadas. Sin la existencia de las estructuras de datos sería imposible o bastante
complicado por ejemplo conocer y manejar todos los números de identificación, nombres y direcciones
de todos los usuarios de un sistema (que normalmente serían muchísimos) pero ahora con las
estructuras de datos es muy simple definir una serie de posiciones en memoria para cada valor que
deseamos guardar o definir un orden o valores específicos para cada campo y accediendo a ellos
generalmente por medio de una única variable, todo esto es sencillo hacerlo con el uso de las
estructuras de datos y sin desperdiciar recursos.

ARRAYS AREGLOS O VECTORES C++

Los arrays, arreglos o vectores forman parte de la amplia variedad de estructuras de datos que nos
ofrece C++, siendo además una de las principales y más útiles estructuras que podremos tener como
herramienta de programación. Los arrays, arreglos o vectores (como los quieras llamar), son utilizados
para almacenar múltiples valores en una única variable. En un aspecto más profundo, los arrays,
permiten almacenar muchos valores en posiciones de memoria continuas, lo cual permite acceder a un
valor u otro de manera rápida y sencilla. Estos valores pueden ser números, letras o cualquier tipo de
variable que deseemos incluso tipos de datos propios.

En múltiples ocasiones es necesario almacenar gran cantidad de información en una variable y a

menudo sucede que no conocemos con exactitud la cantidad de datos que debemos almacenar, pero
sabemos que sí sería más de uno, como por ejemplo almacenar las identificaciones de las personas
ingresadas al sistema. Los arrays, arreglos o vectores son una estructura que nos permite solucionar
este tipo de problemas.

ARCHIVOS C++
Operaciones de escritura en archivos
El archivo de cabecera fstream.h define las clases ifstream, ostream y fstream para operaciones de
lectura, escritura y lectura/escritura en archivos respectivamente. Para trabajar con archivos debemos
crear objetos de éstas clases de acuerdo a las operaciones que deseamos efectuar. Empezamos con las
operaciones de escritura, para lo cual básicamente declaramos un objeto de la clase ofstream, después
utilizamos la función miembro open para abrir el archivo, escribimos en el archivo los datos que sean
necesarios utilizando el operador de inserción y por último cerramos el archivo por medio de la función
miembro close.
En el programa se ha creado un objeto de la clase ofstream llamado archivo, posteriormente se utiliza
la función miembro open para abrir el arcivo especificado en la cadena de texto que se encuentra dentro
del paréntesis de la función. Podemos invocar a la función constructora de clase de tal manera que el
archivo también se puede abrir utilizando la siguiente instrucción:

ofstream archivo("datos.txt"); // constructora de ofstream

Naturalmente, al utilizar la función constructora ya no es necesario utilizar la función miembro open,

ésta forma de abrir un archivo es preferida porque el código es más compacto y fácil de leer. De la misma
forma que se utilizan manipuladores de salida para modificar la presentación en pantalla de los datos
del programa, igual es posible utilizar éstos manipuladores al escribir datos en un archivo.

MODOS DE APERTURA DE ARCHIVOS

Al especificar la apertura de un archivo como se ha mostrado en los programas anteriores, el programa
sobreescribe cualquier archivo existente llamado Datos.txt en el directorio de trabajo del programa.
Dependiendo del propósito del programa es posible que sea necesario agregar datos a los ya existentes
en el archivo, o quizá sea necesario que las operaciones del programa no se lleven a cabo en caso de
que el archivo especificado exista en el disco, para éstos casos podemos especificar el modo de apertura
del archivo incluyendo un parámetro adicional en el constructor, cualquiera de los siguientes:

ios::app Operaciones de añadidura.

ios::ate Coloca el apuntador del archivo al final del mismo.

ios::in Operaciones de lectura. Esta es la opción por defecto para objetos de la clase ifstream.

ios::out Operaciones de escritura. Esta es la opción por defecto para objetos de la clase ofstream.

ios::nocreate Si el archivo no existe se suspende la operación.

ios::noreplace Crea un archivo, si existe uno con el mismo nombre la operación se suspende.

ios::trunc Crea un archivo, si existe uno con el mismo nombre lo borra.

ios::binary Operaciones binarias.

De esta manera, podemos modificar el modo de apertura del programa archiv02.cpp para que los datos
del programa se concatenen en el archivo Datos.txt simplemente escribiendo el constructor así:
ofstream archivo("Datos.txt", ios::app);. Si deseamos que el programa no sobreescriba un archivo
existente especificamos el constructor de ésta manera: ofstream archivo("Datos.txt", ios::noreplace);.
Utilizando los especificadores de modo de apertura se puede conseguir un mayor control en las
operaciones de E/S en archivos.
OPERACIONES DE LECTURA DE ARCHIVOS
Para abrir un archivo y realizar operaciones de lectura se crea un objeto de la clase ifstream y se procede
prácticamente de la misma forma que lo expuesto en el apartado anterior. Después de abrir el archivo
se puede leer su contenido utilizando las funciones miembro de la clase ifstream o bién el operador de
extracción. Cuando se lee un archivo, por lo general se empieza al principio del mismo y se leerá su
contenido hasta que se encuentre el final del archivo. Para determinar si se ha llegado al final del archivo
se puede utilizar la función miembro eof como condición de un bucle while. Además se puede utilizar
la función miembro fail para detectar un error al abrir el archivo.

Para determinar el éxito de la operación de apertura del archivo Pruebas.txt. La función miembro fail( )
produce el valor de 1 si ocurre un error en la operación de archivo. Similarmente es recomendable
utilizar otras funciones para verificar no solo la apertura de archivo sino también las operaciones de
lectura y escritura, las funciones miembro que nos permiten éstas pruebas son las siguientes:

good Produce un 1 si la operación previa fué exitosa.

eof Produce un 1 si se encuentra el final del archivo.

fail Produce un 1 si ocurre un error.

bad Produce un 1 si se realiza una operación inválida.

OPERACIONES CON ARCHIVOS BINARIOS

Las operaciones de flujos de archivos se ejecutan en forma predeterminada en modo de texto, sin
embargo hay ocasiones en donde se requiere realizar operaciones en archivos binarios, como sucede
con archivos de estructuras de datos ó aquellos que contienen datos numéricos de punto flotante. A
manera de prueba trate de relaizar una copia de un archivo ejecutable utilizando el programa
archiv04.cpp, se dará cuenta que si bién, el programa no marca errores, el resultado sencillamente no
es el esperado. La prueba definitiva es comparar el tamaño en bytes del archivo original contra el
tamaño del archivo copiado.

OPERADORES DE ESCRITURA
El archivo de cabecera fstream.h define las clases ifstream, ostream y fstream para operaciones de
lectura, escritura y lectura/escritura en archivos respectivamente. Para trabajar con archivos debemos
crear objetos de éstas clases de acuerdo a las operaciones que deseamos efectuar. Empezamos con las
operaciones de escritura, para lo cual básicamente declaramos un objeto de la clase ofstream,
después utilizamos la función miembro open para abrir el archivo, escribimos en el archivo los datos
que sean necesarios utilizando el operador de inserción y por último cerramos el archivo por medio de
la función miembro close.
SALIDA A IMPRESION
De la misma manera en que es posible escribir la salida en un archivo, habrá ocasiones en las que es
necesario producir constancia en papel utilizando una impresora. En general es posible tratar a la
impresora como uno más de los dispositivos disponibles para la salida de datos, se crea un objeto de la
clase ofstream especificando como nombre de archivo la palabra PRN.

Explicación parcial 2
Función fflush
Esta función sirve para limpiar el buffer de entrada stdin estándar input. Usualmente quedan
almacenados algunos datos en el buffer sobre todo saltos de línea y espacio y se debería usar luego de
insertar un número o una cadena.

Diseño
El diseño fue trabajado mediante variables de tipo char que almacenan valores para generar el código
ASCII.

Vectores
los vectores fueron trabajados como vectores unidimensionales tipo globales.

Función .append
Agrega una copia de una subcadena de str. La subcadena es la parte de str que comienza en la
posición del carácter subposiciones y abarca caracteres subblenados (o hasta el final de str, si str es
demasiado corto o si sublen es string :: npos).