APUNTES DE PROGRAMACIÓN

1. Requisitos para poder programar en C++

 Un editor. Es el programa en el que se escribe el código.
 Un compilador. Es el traductor del código fuente a lenguaje binario. Existen
diferentes compiladores, entre ellos GCC, el cual es desarrollado por los seguidores
de software libre.

En este curso usaremos Codeblocks, un IDE (Entorno de Desarrollo Integrado) que

contiene editor, compilador y algunas otras utilidades en un mismo paquete.

2. Estructura básica de un programa en C++: El programa “Hola mundo”

#include <iostream>
using namespace std;
int main()
{
cout << "Hello world!" << endl;
return 0;
}

 Explicación línea por línea.

#include <iostream>
Incluye la librería básica de entrada (teclado) y salida de datos (pantalla) de
C++. En esta sección se incluirán todas las librerías necesarias para la ejecución de
un programa utilizando siempre la sintaxis:
#include <nombre_libreria>

using namespace std;

Permite utilizar todos los elementos de la librería standard. Si no se escribe esta
línea sería obligatorio escribir std:: antes de cada comando.

int main(void){ }
Es la función principal de nuestro programa, lo ingresado dentro de las llaves de
main, será lo que el programa haga.

cout<<"Hola Mundo"<<endl;
Muestra un mensaje en pantalla. El comando para mostrar mensajes en pantalla es
"cout" seguido de dos signos de menor que. Posteriormente se agrega el mensaje a
mostrar entre comillas. Si queremos mostrar alguna otra cosa se vuelven a agregar
los signos de menor, tal y como se muestra en el ejemplo para agregar "endl" que
indica fin de renglón en nuestro programa.

return 0;
Indica que nuestro programa ha terminado de la forma correcta, no retorna nada
(eso se explicará más delante con profundidad).
 Para ver que el programa ha funcionado, es necesario buscar la opción del editor
para compilar, generalmente con el nombre compilar o construir (build en inglés).
Si el programa no tiene errores se generará el ejecutable del programa.

3. Variables

3.1. Declaración de variables

En C++ cada variable tiene que ser declarada, con su tipo, antes de poder usarse por
primera vez. Esta declaración le informa al compilador el tamaño que debe reservar en
la memoria para una variable en particular y cómo interpretar su valor. La sintaxis para
declarar una variable es la siguiente:

Tipo nombre de la variable (identificador);

Por ejemplo:
int a;
double x;

Una vez que las variables han sido declaradas, pueden usarse en el resto del programa.
Cuando se desea declarar varias variables de un mismo tipo, se lo puede hacer en una
sola instrucción separando los diferentes identificadores con comas. Por ejemplo:

1. int a, b, c;

Esto declara tres variables enteras a, b y c, y es equivalente a escribir:

int a;
2. int b;
int c;

3.2 Inicialización de variables

Cuando una variable es declarada no tiene un valor determinado hasta que se le asigne
uno por primera vez. Sin embargo, es posible asignarle un valor el mismo momento en
el que es declarada. Esto se conoce como inicializar la variable.

En C++, existen tres formas de inicializar variables, todas son equivalentes.

 Inicialización Tipo-C: Consiste en agregar un signo igual seguido del valor con el que
se inicializará la variable:

tipo identificador = valor_inicial;

Ejemplo:
int x = 0;

Inicialización por constructor: encierra el valor inicial entre paréntesis:

tipo identificador (valor_inicial);

Ejemplo:
int x (0);

Inicialización uniforme: encierra el valor inicial entre llaves:

tipo identificador {valor_inicial};

Ejemplo:
int x {0};

Las tres formas son válidas y equivalentes en C++.

// inicialización de variables
#include <iostream>
using namespace std;
int main ()
{
int a=5; // valor inicial: 5
int b(3); // valor inicial: 3
int c{2}; // valor inicial: 2
int result; // valor inicial: indeterminado
a = a + b;
result = a - c;
cout << result;
return 0;
}

4. Introducción a strings

Los tipos fundamentales representan la mayoría de tipos básicos que manejan las
máquinas donde el código de un programa corre. Una de las fortalezas de C++ es su
gran conjunto de composición de tipos. Un ejemplo de un tipo compuesto es la clase
string.

Una variable de tipo string permite almacenar secuencias de caracteres como palabras
y oraciones. Esto es muy útil en programación.
 La primera diferencia de un tipo compuesto con un tipo fundamental es que para poder
declarar y usar estos nuevos objetos, variables de un tipo compuesto, el programa
necesita incluir el “encabezado” o “header” en donde el nuevo tipo está definido dentro
de una librería estándar. En este caso, (header <string>):

// my first string
#include <iostream>
#include <string>

using namespace std;

int main ()
{
string mistring;
mystring = "Esto es un string";
cout << mystring;
return 0;
}

Al igual que con los tipos fundamentales, los métodos de inicialización vistos
anteriormente son válidos también para strings.

string mystring = "Esto es un string";

string mystring ("Esto es un string");
string mystring {"Esto es un string"};

Los strings también pueden llevar a cabo todas las operaciones básicas que realizan
los tipos fundamentales, como ser declarados sin valor inicial y cambiar su valor
durante la ejecución.

1 // mi primer string
2 #include <iostream>
3 #include <string>
4
5 using namespace std;
Este es el contenido
6 int main ()
inicial
7 {
8 string mistring;
Este es un contenido
9 mistring = "Este es el contenido inicial";
diferente
10 cout << mistring << endl;
11 mistring = "Este es un contenido diferente";
12 cout << mistring << endl;
13 return 0;
14 }

5. Constantes

Las constantes son expresiones con un valor fijo. Pueden ser:

5.1 Literales
Es la clase de constante más obvia. Se utilizan para expresar valores particulares dentro
del código de un programa. Por ejemplo:

a = 5;

El 5 en esta porción de código es una constante literal.

Las constantes literales se clasifican en: enteros, flotantes, caracteres, strings,

booleanos, punteros, y definidos por el usuario.

5.1.1 Enteros:

1 1776
2 707
3 -273

Son constantes numéricas que identifican a valores enteros. No se encierran en

comillas ni en ningún otro símbolo. Son solamente una sucesión de dígitos que
representan a un número completo escrito en base decimal.

Las constantes literales tienen un tipo, igual que las variables. Por defecto, literales
enteros son del tipo entero, tipo int. Sin embargo, ciertos sufijos se pueden anexar
ciertos sufijos para especificar el tipo específico de entero. Así:

Sufijo Tipo entero

u or U Unsigned

l or L Long
ll or LL long long

Además, unsigned puede combinarse con cualquiera de los otros dos tipos para
formar unsigned long o unsigned long long. Por ejemplo:

1 75 // int
2 75u // unsigned int
3 75l // long
4 75ul // unsigned long
5 75lu // unsigned long

5.1.2 Flotantes

Expresan valores reales con decimales y/o exponentes. Pueden incluir punto
decimal, un carácter e, o ambos.

1 3.14159 // 3.14159 (PI)

2 6.02e23 // 6.02 x 10^23 (número de Avogadro)
3 1.6e-19 // 1.6 x 10^-19 (carga eléctrica de un electrón)
 4 3.0 // 3.0

El tipo por defecto para un literal flotante es double. Literales flotantes de tipo
float o long double pueden especificarse añadiendo uno de los siguientes sufijos:

Sufijo Tipo
f or F Float
l or L long double
Ejemplo:

1 3.14159L // long double

2 6.02e23f // float

Las letras que pueden ser parte de una constante flotante (e, f, l) pueden ser escritas
en mayúsculas o minúsculas, sin cambiar su significado.

5.1.3 Caracteres y strings

Estos literales se encierran entre comillas:

1 'z'
2 'p'
3 "Hola mundo"
4 "Cuál es tu nombre?"

Las dos primeras líneas representan literales de un carácter y, las dos siguientes,
literales compuestos de varios caracteres. Se observa que un caracter simple se
encierra entre comillas simples y los otros en doble comillas. Las comillas son
necesarias para distinguir de variables que pudieran tener el mismo nombre o de
palabras clave reservadas.

Estos literales también representan caracteres que no se pueden expresar de otra

manera en el código de un programa, como una “nueva línea” (\n) o una
“tabulación” (\tab). Estos caracteres especiales siempre van precedidos por un
backslash (\). A continuación se detalla una lista de los caracteres especiales que
aparecen con más frecuencia.

Código Descripción
\n Newline
\r carriage return
\t Tab
\v vertical tab
\b Backspace
\f form feed (page feed)
 \a alert (beep)
\' single quote (')
\" double quote (")
\? question mark (?)
\\ backslash (\)

Por ejemplo:

'\n'
'\t'
"Left \t Right"
"one\ntwo\nthree"

Varios literales tipo string pueden concatenarse para formar un solo string
simplemente separándolos por uno o más espacios en blanco, incluyendo tabs,
nuevas líneas, y otros caracteres válidos. Por ejemplo:

1 "esto forma" "un único" " string " "de caracteres"

Equivale a:

"esto forma un único string de caracteres"

Todos los literales tipo caracter y tipo string descritos anteriormente están formados
por caracteres de tipo char.

5.2 Expresiones constantes con tipo

5.2.1 Uso de const

En ocasiones conviene darle un nombre a un valor constante.

1 const double pi = 3.1415926;

2 const char tab = '\t';

Esto permite usar los nombres de las constantes en lugar de sus valores, así:

1 #include <iostream>
2
3 using namespace std;
4
5 const double pi = 3.14159; 31.4159
6 const char newline = '\n';
7
8 int main ()
9 {
 10 double r=5; // radio
11 double circle;
12 circle = 2 * pi * r;
13 cout << circle;
14 cout << newline;
15 }

5.2.2 Uso de #define

Otro mecanismo para nombrar constantes es usar un preprocesador de definiciones.

Tiene la siguiente forma:

#define identificador reemplazo

Luego de escribir esta instrucción, cada vez que aparezca en el código el

identificador será interpretado como reemplazo, donde reemplazo es cualquier
secuencia de caracteres. Este reemplazo lo hace el preprocesador y sucede antes de
que el programa sea compilado.

Ejemplo:

1
2 #include <iostream>
3
4 using namespace std;
5
6 #define PI 3.14159
7 #define NEWLINE '\n'
8
9 int main ()
10 {
11 double r=5.0; // radio
12 double circle;
13 circle = 2 * PI * r;
14 cout << circle;
15 cout << NEWLINE;
16 }

Note que las líneas de la forma #define son instrucciones al preprocesador y por lo
tanto no terminan con punto y coma.

6. Operadores

Los operadores permiten hacer operaciones entre variables y constantes. La lista completa
de operadores se muestra a continuación.

6.1 Operador de asignación (Assignment operator) (=)

Asigna un valor a una variable.

x = 5;

Esta instrucción asigna el valor entero de 5 a la variable x. La asignación siempre se hace

de derecha a izquierda y nunca en el otro sentido. Es decir,

x = y;
Asigna a la variable x el valor almacenado en la variable y.

Ejemplo:

1 // assignment operator
2 #include <iostream>
3
4 using namespace std;
5
6 int main ()
7 {
8 int a, b; // a:?, b:?
9 a = 10; // a:10, b:?
10 b = 4; // a:10, b:4
11 a = b; // a:4, b:4
12 b = 7; // a:4, b:7
13 cout << "a: "<< a;
14 cout << " b: "<< b;
15 }

Este programa imprime los valores de a y b (4 y 7, respectivamente) en pantalla.

Las operaciones de asignación son expresiones que pueden ser evaluadas. Ejemplo:

y = 2 + (x = 5);

En esta expresión le asignamos a y el resultado de una operación que incluye una

asignación. Es equivalente a:

1 x = 5;
2 y = 2 + x;

La siguiente expresión también es válida en C++:

x = y = z = 5;

permite asignar el valor de 5 a las tres variables: x, y e z.

6.2 Operadores aritméticos (Arithmetic operators) ( +, -, *, /, % )

Los cinco operadores aritméticos que soporta C++ son:

 operador descripción
+ Suma
- resta
* multiplicación
/ división
% módulo

La operación módulo da el residuo de la división entre dos valores. Por ejemplo, x = 11 %

3; da como resultado x igual a 2.

6.3 Asignación compuesta (Compound assignment)

(+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=)

Estos operadores modifican el valor actual de la variable mediante el cálculo de una

operación sobre esa misma variable. Son equivalentes a asignar el resultado de una
operación al primer operando:

Expresión equivalente a...

y += x; y = y + x;
x -= 5; x = x - 5;
x /= y; x = x / y;
precio *= unidades + 1; precio = precio * (unidades+1);

por ejemplo:

1 // operadores de asignación compuesta

2 #include <iostream>
3 using namespace std;
4
5 int main ()
6 { 5
7 int a, b=3;
8 a = b;
9 a+=2; // equivale a a=a+2
10 cout << a;
11 }

6.4 Incremento y decremento (++, --)

El operador de incremento (++) y el operador de decremento (--) aumentan o disminuyen el

valor almacenado en una variable en una unidad. Son equivalentes a +=1 y a -=1,
respectivamente. Así, las expresiones
1 ++x;
2 x+=1;
3 x=x+1;
son equivalentes en su funcionalidad. Las tres aumentan el valor de x en una unidad.

Una propiedad importante de estos operadores es que pueden usarse como prefijo tanto
como sufijo. Es decir, se pueden escribir antes del nombre de la variable (++x) o después de
éste (x++).

Sin embargo, cuando se usa los operadores en expresiones que van a ser evaluadas, el uso
de los operadores como sufijo o como prefijos puede cambiar de forma importante su
significado y el resultado final.

Prefijo: Cuando el operador de incremento se usa como prefijo (++x), la expresión se

evalúa con el valor final de x, una vez que se ha incrementado su valor. En cambio, si se
usa como sufijo (x++), la expresión se evalúa con el valor actual de x , luego de lo cual se
incrementa su valor. Ejemplo:

Ejemplo 1 Ejemplo 2
x = 3; x = 3;
y = ++x; y = x++;
// x vale 4, y vale 4 // x vale 4, y vale 3

6.5 Operadores relacionales y de comparación (Relational and comparison

operators ) ( ==, !=, >, <, >=, <= )

Dos expresiones pueden ser comparadas usando operadores relacionales o de igualdad, con
ellos se puede evaluar si dos valores son iguales, o si uno es mayor que otro, por ejemplo.
El resultado de estas operaciones es verdadero true o falso false ,es decir, es un valor
booleano. La lista de operadores se muestra a continuación:

operador descripción
== Igual a
!= No es igual a
< Menor que
> Mayor que
<= Menor o igual que
>= Mayor o igual que

Ejemplos comparando constantes:

1 (7 == 5) // evalúa como falso

2 (5 > 4) // evalúa como verdadero
3 (3 != 2) // evalúa como verdadero
4 (6 >= 6) // evalúa como verdadero
5 (5 < 5) // evalúa como falso

Ejemplos comparando variables:

Supongamos que a=2, b=3 y c=6, entonces:

1 (a == 5) // evalúa como falso, ya que a no es igual a 5

2 (a*b >= c) // evalúa como verdadero, ya que (2*3 >= 6) es verdadero
3 (b+4 > a*c) // evalúa como falso, ya que (3+4 > 2*6) es falso
4 ((b=2) == a) // evalúa como verdadero

OBSERVACIÓN: No se debe confundir al operador de asignación “es igual a”(=) con el

operador de comparación (==). Por ejemplo:

((b=2) == a) esta expresión primero asigna a b el valor de 2 y luego compara si es que es

igual al valor de a, como a también es 2, el resultado es verdadero.

6.6 Operadores Lógicos (Logical operators )( !, &&, || )

El operador ! representa la operación boolena NO. Tiene un único operando a su derecha y

lo invierte, dando como respuesta false si el valor del operando es true y true si el valor
del operando es false . Por ejemplo:

1 !(5 == 5) // evalúa como false porque (5 == 5) es true

2 !(6 <= 4) // evalúa como true porque (6 <= 4) es false

Los operadores lógicos && y || se usan para evaluar dos expresiones y obtener un solo
resultado relacional. El operador && corresponde a la operación lógica booleana Y, cuyo
resultado es verdadero true si los dos operandos son verdaderos, y falso false en caso
contrario. Así:

&& OPERADOR (y/and)

a b a && b
true true true
true false False
false true False
false false False

El operador || corresponde a la operación lógica booleana Ó, cuyo resultado es verdadero

true si cualquiera de sus operandos es verdadero, y falso solamente cuando los dos
operandos son falsos. Así:

|| OPERADOR (o/or)
a b a || b
true true True
 true false true
false true True
false false False
Por ejemplo:
1 ( (5 == 5) && (3 > 6) ) // evalúa como false ( true && false )
2 ( (5 == 5) || (3 > 6) ) // evalúa como true ( true || false )

Cuando se usan operadores lógicos, C++ evalúa solamente las expresiones que sean
necesarias de izquierda a derecha para obtener el resultado, ignorando el resto. Esto se
conoce como evaluación de circuito corto (short-circuit evaluation), y funciona de la
siguiente forma:

operador Circuito corto

&&
Si el lado izquierdo de la expresión es false el resultado combinado es
false (el lado derecho de la expresión nunca es evaluado).

||
Si el lado izquierdo de la expresión es true, el resultado combinado es true
(el lado derecho de la expresión nunca es evaluado).

Esto se debe tener muy en cuenta cuando la expresión de la derecha tenga algún efecto
importante en el programa, como por ejemplo alteración de valores de variables. Por
ejemplo:

if ( (i<10) && (++i<n) ) { /*...*/ } // note que la condición

incrementa el valor de i

6.7 Operador condicional (Conditional ternary operator) ( ? )

El operador condicional evalúa una expresión y retorna un valor específico si la

expresión es verdadera y otro valor específico si la expresión es falsa. Su sintaxis es:
condición ? resultado1 : resultado2

Si condición es true, la expresión completa da como respuesta resultado1, en caso

contrario la respuesta es resultado2.

1 7==5 ? 4 : 3 // evalúa como 3, porque 7 no es igual a 5.

2 7==5+2 ? 4 : 3 // evalúa como 4, porque 7 es igual a 5+2.
3 5>3 ? a : b // evalúa como a, porque 5 es mayor que 3.
4 a>b ? a : b // evalúa como el valor mayor, sea a o b.

Ejemplo:

1 //operador condicional
2 #include <iostream>
3
4 using namespace std;
5
6 int main ()
7 {
8 int a,b,c;
9 a=2;
10 b=7;
11 c = (a>b) ? a : b;
12 cout << c << endl;
13 }
14

En este ejemplo, a fue 2, y b fue 7, como 2>7 es falso, el resultado de la expresión es 7.

6.8 Operador explícito de conversión de tipo (Explicit type casting

operator)

Este operador permite convertir el valor de un determinado tipo en otro tipo. Existen
varias formas de realizar esta operación en C++, una de ellas es la siguiente: preceder
a la expresión a ser convertida por el nuevo tipo encerrado entre paréntesis. Por
ejemplo:

1 int i;
2 float f = 3.14;
3 i = (int) f;

convierte el número flotante 3.14 en un valor entero 3. Otra forma es usar notación
funcional , se debe escribir antes de la expresión a ser convertida el nuevo tipo y
encerrar la expresión entre paréntesis. Así:

3 i = int (f);

6.9 sizeof

Este operador acepta un parámetro que puede ser un tipo o una variable, y devuelve
el tamaño de ese objeto en bytes.

x = sizeof (char);

Aquí, a x se le asigna el valor 1, porque char es un tipo con tamaño de un byte.

El valor que retorna sizeof se determina siempre antes de la ejecución del programa.

6.10 Precedencia de operadores

Una expresión puede tener múltiples operadores. Por ejemplo:

x = 5 + 7 % 2;
En C++, esta expresión asigna 6 a la variable x, porque el operador % tiene mayor
precedencia que el operador + , y siempre es evaluado antes. Es conveniente usar
paréntesis para anular esta propiedad de precedencia e indicar claramente el orden
de las operaciones que se desean realizar. Por ejemplo:

1 x = 5 + (7 % 2); // x = 6
2 x = (5 + 7) % 2; // x = 0
Desde la mayor prioridad hacia la menor, los operadores en C++ se evalúan en el
siguiente orden:

Level Precedence group Operator Description Grouping

Left-to-
1 Scope :: scope qualifier
right
++ --
postfix increment /
decrement
() functional forms Left-to-
2 Postfix (unary)
right
[] subscript
. -> member access
++ --
prefix increment /
decrement
~ ! bitwise NOT / logical NOT
+ - unary prefix Right-to-
3 Prefix (unary) & * reference / dereference left
new delete allocation / deallocation
sizeof parameter pack
(type) C-style type-casting
Left-to-
4 Pointer-to-member .* ->* access pointer
right
Left-to-
5 Arithmetic: scaling * / % multiply, divide, modulo
right
Left-to-
6 Arithmetic: addition + - addition, subtraction
right
Left-to-
7 Bitwise shift << >> shift left, shift right
right
Left-to-
8 Relational < > <= >= comparison operators
right
Left-to-
9 Equality == != equality / inequality
right
10 And & bitwise AND Left-to-
 right
Left-to-
11 Exclusive or ^ bitwise XOR
right
Left-to-
12 Inclusive or | bitwise OR
right
Left-to-
13 Conjunction && logical AND
right
Left-to-
14 Disjunction || logical OR
right
= *= /= %= +=
-= assignment / compound
Assignment-level >>= <<= &= ^= assignment Right-to-
15
expressions |= left
?: conditional operator
Left-to-
16 Sequencing , comma separator
right

Cuando una expresión tiene dos operadores con el mismo nivel de precedencia, la
propiedad grouping determina cuál de ellos se evalúa primero, ya sea de derecha a
izquierda o de izquierda a derecha.

Nuevamente, se recomienda encerrar en paréntesis todas las expresiones que

permitan identificar claramente las instrucciones, de esta manera el código se puede
leer con facilidad.

7. Entrada/salida Básico

La librería estándar de C++ proporciona varias formas de interactuar con el usuario a

través de sus comandos input/output.

C++ usa streams para llevar a cabo operaciones de entrada y salida en medios como
teclado, pantalla o archivo. Un stream es una entidad donde un programa puede
insertar o extraer caracteres. Sin ahondar en detalles sobre su funcionamiento, lo que
se debe saber es que son fuente/destino de caracteres quienes a su vez son
entregados/recibidos secuencialmente, es decir, uno después de otro.

Los streams que se usan con mayor frecuencia son:

stream descripción
cin stream de entrada estándar
cout stream de salida estándar
7.1 Salida estándar

En la mayoría de programas, la salida estándar es la pantalla, y el stream para acceder

a ella es cout.

cout se usa junto al operador de inserción que se escribe << , por ejemplo:

1 cout << "Oración de salida"; // imprime Oración de salida

2 cout << 120; // imprime el número 120
3 cout << x; // imprime el valor de x

El operador << inserta el dato que le sigue en el stream que le precede. En el ejemplo
anterior note el uso de comillas dobles para imprimir texto literalmente, si no está
entre comillas el texto será interpretado como el identificador de una variable, y se
imprimirá el valor de tal variable.

Se pueden realizar operaciones de inserción multiples encadenadas en una sola

instrucción. Así:

cout << "Esto " << " es una " << "sola instrucción de C++";

El encadenamiento es especialmente útil cuando se combina la impresión de literales

y variables en una sola instrucción:

cout << "Tengo " << edad << " años y mi código postal es" << codigo;

cout no añade automáticamente saltos de línea al finalizar de imprimir algo en

pantalla, a menos que exista la instrucción correspondiente. Por ejemplo:

cout << "Esta es una oración";

cout << "Esta es otra oración.";

da como resultado:
Esta es una oración.Esta es otra oración.

Para insertar un salto de línea se usa endl. Por ejemplo:

1 cout << "Primera oración." << endl;

2 cout << "Segunda oración." << endl;

imprime:

Primera oración.
Segunda oración.

7.2 Entrada estándar (cin)

En la mayoría de programas la entrada estándar es a través del teclado y el stream
para acceder a ella es cin.

cin se usa con el operador de extracción que se escribe >>. Al operador le sigue la
variable en donde el dato extraído será almacenado. Ejemplo:

1 int edad;
2 cin >> edad;

La primera instrucción declara una variable de tipo entero llamada edad y la segunda
extrae desde cin el valor que se almacenará en esa variable. Esta operación hace que
el programa espere a que el usuario ingrese alguna secuencia mediante el teclado.
Esta secuencia se transmite al programa únicamente cuando se ha presionado la tecla
ENTER (o RETURN).

1 // i/o example
2 #include <iostream>
3
4 using namespace std;
5
6 int main ()
7 {
8 int i;
9 cout << "Ingrese un número entero: ";
10 cin >> i;
11 cout << "El valor ingresado es " << i;
12 cout << " y su doble es " << i*2 << endl;
13 return 0;
14 }
Cuando el usuario ingresa algo diferente a lo que se esperaba (int, string, etc) la
operación de extracción falla y el programa continua sin haber fijado el valor de la
variable, lo que producirá resultados no válidos si se usa esa variable en el programa.

Múltiples extracciones con cin también pueden ser encadenadas en una sola
instrucción para obtener más de un dato:

cin >> a >> b;

Es equivalente a:

1 cin >> a;
2 cin >> b;

En ambos casos se espera que el usuario ingrese dos valores, cualquier tipo de espacio
se usa para separar dos ingresos consecutivos, pueden ser espacio, tab, nueva línea,
etc.