Formatted: Right: 0.

23"
Estructura de un Programa en C++

// Comentario: Mi primer programa en C++

//Declaracion de la directiva de procesador (bibliotecas)
#include <iostream>
using namespace std;
int main ()
{
cout << "Hola Mundo!" ;
return 0;
}
Imprime Hola Mundo!

Analicemos por línea de comandos el programa anterior

#include <iostream>
Las líneas de directivas para el preprocesador comienzan con el signo ( # ).
La directiva #include <iostream> indica al preprocesador incluir el archivo iostream estándar. Este
incluye las declaraciones de la biblioteca de entrada-salida de C + +.

using namespace std;

Todos los elementos de la biblioteca de C + + se declaran dentro de lo que se llama un espacio de
nombres. Esta línea es muy frecuente en los programas de C + + que utilizan la biblioteca estándar.
int main ()
Esta línea específica el comienzo de la definición de la función principal. La función principal es el punto
por donde todos los programas C + + comienzan su ejecución, independientemente de su ubicación
dentro del código fuente. No importa si hay otras funciones con otros nombres antes o después de ella.
Todos los programas de C + + tiene una función principal.
La palabra main va seguida de paréntesis ( ). Esto es así porque se trata de una declaración de la
función: en C + +, lo que diferencia a una declaración de la función de otros tipos de expresiones son
estos paréntesis que siguen a su nombre. Opcionalmente, estos paréntesis, podrá tener una lista de
parámetros dentro de ellos.

Cuerpo de la función principal

Inmediatamente después de estos paréntesis se encuentra el cuerpo de la función principal entre llaves
{}. Lo que está contenido dentro de estas llaves es lo que hace la función cuando se ejecuta.

cout << "Hola Mundo!";

Esta línea es una instrucción C + +. Es una acción que genera un efecto visible en nuestro programa.

cout es el nombre de la secuencia de salida estándar en C + +, cout se declara en el archivo iostream

estándar dentro del espacio de nombres std, por eso tenemos que declarar que se va a utilizar el espacio
de nombres aa principios de nuestro código.
La declaración termina con un punto y coma ( ; ). Este carácter se utiliza para marcar el final de la
declaración y, de hecho, debe incluirse al final de todas las declaraciones de expresión en todos los
programas C + +.
return 0;
La sentencia return indica el fin de la función principal. return puede ser seguido por un código de retorno
Un código de retorno 0 para la función principal se interpreta generalmente como el programa funcionó
como se esperaba sin ningún error durante su ejecución. Esta es la forma más habitual para poner fin a
un programa en C + + de la consola.

Escritura del programa

C + +, no tiene reglas estrictas sobre la manera de separar las instrucciones en diferentes líneas.
En C + +, la separación entre las declaraciones se especifica con un punto y coma final ( ; )
Las directivas de preprocesador (aquellos que empiezan por # ) están fuera de esta regla general, ya
que no son declaraciones. Son líneas leídas y procesadas por el preprocesador y no producen ningún
código por sí mismos.

Vamos a agregar una instrucción adicional para nuestro programa:

// Mi Segundo programa en C++
#include <iostream>
using namespace std;
int main ()
{
cout << "Hola Mundo! " ;
cout << "Soy un programa C++;
return 0;
}

Comentarios
// mi primer programa en C++
Línea de comentario. Comienzan con dos signos de barra ( // ) y no tienen ningún efecto sobre el
comportamiento del programa. El programador puede utilizarlo para incluir breves explicaciones u
observaciones de su propio código fuente. Podemos usar /* Comentario*/ para escribir un bloque de
texto.

Comentario de línea: // line comment

Comentario de bloque: /* block comment */

Vamos a añadir comentarios a nuestro programa:

/* Mi programa en C++ con más comentarios*/

#include <iostream>
using namespace std;
int main ()
{
cout << "Hola mundo!";
// Imprime hola mundo!
cout << "Yo soy un programa en C++" ;
// Imprime yo soy un programa en C++
return 0;
}
Variables. Tipos de datos.
Podemos definir una variable como una porción de memoria para almacenar un valor determinado. Cada variable
tiene un identificador que lo distingue de los demás
a = 5; b = 2; a = a + 1; result = a - b;

los identificadores de las variables serian a , b y result

Identificadores
Un identificador válido es una secuencia de una o más letras, números o caracter de subrayado. Sólo letras, dígitos
y caracteres de subrayado son válidos. Además, los identificadores de variables siempre tienen que comenzar con
una letra. También puede comenzar con un carácter de subrayado, pero en algunos casos éstos pueden ser
reservados para las palabras clave específicas del compilador o identificadores externos.

No puede coincidir con palabras clave del lenguaje C + +, ni los específicos de su compilador, que son palabras
clave reservadas. Las palabras clave reservadas estándar son:

asm, auto, bool, break, case, catch, char, class, const, const_cast, continue, default, delete, do, double,
dynamic_cast, else, enum, explicit, export, extern, false, float, for, friend, goto, if, inline, int, long, mutable,
namespace, new, operator, private, protected, public, register, reinterpret_cast, return, short, signed, sizeof, static,
static_cast, struct, switch, template, this, throw, true, try, typedef, typeid, typename, union, unsigned, using, virtual,
void, volatile, wchar_t, while

Las representaciones de operadores no se pueden utilizar como identificadores, ya que son palabras reservadas
bajo algunas circunstancias:

and, and_eq, bitand, bitor, compl, not, not_eq, or, or_eq, xor, xor_eq

Muy importante: El lenguaje C + + es "sensible al lenguaje". Esto significa que un identificador escrito en letras
mayúsculas no es equivalente a otro con el mismo nombre pero escrito en letras minúsculas.

Tipos de datos fundamentales

Resumen de los tipos de datos básicos fundamentales en C + +:
Tamaño
Nombre Descripción * El rango
*
firmado: -128 a 127
char Carácter o entero pequeño. 1byte
sin signo: 0 a 255
short int ( firmado: -32768 a 32767
Entero corto. 2bytes
short ) sin signo: 0 a 65535
firmado: -2147483648 a
int Entero. 4bytes 2147483647
sin signo: 0 a 4294967295
firmado: -2147483648 a
long int (
Entero largo. 4bytes 2147483647
long )
sin signo: 0 a 4294967295
Valor booleano. Se puede tomar uno de dos
bool 1byte true o false
valores: verdadero o falso.
+ / - 3.4e + / - 38 (~ 7
float Número de punto flotante. 4bytes
dígitos)
+ / - 1.7e + / - 308 (~ 15
double De doble precisión de coma flotante. 8bytes
dígitos)
+ / - 1.7e + / - 308 (~ 15
long double Largo de doble precisión de coma flotante. 8bytes
dígitos)
2ó4
wchar_t Carácter ancho. Un carácter ancho
bytes
Declaración de variables
Para utilizar una variable en C + +, primero debe declar el tipo de datos que queremos. La sintaxis para declarar
una variable es: especificar el tipo de datos (como int, bool, float ...) seguido de un identificador de variable válido
Tipo de dato Nombre de Variable;

Ejemplo: int a; float mynumber;

Podemos declarar varias variables del mismo tipo, separando sus identificadores con comas.

Por ejemplo: int a, b, c;

Los tipos de datos int, char, short, int largo y puede ser con signo o sin signo. Tipos con signo pueden
representar los valores tanto positivos como negativos, mientras que los tipos sin signo sólo puede representar
valores positivos (y cero).

Por ejemplo: unsigned short int NumberOfSisters;

signed int MyAccountBalance;

Por defecto, si no se especifica si el tipo de dato es con/sin signo el compilador asumirá que es con signo: int
MyAccountBalance; //variable con signo

Una excepción a esta regla es el tipo char, pensada para almacenar caracteres. Debe usar ya sea signed charo
unsigned char , si tiene la intención de almacenar los valores numéricos en una variable de tipo char de tamaño.

short y long se pueden usar solos como especificadores de tipo. En este caso, se refieren a sus respectivos tipos
enteros fundamentales: short es equivalente a short int y long es equivalente a long int.

short Year; short int Year;

Por último, signed y unsigned también puede ser utilizado como especificadores de tipo independientes, y so
equivalentes a signed int y unsigned int respectivamente.

unsigned NextYear; unsigned int NextYear;

Ejemplo:
// Operaciones con variables
#include <iostream>
using namespace std;
int main ()
{
// Declaración de variables:
int a, b; int result;
// Procesoso:
a = 5; b = 2; a = a + 1;
result = a - b;
// Imprime los resultados:
cout << result;
// Termina el programa:
return 0;
}
Alcance de las variables
Una variable puede ser cualquiera de alcance global o local. Una variable global es una variable declarada en el
cuerpo principal del código fuente, fuera de todas las funciones, mientras que una variable local es declarada
dentro del cuerpo de una función o un bloque.

Las variables globales pueden ser referidos desde cualquier parte del código, incluso dentro de las funciones,
siempre que sea después de su declaración.

Inicialización de variables
Cuando se declara una variable local regular, su valor por defecto es indeterminado. Sin embargo, es posible que
desee una variable para almacenar un valor concreto en el momento en que se declara. Con el fin de hacer esto,
puede inicializar la variable. Hay dos maneras de hacer esto en C + +:

1. A la declaración de la variable, se añade un signo igual seguido por el valor para inicializar la variable:
Sintaxis: type identifier = Valor_inicial;
Ejemplo: int a=0;

2. Conocida como la inicialización del constructor, encerrar el valor inicial entre paréntesis ( ):
Sintaxis: type identifier (Valor_inicial);
Ejemplo: int a (0)
// Inicialización de variables
#include <iostream>
using namespace std;
int main ()
{
int a=5;
// Inicializa value = 5
int b(2);
// Inicializa value = 2
int result;
// Inicializa value a un valor indeterminado
a = a + 3;
result = a - b;
cout << result;
return 0;
}
Introducción a las cadenas
Las variables que pueden almacenar valores no numéricos que son más de un carácter se conoce como cadenas.

La biblioteca de C + + proporciona apoyo para el manejo de cadenas a través de la clase string.

Para usar objetos (variables) de este tipo es necesario incluir un archivo de cabecera adicional en el código
fuente: <string> y tener acceso al espacio de nombres estándar (declaración using namespace std;).

// Mi primer cadena
#include <iostream>
#include <string>
using namespace std;
int main ()
{
string micadena = "Esta es una cadena" ;
cout << micadena;
return 0;
}
Como se puede ver en el ejemplo anterior, las cadenas se pueden inicializar con cualquier cadena válida literal.
Ambos formatos son válidos para inicializar variables de cadena:

string micadena = "Esta es una cadena" ;

string micadena ( "This is a string" );

Con las cadenas también se pueden realizar todas las operaciones básicas que con otros tipos de datos
fundamentales

// mi primer cadena
#include <iostream>
#include <string>
using namespace std;
int main ()
{
string micadena;
mystring = "Este es el contenido de la cadena inicial" ;
cout << micadena << endl;
mystring = "Esta es el contenido de una cadena diferente" ;
cout << micadena << endl;
return 0;
}

Constantes
Las constantes son expresiones con un valor fijo.

Literales
Las literales son el tipo más obvio de las constantes. Se utilizan para expresar valores particulares dentro del
código fuente de un programa.
a = 5;
El 5 en esta parte del código es una constante literal.

Constantes literales pueden ser divididas en: números enteros, números en coma flotante, caracteres, cadenas y
valores booleanos.
Números enteros
1776 707 -273 Son constantes numéricas que identifican valores enteros sin decimales.
C++ permite números decimales, octales (base 8) y hexadecimales (base 16) como constantes literales. Para
expresar un número octal tiene que ir precedido de un 0(cero), un hexadecimal tiene que ir precedido por los
caracteres 0x (cero, x).

Ejemplo: 75 // decimal 0113 // octal 0x4b // hexadecimal

Por defecto, las literales enteras son de tipo int. Sin embargo, podemos obligarlas a ser sin signo añadiendo el
carácter u , o largo añadiendo l:

75 // int 75u // unsigned int 75l // long 75ul // unsigned long

En ambos casos, el sufijo se puede especificar usando letras mayúsculas o minúsculas.

Números de punto flotante

Expresan los números con decimales y / o exponentes. Se puede incluir el punto decimal, una e seguida de
enteros, o ambos un punto decimal y una e seguida de enteros:

3.14159 // 3.14159 6.02e23 // 6.02 x 10^23 1.6e-19 // 1.6 x 10^-19 3.0 // 3.0

El tipo por defecto para los literales de punto flotante es el doble. Si queremos expresar de forma explícita un
flotante o un largo doble numérica literal, puede utilizar los sufijos f, l o s, respectivamente:

3.14159L // long double 6.02e23f // float

Cualquiera de las letras que se usan en una constante numérica de punto flotante ( e , f , l ) se puede escribir
usando letras mayúsculas o minúsculas.

De caracteres y la cadena de literales

También existen constantes no numéricas, tales como:
'z' 'p' "Hello world" "How do you do?"
Las dos primeras son constantes de caracteres, y las dos siguientes son cadenas.
Para expresar un solo carácter se debe poner entre comillas simples ( ' ) y para expresar una cadena se debe
poner entre comillas ( " ).
X referencia una variable
‘x’ referencia una constante de caracteres
Códigos de escape. Son caracteres especiales todos ellos están precedidos por una barra invertida ( \ ).

\n salto de línea
\r retorno de carro
\t tabulador
\v tabulador vertical
\b tecla de retroceso
\f la forma de alimentación (alimentación de página)
\a alerta (zumbido)
\' comilla simple (')
\" comillas (")
\? signo de interrogación (?)
\\ barra invertida (\)

Por ejemplo: '\n' '\t' "izquierda \t Derecha" "uno\ndos\ntres"

 Además, puede expresar cualquier carácter por su código ASCII numérico escribiendo una barra invertida ( \ ),
seguido por el código ASCII expresado como un octal o el número hexadecimal.

Primer caso (octal) las cifras debe seguir inmediatamente a la barra invertida (por ejemplo \23).

Segundo caso (hexadecimal), una x debe presidir los dígitos (por ejemplo \x20 o \x4A ).

Las cadena se puede extender a más de una línea de código, escriba un signo de barra invertida ( \ ) al final de
cada línea sin terminar.

"cadena expresada en\ dos lineas"

También puede concatenar varias constantes de cadena que los separan por uno o varios espacios en blanco,
tabuladores, nueva línea o de cualquier otro carácter en blanco válido:

"Esto forma" "una sola" "cadena" "de caracteres"

Por último, si queremos que la cadena se con caracteres anchos (tipo wchar_t), en lugar de los caracteres
estrechos (tipo char), se puede preceder a la constante con el prefijo L:

L "Esta es una cadena de caracteres anchos"

Literales Booleanas
Sólo hay dos valores válidos booleanos: true y false. Estos pueden ser expresados en C + + como valores de tipo
bool mediante las literales booleanas true y false .

Constantes definidas (#define)

Puede definir sus propios nombres para las constantes usando la directiva de procesador #. Su formato es:
#define identificador valor

Por ejemplo: #define PI 3.14159 #define NEWLINE '\n'

Esto define dos nuevas constantes: PI y la nueva línea. Una vez que se definan, se pueden utilizar en el resto del
código como si se tratara de cualquier otra constante.

Ejemplo:
// definición de constantes: Calcula el área de una circunferencia
#include <iostream>
using namespace std;
#define PI 3.14159
#define NEWLINE '\n'
int main ()
{
double r=5.0;
// radio
double circle;
circle = 2 * PI * r;
cout << circle;
cout << NEWLINE;
return 0;
}

#define no es una instrucción C + +, pero si una directiva para el preprocesador, por lo tanto no requiere de un
punto y coma ( ; ) en su extremo.
Constantes declaradas (const)
Con el prefijo const se pueden declarar constantes con un tipo específico de la misma manera como lo haría con
una variable:

const int pathwidth = 100; const char tabulador = '\t' ;

pathwidth y tabulador son dos constantes con tipo. Se tratan igual que las variables, salvo que sus valores no
pueden ser modificados después de su definición.

Operadores
Los operadores en C + + se compone de los signos que que representan las operaciones matemáticas.

Asignación (=)
El operador de asignación asigna un valor a una variable.

a=5 //Esta sentencia asigna a la variable a el valor 5

La operación de asignación se realiza siempre de derecha a izquierda, y nunca de otra manera:

a=b

Esta sentencia asigna a la variable a, el valor contenido en la variable b

Ejemplo:
// Operador de asignación
#include <iostream>
using namespace std;
int main ()
{
int a, b;
// a:?, b:?
a = 10;
// a:10, b:?
b = 4;
// a:10, b:4
a = b;
// a:4, b:4
b = 7;
// a:4, b:7
cout << "a=" ;
cout << a;
cout << " b=" ;
cout << b;
return 0;
}

Una propiedad de C + + es que la operación de asignación se puede utilizar como el valor de la derecha (o parte
de un valor de la derecha) para otra operación de asignación.

Ejemplo: a = 2 + (b = 5);

Es equivalente a:
b = 5;
a = 2 + b;
Significa: asignar 5 a variable b y luego asignar 2 a la variable a mas el valor de b.

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

a = b = c = 5;

Se asigna 5 a las tres variables: a, b, y c.

Los operadores aritméticos (+, -, *, /,%)

Las cinco operaciones aritméticas apoyadas por el lenguaje C + + son:

+ adición
- sustracción
* multiplicación
/ división
% módulo

Módulo es la operación que le da el resto de una división de dos valores. Por ejemplo, si escribimos:

a = 11 % 3;

La variable a contiene el valor 2, pues 2 es el residuo de dividir 11 entre 3.

Asignación compuesta (+ =, - =, * =, / =,% =, >> =, << =, & =, ^ =, | =)

Cuando se quiere modificar el valor de una variable mediante la realización de una operación con el valor
almacenado actualmente en esa variable se puede utilizar operadores de asignación compuestos:

expresión es equivalente a
valor + = incremento; valor = valor + incremento;
uno - = 5; uno = uno - 5;
uno / = b; a = a / b;
Precio * = unidades + 1; Precio = Precio * (unidades + 1);

Lo mismo para todos los otros operadores. Por ejemplo:

// Operadores de asignación compuestos

#include <iostream>
using namespace std;
int main ()
{
int a, b=3; a = b; a+=2;
// equivalente a a=a+2
cout << a;
return 0;
}

Incrementar y Disminuir
El operador incremento (+ +) y el operador de una disminución (-) aumenta o disminye en uno el valor almacenado
en una variable. Son equivalentes a + = 1 y - = 1, respectivamente. Así:
c++; c+=1; c=c+1;
 Son equivalentes en su funcionalidad: los tres incrementan en uno el valor de c.
Una característica de este operador es que puede ser utilizado tanto como un prefijo y como sufijo. Es decir puede
ser escrito o antes del identificador de variable (+ + a) o después de el (a + +).

En el caso de que el operador incremento se utilice como prefijo (+ + a) el valor se incrementa antes de que el
resultado de la expresión se evalúa y por lo tanto el mayor valor se considera en la expresión externa, si se utiliza
como un sufijo ( a + +) el valor almacenado se incrementa después de ser evaluado y por lo tanto, el valor
almacenado antes de la operación de aumento se evalúa en la expresión exterior.

Ejemplo 1 Ejemplo 2
B = 3; B = 3;
A = B + +; A = B + +;
/ / A contiene 4, B contiene 4 / / A contiene 3, B contiene 4

Los operadores relacionales y de igualdad (==,! =,>, <,> =, <=)

Para evaluar una comparación entre dos expresiones podemos utilizar los operadores relacionales y de igualdad.
El resultado de una operación relacional es un valor booleano que sólo puede ser verdadera o falsa, de acuerdo a
su resultado booleano.

== Igual a
!= No es igual a
> Mayor que
< Menos que
>= Mayor o igual a
<= A menos de o igual a

Ejemplos:
(7 == 5) //evalúa a false. (5 > 4) //evalúa a true. (3 != 2) //evalúa a true.
(6 >= 6) //evalúa a true. (5 < 5) //evalúa a false.

Por supuesto, en lugar de utilizar sólo las constantes numéricas, podemos utilizar cualquier expresión válida,
incluidas las variables. Supongamos que a = 2, b = 3 y c = 6,

(a == 5) // evalúa a false puesto que a no es igual a 5.

(a*b >= c) // evalúa to true puesto que (2*3 >= 6) es true.
(b+4 > a*c) // evalúa to false puesto que (3+4 > 2*6) es false.
((b=2) == a) // evalúa a true.

El operador = no es el mismo que el operador ==, el primero es un operador de asignación y el otro (= =) es el

operador de igualdad que compara si ambas expresiones en los dos lados de la misma son iguales entre sí.

Operadores lógicos(!, &&, | |)

El Operador! en C ++ es el operador para llevar a cabo la operación booleana NOT, que tiene un solo operando,
ubicado a su derecha, y lo único que hace es invertir el valor de la misma, produciendo falso si su operando es
verdadero y cierto si su operando es falso
!(5 == 5) // evalúa false porque la expression a su derecha(5 == 5) es verdadera. !(6 <= 4) // evalúa true porque(6
<= 4) sera false.
!true // evalúa false
!false // evalúa true.

Los operadores lógicos && y || se utilizan en la evaluación de dos expresiones y obtener un resultado relacional
único. El operador && es la operación lógica booleana AND. Esta operación da como resultado true si ambos
operandos son verdaderos, y falsa en caso contrario.

OPERADOR &&

a b a && b
verdadero verdadero verdadero
verdadero falso falso
falso verdadero falso
falso falso falso

El operador || es la operación lógica booleana OR. Esta operación da como resultado verdadero si cualquiera de
sus dos operandos es verdadera, por lo tanto es falsa solamente cuando ambos operandos son falsos:

Operador | |
a b a||b
verdadero verdadero verdadero
verdadero falso verdadero
falso verdadero verdadero
falso falso falso

Ejemplo:

((5 == 5) && (3 > 6)) // evalúa false ( true && false ).

((5 == 5) || (3 > 6)) // evalúa to true ( true || false ).

corto-circuito
operador
Si la expresión izquierda es falsa, el resultado combinado es falsa (de la derecha no se evalúa la
&&
expresión de lado).
Si la expresión izquierda es cierto, el resultado combinado es cierto (la mano derecha no se evalúa la
||
expresión de lado).
Esto es sobre todo importante cuando la expresión de la derecha tiene efectos secundarios, tales como la alteración
de los valores:

if ((i<10)&&(++i<n)) { /*...*/ }

Esta expresión condicional combinada i se incrementa en uno, pero sólo si la condición a la izquierda de && es
cierto, ya que de lo contrario la expresión de la derecha (+ + i <n) no se evalúa.

Operador condicional (?)

El operador condicional evalúa una expresión que devuelve un valor si la expresión es verdadera y otra distinta si
la expresión se evalúa como falsa. Su formato es:
condición? result1: result2

Si la condición es verdadera la expresión devolverá result1, si es falsa devuelve el result2.

7==5 ? 4 : 3 // devuelve 3, Puesto que 7 no es igual a 5.

7==5+2 ? 4 : 3 // devuelve 4, Puesto que 7 es igua a 5+2.
5>3 ? a : b // devuelve el valor de a, puesto que 5 es mayor que 3.
a>b ? a : b // devuelve el mayor, a o b.

// conditional operator
#include <iostream>
using namespace std;
int main ()
{
int a,b,c;
a=2; b=7;
c = (a>b) ? a : b;
cout << c;
return 0;
}

Operador coma (,)

El operador coma (,) se utiliza para separar dos o más expresiones que se incluyen en donde sólo una expresión
que se espera.

Ejemplo:
a = (b=3, b+2);
Se asigna el valor 3 a B, y luego se asigna b=2 a la variable a. Así, al final, una variable que contiene el valor 5,
mientras que la variable b contendría valor 3.

Tipo de operador de conversión explícita

Los operadores de conversión de tipos le permiten convertir un dato de un tipo determinado a otro. Hay varias
maneras de hacer esto en C + +. La más simple, que se ha heredado del lenguaje C, ha de preceder la expresión
a ser convertida por el nuevo tipo encerrado entre paréntesis ():

int i; float f = 3.14; i = ( int ) f;

El código anterior se convierte el número flotat 3,14 a un valor entero (3), el resto se pierde. Otra forma de hacer
lo mismo en C + + es utilizando la notación funcional: que precede a la expresión que se convierte por el tipo y
encerrando la expresión entre paréntesis:

i = int ( f );

Ambas formas de conversión de tipos son válidos en C + +.

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

a = sizeof ( char );

Prioridad de los operadores

 Al escribir expresiones complejas con varios operandos, puede que tengamos algunas dudas sobre la operación
que se evalúa primero. Ejemplo:
a=5+7%2
Podemos dudar sobre cuál es el resultado correcto:

a = 5+(7 % 2) // con un resultado de 6, o a = (5+7)%2 // con un resultado de 0

La respuesta correcta es la primera de las dos expresiones, con un resultado de 6.

De mayor a menor prioridad, el orden de prioridad es el siguiente:
Operador Descripción Agrupamiento
Nivel
De izquierda a
1 :: alcance
derecha
() []. -> + + - Static_cast dynamic_cast reinterpret_cast De izquierda a
2 sufijo
const_cast typeid derecha
+ + - ~! sizeof new delete unario (prefijo)
indirecto y de referencia De derecha a
3 *&
(punteros) izquierda
+- operador de signo unario
De derecha a
4 (Tipo) Tipo de fundición
izquierda
De izquierda a
5 . * -> * puntero a miembro
derecha
De izquierda a
6 * /% multiplicativo
derecha
De izquierda a
7 +- aditivo
derecha
De izquierda a
8 << >> cambiar
derecha
De izquierda a
9 <> <=> = relacional
derecha
De izquierda a
10 ==! = igualdad
derecha
De izquierda a
11 Y AND bit a bit
derecha
De izquierda a
12 ^ XOR bit a bit
derecha
De izquierda a
13 | OR bit a bit
derecha
De izquierda a
14 && Y lógico
derecha
De izquierda a
15 || OR lógico
derecha
De derecha a
16 ? condicional
izquierda
De derecha a
17 = * = / =% = + = - = >> = << = & = ^ = | = asignación
izquierda
De izquierda a
18 , coma
derecha
 Agrupación define el orden de precedencia, en el que los operadores se evalúan en el caso de que haya varios
operadores del mismo nivel en una expresión.

Todos estos niveles de precedencia para los operadores pueden ser manipulados o ser más legibles, eliminando
posibles ambigüedades que utilizan signos entre paréntesis (y), como en este ejemplo:
a = 5 + 7 % 2; podría ser escrito, ya sea como: a = 5 + (7 % 2); o a = (5 + 7) % 2;

Básico de Entrada / Salida

Hasta ahora, los programas de ejemplo de las secciones anteriores, siempre muy poca interacción con el usuario,
o ninguna en absoluto. Uso de la entrada estándar y la biblioteca de salida, que será capaz de interactuar con el
usuario mediante la impresión de mensajes en la pantalla y conseguir la entrada del usuario desde el teclado.

C + + utiliza una abstracción llamada corrientes para realizar operaciones de entrada y salida en los medios como
la pantalla o el teclado.
La biblioteca estándar de C + + incluye el archivo de cabecera iostream, donde los objetos estándar de entrada y
salida se declaran.
De salida estándar (cout)

De forma predeterminada, la salida estándar de un programa es la pantalla, y en C + + el objeto de secuencia

definida para acceder a ella es cout.

cout se utiliza en conjunción con el operador de inserción, que se escribe como << dos signos "meno que".)

cout << "Sentencia de Salida" ; // Imprime en pantalla sentencia de salida

cout << 120; // Imprime en pantalla el número 120
cout << x; // Imprime en pantalla el contenido de x

En los ejemplos anteriores se inserta: una cadena, Una constantes numéricas y variable. Una cadena debe estar
encerrada entre comillas ("):

cout << "Hola" ; // Imprime hola cout << Hola; // pImprime el contenido de la variable hola

El operador de inserción (<<) se puede utilizar más de una vez en una sola sentencia:

cout << "Hola, " << "Yo soy " << "una instrucción C++" ;

Imprime el mensaje Hola, soy una instrucción C + + en la pantalla. La utilidad de repetir el operador de inserción
(<<) se demuestra cuando queremos imprimir una combinación de variables y constantes o variables:

cout << "Hola, Yo tengo " << Edad << " años y mi código postal es " << codigopostal;

La salida seria:
Hola, yo tengo 24 años y mi código postal es 90064
Es importante señalar que cout no agrega un salto de línea después de su salida a menos que se le indique.
Por lo tanto, las siguientes declaraciones:

cout << "Esta es una sentencia” ; cout << "Esta es otra sentencia." ;

se muestra en la pantalla una después de la otra sin ningún tipo de salto de línea entre ellos:
Esta es una sentencia. Esta es otra sentencia.
Para realizar un salto de línea en la salida de manera explícita debe insertar un carácter de nueva línea en cout.
En C + + un carácter de nueva línea se pueden especificar como \ n (barra invertida, n):
cout << "Primera sentencia.\n" ; cout << "Segunda sentencia.\nTercera sentencia." ;
Esto produce el siguiente resultado:

La primera frase.
Segunda frase.
La tercera frase.

Además, para añadir una nueva línea, usted también puede usar el manipulador endl. Por ejemplo:
cout << "primera sentencia." << endl; cout << "Segunda sentencia." << endl;

Se imprime:

La primera frase.
Segunda frase.

El manipulador endl produce un carácter de nueva línea y cuando se utiliza con flujos de buffer: el buffer se vacía.

Estándar de entrada(cin).
El dispositivo de entrada estándar es generalmente el teclado. El Manejo de la entrada estándar en C + + se lleva
a cabo mediante la aplicación del operador sobrecargado de extracción (>>) en el flujo cin. El operador debe ser
seguida por la variable que almacenan los datos que van a extraerse. Ejemplo:

int age;
cin >> age;

La primera instrucción declara una variable de tipo int llamada edad, y el segundo espera una entrada de CIN (el
teclado) con el fin de almacenar en esta variable entera. cin sólo puede procesar la entrada desde el teclado una
vez que la tecla de retorno ha sido presionado.

El tipo de la variable se debe considerar como un recipiente con extracciones del cin. Si usted solicita un número
entero obtendrá un número entero, si usted solicita un caracter tendrá un carácter y si usted solicita una cadena
obtendrá una cadena.

// Ejemplo de E/S
#include <iostream>
using namespace std;
int main ()
{
int i;
cout << "Por favor, introduzca un valor entero:" ;
cin >> i;
cout << "El valor que introdujo es" << i;
cout << " y su doble es" << i*2 << ".\n" ;
return 0;
}

El usuario de un programa puede ser uno de los factores que generan los errores. Puesto que si usted solicita un
valor entero y el usuario introduce un nombre se genera un error de tipo de datos.
La clase stringstream ofrece una posible solución para los errores que pueden ser causados por este tipo de entrada
del usuario.
También puede utilizar el cin para pedir más de una entrada de datos:

cin >> a >> b;

Es equivalente a:
cin >> a;
cin >> b;

cin y cadenas
Podemos usar cin para conseguir secuencias con el operador de extracción (>>) como lo hacemos con las
variables de tipo de datos:
cin >> micadena;

La extracción de cin deja de leer cuando se encuentra con un espacio en blanco, por lo que en este caso no
podemos obtener una palabra para cada extracción.
Con el fin de conseguir líneas enteras, podemos usar la función getline, que es la forma más recomendable para
obtener la entrada del usuario con cin:

// Cadenas con cin

#include <iostream>
#include <string>
using namespace std;
int main ()
{
string micadena;
cout << "¿Cual es tu nombre? " ;
getline (cin, micadena);
cout << "Hola " << micadena << ".\n" ;
cout << "¿Cual es tu equipo favorito? " ;
getline (cin, micadena);
cout << "Me gustan " << micadena << " tambien!\n" ;
return 0;
}

Observe cómo en las dos llamadas a getline se utiliza el identificador de cadena (mistr). Lo que hace el programa
en la segunda convocatoria es simplemente para reemplazar el contenido anterior por el nuevo que se introduce.

stringstream
El encabezado del archivo <sstream> define una clase llamada stringstream . De esta manera podemos realizar
las operaciones de extracción o inserción de / a las cadenas, lo cual es especialmente útil para convertir cadenas
en valores numéricos, y viceversa. Ejemplo, si queremos extraer un número entero de una cadena se puede escribir:

string micadena ( "1204" );

int mientero;
stringstream(micadena) >> mientero;

Esto declara un objeto de cadena con un valor de "1204", y un objeto int. Luego utilizamos el constructor
stringstream 's para construir un objeto de este tipo desde el objeto de cadena. Debido a que podemos utilizar
objetos stringstream como si fueran corrientes, podemos extraer un número entero de lo que hubiéramos hecho en
cin aplicando el operador de extracción (>>) sobre el mismo seguido por una variable de tipo int.

Después de esta pieza de código, la variable Mientero contendrá el valor numérico de 1204.

// stringstreams
#include <iostream>
#include <string>
#include <sstream>
using namespace std;
int main ()
{
string micadena;
float precio=0;
int cantidad=0;
cout << "Introduzca el precio: " ;
getline (cin,micadena);
stringstream(micadena) >> precio;
cout << "Introduzca la cantidad: " ;
getline (cin,micadena);
stringstream(micadena) >> cantidad;
cout << "Precio total: " << Precio*cantidad << endl;
return 0;
}
Salida

Introduzca el precio: 22,25

Introduzca la cantidad: 7
Precio total: 155,75

En este ejemplo, se adquieren valores numéricos de la entrada estándar indirectamente. En vez de extraer los
valores numéricos directamente desde la entrada estándar, obtenemos las líneas de la entrada estándar (cin) en un
objeto de cadena (mystr), y luego extraer los valores enteros de esta cadena en una variable de tipo int (cantidad).

El uso de este método, en lugar de las extracciones directas de valores enteros, tenemos más control sobre lo que
ocurre con la entrada de valores numéricos del usuario, ya que se van a separar el proceso de obtener la entrada
del usuario (que ahora sólo le pedimos para las líneas) con la interpretación de que la entrada. Por lo tanto, este
método se prefiere generalmente para obtener los valores numéricos del usuario en todos los programas que son
intensivas en la entrada del usuario.

Estructuras de control
Un programa generalmente no se limita a una secuencia lineal de instrucciones. Durante su proceso se puede
bifurcar, repetir código o tomar decisiones. Para ello, C + + proporciona estructuras de control que sirven para
especificar lo que se tiene que hacer nuestro programa, bajo determinadas circunstancias.
 Un bloque es un grupo de sentencias que están separadas por punto y coma (;) como todos los de C + +, pero
agrupados en un bloque entre llaves: {}:

{Sentencia1; sentencia2; sentencia3;}

En el caso de que la declaración tenga una sola sentencia, no es necesario encerrarla entre llaves ({}). Pero en
el caso de que queremos que la declaración sea una instrucción compuesta debe ser encerrado entre llaves ({}),
formando un bloque.

Estructura condicional: if y else

Sentencia If
La palabra if significa si (condicional).
Su formato para ejecutar una sentencia si la condición es verdadera es el siguiente:
if (condición) sentencia, para una sola sentencia

Por ejemplo, el siguiente fragmento de código imprime x es 100 sólo si el valor almacenado en la variable x es
igual a 100:

if (x == 100) cout << "x is 100" ;

Si queremos algo más que una sola instrucción que se ejecutará en caso de que la condición es verdadera se
puede especificar un bloque mediante llaves {}:

if (x == 100)
{
cout << "x es " ;
cout << x;
}

Su formato para ejecutar más de una sentencia si la condición es verdadera es el siguiente:

if ( condición )
{
instrucciones a ejecutar
}

Donde condición es la expresión que se está evaluando. Si esta condición se cumple, se ejecuta la sentencia o
bloque de sentencias. Si es falsa, la declaración no se ejecuta y el programa continúa inmediatamente después de
la estructura condicional.

En el siguiente ejemplo tenemos un programa que nos pide un número, si ese número es 10 se muestra un mensaje.
Si no es 10 no se muestra ningún mensaje:
#include <stdio.h>

int main()
{
int num;

printf( "Introduce un número " );

scanf( "%i", &num );
if (num==10)
{
printf( "El número es correcto\n" );
}
}
Sentencia If-else
Esta sentencia, puede especificar lo que queremos que suceda si la condición no se cumple mediante el uso de la
palabra clave else. El formato es el siguiente:
if (condición) sentencia1 else sentencia2 para una sola sentencia si se cumple o si no se cumple:
Por ejemplo:

if (x == 100) cout << "x es 100" ; else cout << "x no es 100" ;

La forma más general de esta sentencia es la siguiente

if ( condición )
{
bloque que se ejecuta si se cumple la condición
}
else
{
bloque que se ejecuta si no se cumple la condición
}

En el if si no se cumplía la condición no se ejecutaba el bloque siguiente y el programa seguía su curso normal. Con
el if-else tenemos un bloque adicional que sólo se ejecuta si no se cumple la condición.

Recuerde que en caso de que queramos más que una sola sentencia para su ejecución, debemos agruparlos en
un bloque encerrándolos entre llaves {}.

If-else-if
Se pueden anidar el if-else si se desea con la intención de verificar un rango de valores. El siguiente ejemplo
muestra su uso diciendo si el valor almacenado actualmente en la x es positivo, negativo o cero:

if (x > 0)
cout << "x es positivo" ;
else if (x < 0)
cout << "x es negativo" ;
else
cout << "x es 0" ;

Ejemplo
#include <stdio.h>

int main()
{
int a;

printf( "Introduce un número " );

scanf( "%i", &a );
if ( a<10 )
{
printf ( "El número introducido era menor de 10.\n" );
}
else if ( a>10 && a<100 )
{
printf ( "El número está entre 10 y 100"\n" );
}
else if ( a>100 )
{
 printf( "El número es mayor que 100\n" );
}
printf( "Fin del programa\n" );
}

El símbolo && de la condición del segundo if es un AND (Y). De esta forma la condición queda: Si a es mayor que
10 Y a es menor que 100.
Y así todos los if else que queramos. Si la condición del primer if es verdadera se muestra el mensaje El número
introducido era menor de 10 y se saltan todos los if-else siguientes (se muestra Fin del programa). Si la condición
es falsa se ejecuta el siguiente else-if y se comprueba si a está entre 10 y 100. Si es cierto se muestra El número
está entre 10 y 100. Si no es cierto se evalúa el último else-if.

? El otro if-else

El uso de la interrogación es una forma de condensar un if-else. Su formato es el siguiente:

( condicion ) ? ( instrucción 1 ) : ( instrucción 2 ) Si se cumple la condición se ejecuta la instrucción 1 y si no se
ejecuta la instrucción 2. Veamos un ejemplo con el if-else y luego lo reescribimos con "?":

Ejemplo
#include <stdio.h>

int main()
{
int a;
int b;

printf( "Introduce un número " );

scanf( "%i", &a );
if ( a<10 )
{
b = 1;
}
else
{
b = 4;
}
printf ( "La variable 'b' toma el valor: %i\n", b );
}

Si el valor que tecleamos al ejecutar es menor que 10 entonces b=1, en cambio si tecleamos un número
mayor que 10 'b' será igual a 2. Ahora vamos a reescribir el programa usando '?':
#include <stdio.h>

int main()
{
int a;
int b;

printf( "Introduce un número " );

scanf( "%i", &a );
b = ( a<10 ) ? 1 : 4 ;
printf ( "La variable 'b' toma el valor: %i\n", b );
}
¿Qué es lo que sucede ahora? Se evalúa la condición a<10. Si es verdadera (a menor que 10) se ejecuta la
instrucción 1, es decir, que b toma el valor '1'. Si es falsa se ejecuta la instrucción 2, es decir, b toma el valor '4'.
Esta es una sentencia muy curiosa pero sinceramente creo que no la he usado casi nunca en mis programas y
tampoco la he visto mucho en programas ajenos.

switch
El formato de la sentencia switch es:
switch ( variable )
{
case opción 1:
código a ejecutar si la variable tiene el
valor de la opción 1
break;
case opción 2:
código a ejecutar si la variable tiene el
valor de la opción 2
break;
default:
código que se ejecuta si la variable tiene
un valor distinto a los anteriores
break;
}
Aquí no tenemos una condición que se debe cumplir sino el valor de una variable. Dependiendo del valor se cumplirá
un caso u otro.

Ejemplo de múltiples casos con if-else y luego con switch:

#include <stdio.h>
int main()
{
int num;

printf( "Introduce un número " );

scanf( "%i", &num );
if ( num==1 )
printf ( "Es un 1\n" );
else if ( num==2 )
printf ( "Es un 2\n" );
else if ( num==3 )
printf ( "Es un 3\n" );
else
printf ( "No era ni 1, ni 2, ni 3\n" );
}

Ahora con switch:

#include <stdio.h>

int main()
{
int num;

printf( "Introduce un número " );

scanf( "%i", &num );
switch( num )
{
case 1:
printf( "Es un 1\n" );
break;
 case 2:
printf( "Es un 2\n" );
break;
case 3:
printf( "Es un 3\n" );
break;
default:
printf( "No es ni 1, ni 2, ni 3\n" );
}
}

Como vemos el código con switch es más cómodo de leer.

Vamos a ver qué pasa si nos olvidamos algún break:
#include <stdio.h>
int main()
{
int num;

printf( "Introduce un número " );

scanf( "%i", &num );
switch( num )
{
case 1:
printf( "Es un 1\n" );
/* Nos olvidamos el break que debería haber aquí */
case 2:
printf( "Es un 2\n" );
break;
default:
printf( "No es ni 1, ni 2, ni 3\n" );
}
}
Si al ejecutar el programa escribimos un dos tenemos el mensaje Es un dos. Todo correcto. Pero si escribimos un
uno lo que nos sale en pantalla es:
Es un 1
Es un 2
¿Por qué? Pues porque cada caso empieza con un case y acaba donde hay un break. Si no ponemos break aunque
haya un case el programa sigue hacia adelante. Por eso se ejecuta el código del case 1 y del case 2.
Puede parecer una desventaja pero a veces es conveniente. Por ejemplo cuando dos case deben tener el mismo
código. Si no tuviéramos esta posibilidad tendríamos que escribir dos veces el mismo código. (Vale, vale, también
podríamos usar funciones, pero si el código es corto puede ser más conveniente no usar funciones. Ya hablaremos
de eso más tarde.).
Sin embargo switch tiene algunas limitaciones, por ejemplo no podemos usar condiciones en los case. El ejemplo
que hemos visto en el apartado if-else-if no podríamos hacerlo con switch.

Estructuras de iteración (bucles)

Bucles tiene como propósito repetir una afirmación de un cierto número de veces o mientras una condición se
cumple.
El bucle for
Su formato es:

for (inicialización; condición; incremento) sentencia;

y su función principal es repetir la declaración mientras la condición sigue siendo verdad. Pero además, el bucle
proporciona lugares específicos para contener una instrucción de inicialización y una declaración de incremento.
Esta instrucción esta diseñado para llevar a cabo una acción repetitiva con un contador que se inicializa y el
incremento en cada iteración.

Funciona de la siguiente manera:

1. inicialización se ejecuta. Es el valor inicial para una variable de contador. Esto se ejecuta sólo una vez.
2. condición se comprueba. Si bien es cierto el bucle continúa, de lo contrario el bucle termina y se omitirá
la sentencia (no ejecutados).
3. se ejecuta la sentencia. Como de costumbre, puede ser una sola sentencia o un bloque entre llaves {}.
4. Finalmente, todo lo que se especifica en el campo de aumento se ejecuta el bucle y vuelve al paso 2.

Aquí está un ejemplo de la cuenta regresiva mediante un bucle for:

// Contador descendente usando un for

#include <iostream>
using namespace std;
int main ()
{
for ( int n=10; n>0; n--)
{
cout << n << ", " ;
}
cout << "FIRE!\n" ;
return 0;
}

Salida: 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, FUEGO!

Los campos de inicialización e incremento son opcionales. Pueden permanecer vacío, pero en todos los casos
los signos punto y coma entre ellos debe estar

Por ejemplo, podríamos escribir: for (; n <10 ;) si queremos especificar que no hay inicialización ni incremento(; n
<10, n + +) si quisiéramos incluir un campo de incremento, pero no de inicialización (tal vez porque el variable se
inicializa antes).

Si lo desea, usando el operador coma (,) se puede especificar más de una expresión en cualquiera de los campos
incluidos en un bucle, como en la inicialización, por ejemplo. El operador coma (,) es un separador de expresión,
que sirve para separar más de una expresión que sólo una se espera en general. Por ejemplo, supongamos que
queremos iniciar más de una variable en nuestro bucle:

for ( n=0, i=100 ; n!=i ; n++, i-- ) { // whatever here... }

Este bucle se ejecutará durante 50 horas cuando ni n=, 0 i=100 son modificadas dentro del bucle:
 n comienza con un valor de 0, y I con 100, la condición es n! = i (que n no es igual a i). Dado que n se incrementa
en uno y disminuyó por una, la condición del bucle se convertirá en falso después del bucle 50a, cuando ambos n
e i será igual a 50.

El bucle while
Su formato es:

while (expresión) sentencia

y su funcionalidad es simplemente repetir la declaración, mientras que la condición establecida en la expresión es

verdadera.
Por ejemplo, vamos a hacer un programa de la cuenta regresiva mediante un bucle while:

// Contador descendente usando while

#include <iostream>
using namespace std;
int main ()
{
int n;
cout << "Introduzca el numero inicial> " ;
cin >> n;
while (n>0)
{
cout << n << ", " ; --n;
}
cout << "Fuego!\n" ;
return 0;
}
Salida

Introduce el número de inicio> 8

8, 7, 6, 5, 4, 3, 2, 1, FUEGO!

Al iniciar el programa se pide al usuario que introduzca un número de partida de la cuenta regresiva. Entonces
comienza el bucle mientras, si el valor especificado por el usuario cumple la condición n> 0 (que n es mayor que
cero) el bloque que sigue a la condición será ejecutado y repite mientras la condición (n> 0) permanece siendo
verdadera.

Todo el proceso del programa anterior se puede interpretar de acuerdo con la siguiente secuencia de comandos:

1. El usuario asigna un valor a n

2. La condición, mientras que se verifica (n> 0). En este punto hay dos posibilidades:
Condición de * es cierto: se ejecuta la sentencia (al paso 3)
* Condición es falsa: ignorar la declaración y continuar después de que (al paso 5)
3. Ejecutar la sentencia:
cout << n << ",";
- N;
(Imprime el valor de n en la pantalla y disminuye n por 1)
4. Fin del bloque. Volverá automáticamente al paso 2
5. Continuar con el programa justo después del bloque: FUEGO impresión! y al final del programa.
 Cuando se crea un bucle while, que siempre debe tener en cuenta que tiene que terminar en algún momento, por
lo tanto, tenemos que dar dentro del bloque de algún método para forzar la condición sea falsa en algún momento,
de lo contrario, el bucle se continuar girando para siempre. En este caso hemos incluido - n, que disminuye el valor
de la variable que está siendo evaluado en la condición (n) por uno - esto eventualmente hará que la condición (n>
0) para llegar a ser falso después de un cierto número de bucle iteraciones: para ser más específico, cuando n es
0, que es donde nuestro bucle while y nuestro fin de cuenta regresiva.

Por supuesto esto es una acción tan sencillo para nuestro equipo en el que la cuenta atrás de todo se realiza al
instante sin demora alguna práctica entre los números.

El bucle do-while

Su formato es:

do while (condición);

Su funcionalidad es exactamente el mismo que el bucle while, con esa condición en el bucle do-while se evalúa
después de la ejecución de la declaración en lugar de antes, la concesión de al menos una ejecución de la
declaración, incluso si la condición no se cumple. Por ejemplo, el siguiente programa de ejemplo se hace eco de
cualquier número que introduzca hasta que introduzca 0.

// number echoer
#include <iostream>
using namespace std;
int main ()
{
unsigned long n;
do
{
cout << "Enter number (0 to end): " ;
cin >> n;
cout << "You entered: " << n << "\n" ;
} while (n != 0);
return 0;
}

El do-while se utiliza generalmente cuando la condición de que tiene que determinar el final del bucle se
determina dentro de la instrucción bucle sí mismo, como en el caso anterior, donde la entrada del usuario dentro
del bloque es lo que se utiliza para determinar si el bucle tiene que terminar. De hecho, si no se introduce el valor
0 en el ejemplo anterior puede que se le pida más números para siempre.

Saltar declaraciones.

La sentencia break
 Uso de descanso que puede dejar un bucle, incluso si la condición para que su fin no se cumple. Puede ser
utilizado para poner fin a un bucle infinito, o para forzarlo a terminar antes de su fin natural. Por ejemplo, vamos a
detener la cuenta regresiva antes de su fin natural (tal vez debido a un fallo del motor del cheque?)

// break loop example

#include <iostream>
using namespace std; int main ()
{
int n;
for (n=10; n>0; n--)
{
cout << n << ", " ;
if (n==3)
{
cout << "countdown aborted!" ;
break ;
}
}
return 0;
}

Obtener numeros aleatorios en C++ (rand, srand)Es algo muy frecuente, cuando ya dominas todo eso de pedir
y almacenar datos, ahora tu profesor te pedirá que tus programas generen números aleatorios para automatizar
el proceso de llenar arreglos y todo eso.

Así que lo primero que tenemos que hacer es incluir la librería:

#include<stdlib.h>
Luego inicializar los números aleatorios incluyendo esto:
srand(time(NULL));
*Actualización: No se porqué con algunos IDE’s tira error con la función time. Solo hay que utilizar además la
librería time.h:
#include<time.h>
Luego guardar el número aleatorio en alguna parte:
num=rand();

Eso es básicamente. Para ajustar el rango de número aleatorios podemos hacer varias cosas.

Número aleatorios entre 0 y 50:

num=rand()%51;
Número aleatorios entre 1 y 100:
num=1+rand()%(101-1);
Número aleatorios entre 250 y 420:
num=250+rand()%(421-250);
De forma general es:
variable = limite_inferior + rand() % (limite_superior +1 - limite_inferior) ;

Así que un programa que muestre 10 números aleatorios entre 1 y 10 quedaría así:

#include<stdlib.h>
#include<iostream>
using namespace std;
int main()
{
int num,c;
srand(time(NULL));
for(c=1;c<=10;c++)
{
num=1+rand()%(11-1);
cout<<num<<" ";
}
cin.get();
}

Números aleatorios sin repetir en C++

1. Crear una matriz y dejarla vacía.

2. Obtener un número aleatorio.
3. Checar si ese número existe en la matriz. Si si, regresar al paso 2. Si no, guardar el numero en la matriz.

Así que el programa es este:

1 #include<cstdlib>
2 #include<ctime>
3 #include<iostream>
4 using namespace std;
5
6 bool checkrep(int n, int num[])
7 {
8 for(int i=0; i<10; i++)
9 if(n == num[i])
10 return true;
11 return false;
12 }
13
14 int main()
15 {
16 srand(time(NULL));
17 int n, num[10];
18 for(int i=0; i<10; i++)
19 {
20 do
21 n = 1 + rand() % 10;
22 while(checkrep(n, num));
23 num[i] = n;
24 cout << num[i] << " ";
25 }
26 }

Primero que nada, <cstdlib> es la forma correcta de incluir la librería <stdlib.h> en c++, igual con <ctime>.
Como ven, usamos una función bool (que retorna falso o verdadero) para checar si el número aleatorio ya existe
en nuestra matriz. Si cualquiera de los números es igual a nuestro número aleatorio n, la función retorna true, por lo
que el ciclo do-while desde el cual llamamos la función tendrá que repetirse una vez más y hasta que la función
retorne false.

Cuando se logra salir del ciclo do-while, guardamos nuestra n en el lugar de la matriz que corresponda, lo mostramos
en pantalla y continuámos con la siguiente posición de la matriz.

Otra cosa. Para decirnos si un número está repetido en la matriz, la función checkrep() necesita obviamente dos
cosas, el número aleatorio y la matriz. Así que le enviámos como parámetros nuestra matriz y nuestro número
aleatorio.
Otro ejemplo, la tabla de multiplicar del 2 en C++:
#include<stdio.h>
#include<conio.h>
int main()
{
int c=0;
for(c=1;c<=10;c++)
{
printf("2 x %d = %d\n",c,2*c);
}
getch();
}
Veamos como funcionaría un contador dentro de un ciclo:
#include<iostream>
using namespace std;
int main()
{
int contador=0;
for(int i=0; i<10; i++)
contador++;
cout << contador;
}
Con una condición:
#include<iostream>
using namespace std;
int main()
{
int contador=0;
for(int i=0; i<10; i++)
{
if(i==5)
contador++;
}
cout << contador;
}
Con una condición para obtener los números pares:
#include<iostream>
using namespace std;
int main()
{
int contador=0;
for(int i=0; i<10; i++)
{
if(i%2==0)
contador++;
}
cout << contador;
}

Funciones en C++
#include<iostream>
using namespace std;
void hola()
{
cout << "Hola Mundo!";
}
int main()
{
hola();
}
Ahora veamos una función que sí nos es útil:

#include<iostream>
using namespace std;

void hola(char nombre[50])

{
cout << "Hola " << nombre << "!";
}

int main()
{
char nombre[50];
cout << "Cual es tu nombre?: ";
cin.getline(nombre, 50, '\n');
hola(nombre);
}

Tipos de funciones en C++

Los tipos de funciones en c++ son 4, aunque en realidad son las combinaciones de las 2 cosas que una
función puede hacer. Una función, puede hacer (o no) dos cosas:
1 – Recibir datos
2 – Retornar datos.

De esto surgen los cuatro tipos de funciones:

1. No reciben ni retornan
2. Reciben y no retornan
3. No reciben y retornan
4. Reciben y retornan
Vamos a hacer un programa que sume dos números, usando los cuatro tipos de funciones:

No reciben ni retornan
Las más sencillas. Para usarlas sólo tenemos que saber cómo crearlas y cómo llamarlas.
Una función se crea de esta forma general:
tipo nombre()
{

}
El ‘tipo’ se refiere al tipo de dato (int, float, void, char) y en las funciones que no retornan siempre es void.
El ‘nombre’ es el nombre de la función: cualquiera que empiece con una letra, que sea significativo y que
no sea una palabra reservada.
Para llamarlas sólo hay que escribir el nombre de la función seguido de sus paréntesis y un punto y coma
(;).
nombre();
Así nuestro programa sería:

//Ejemplo de una función que no recibe y no retorna

#include<iostream>
using namespace std;
void sumar()
{
int num1, num2, r;
cout << "Numero 1: ";
cin >> num1;
cout << "Numero 2: ";
cin >> num2;
r = num1 + num2;
cout << "La suma es " << r<<”\n”;
}
int main()
{
sumar();
}
Como ven, todo lo que habríamos puesto en nuestro main mejor los pusimos en una función y desde el
main la llamamos. Una función siempre, siempre, siempre tiene que ir antes del main.
Una función de este tipo que hemos usado muchas veces es getch();
Reciben y No Retornan
¿Cómo haríamos para pedir los dos números en el main y que la función haga la suma? Para eso tenemos
que hacer una función capaz de recibir datos, entonces la sintaxis cambia un poco:
tipo nombre(tipo_var1 nombre_var1, tipo_var2 nombre_var2)
{

‘tipo’ y ‘nombre’ se refieren a lo mismo y como no retorna el tipo siempre es void.

Dentro del paréntesis tenemos otros aspectos:

‘tipo_var1′ se refiere al tipo de la variable que nuestra función va a recibir.
‘nombre_var1′ se refiere al nombre de esa variable.

Si queremos recibir una variable hasta ahí es suficiente, si queremos otra variable ponemos una coma (,)
y declaramos la siguiente variable.

Para llamar la función hay que poner la variables que vamos a enviar dentro del paréntesis en el mismo
orden en que las declaramos en la función:
nombre(var1, var2);
Nuestro programa quedaría así:
//Ejemplo de una función que recibe pero no retorna
#include<iostream>
using namespace std;

void sumar(int num1, int num2)

{
int r;
r = num1 + num2;
cout << "La suma es " << r<<”\n”;
}

int main()
{
int num1, num2;
cout << "Numero 1: ";
cin >> num1;
cout << "Numero 2: ";
cin >> num2;
sumar(num1, num2);
}
Pedimos los dos números en el main, los enviamos a la función, ésta los suma y los muestra.
Una función de este tipo que hemos usado muchas veces es el odiado por muchos, amados por otros,
gotoxy(x,y);
Retornan y No Reciben
¿Y si ahora queremos lo contrario? Pedir los números en la función, pero mostrar el resultado en el
main. Para eso necesitamos una función que retorne.
Recibir es enviar datos del main a la función. Retornar es enviar datos de la función al main. Para
retornar datos hay que hacer dos cosas: no usar void como tipo y usar return.
De forma general:
tipo nombre()
{
return var;
}
El ‘tipo’ tiene que ser del tipo de variable que queremos retornar, si nuestra variable retorna una variable
int, pues el tipo de la función es int.
Para indicar qué variable estamos retornando usaremos la palabra return seguido de la variable.
Usualmente esto va al final de la función.
Para llamar a la función hay que preparar un colchón en donde caiga la variable que está
retornando.
var = nombre();

La variable que está retornando nuestra función se va a almacenar en la variable ‘var’. Este es un buen
momento para recordarles que las variables declaradas entre dos llaves {} únicamente existen entre esas
dos llaves. O sea que la variable ‘var’ de la función no es la misma que la variable ‘var’ de la función; sin
embargo la var del main está adquiriendo el valor de la var del main. Un poco confuso lo se, no se
preocupen.
Nuestro programa quedaría así:
//Ejemplo de una función que retorna y no recibe
#include<iostream>
using namespace std;
int sumar()
{
int num1, num2, r;
cout << "Numero 1: "; cin >> num1;
cout << "Numero 2: "; cin >> num2;
r = num1 + num2;
return r;
}

int main()
{
int r;
r = sumar();
cout << "La suma es " << r<<”\n”;
}
¿A alguien se le ocurre una función conocida de este tipo?
Reciben y Retornan
Ahora queremos que nuestra función únicamente sume, el main se va a encargar de pedir los números y
sumar los resultados. Para eso necesitamos que nuestra función reciba las variables y además retorne el
resultado. ¡Wow! ¿Es acaso eso posible? Claro que sí.
Es sólo cuestión de combinar las funciones que reciben y no retornan con las que retornan y no reciben.
Nuestro programa quedaría así:
//Ejemplo de una función que recibe datos y retorna resultados
#include<iostream>
using namespace std;

int sumar(int num1, int num2)

{
int r;
r = num1 + num2;
return r;
}

int main()
{
int num1, num2, r;
cout << "Numero 1: ";
cin >> num1;
cout << "Numero 2: ";
cin >> num2;
r = sumar(num1, num2);
cout << "La suma es " << r<<”\n”;
}
Las funciones de la librería math.h son en su mayoría de este tipo. sqrt(); pow(); sin();
En principio puede parecer que las funciones sirven únicamente para organizar el código, lo cual es cierto,
pero no sólo eso. ¿Se imaginan si tuviéramos que escribir todo el código detrás de un simple gotoxy();?
Ah verdad…
Bueno, no me iba a quedar tranquilo si no les mostraba la versión optimizada de la última función:

#include<iostream>
using namespace std;
int sumar(int num1, int num2)
{
return num1 + num2;
}

int main()
{
int num1, num2;
cout << "Numero 1: "; cin >> num1;
cout << "Numero 2: "; cin >> num2;
cout << "La suma es " << sumar(num1, num2);
}
Vamos a ver como se declaran las funciones en c++. No tiene ningun misterio, es
igual que en c. Siempre hay que especificar el tipo de retorno.
/**
* Funcion.cpp
* Programa con llamada a una funcion
*
* Pello Xabier Altadill Izura
*
* Compilado: g++ Funcion.cpp -o Funcion
*/
using namespace std;
#include <iostream>
// Funcion: llamada
int llamada (int x, int y) {
cout << "Estamos en la funcion!!" << endl;
return (x+y);
}
int main() {
// Estos comentarios son propios de C++
cout << "Vamos a llamar a la funcion.." << endl;
// Llamamos a la funcion
// Llamamos a una funcion y asignamos
int z = llamada(5,7);
cout << "Resultado:" << z << endl;
// Llamada desde el output
cout << "Resultado:" << llamada(6,7) << endl;
cout << "Programa terminado \n" << endl;
return 0;
}

Atencion, en este caso veremos como recoger datos de stdin o entrada estandar.
/**
* Funcion3.cpp
* Programa con llamada a una funcion
* El programa principal recoge datos de la entrada estandar
*
* Pello Xabier Altadill Izura
*
* Compilado: g++ Funcion3.cpp -o Funcion3
*/
using namespace std;
#include <iostream>
// Funcion: llamada
int llamada (int x, int y) {
cout << "Estamos en la funcion!!" << endl;
return (x+y);
}
int main() {
// Estos comentarios son propios de C++
cout << "Vamos a llamar a la funcion.." << endl;
// Llamamos a la funcion
// Llamamos a una funcion y asignamos
int z = 0, x = 0, y = 0;
// Recogemos los parametros
cout << "Dame el primer parametro:";
cin >> x;
cout << "\nOK!\nDame el segundo parametro:";
cin >> y;
cout << "\nOK vamos a calcular.";
6
Capítulo 3. Funciones
// Efectuamos la funcion.
z = llamada(x,y);
// Mostramos el resultado
cout << "Resultado:" << z << endl;
// Llamada desde el output
cout << "Resultado:" << llamada(6,7) << endl;
cout << "Programa terminado \n" << endl;
return 0;
}
Actividades de Programación
I. Estructura Secuencial (los algoritmos deberían tener análisis, pseudocodigo, diagrama de flujo y Código

Programas
I. Programas con instrucciones de Entrada/Salida
1. Programa que imprime el mensaje “¡Bienvenidos al Curso de POO!
2. Programa que imprime cuatro mensajes dos en cada renglón
M1: Soy Alumno del grupo 416
M2: Curso el Módulo de POO
M3: Para acreditar el Curso
M4: Debo Trabajar y Estudiar
3. Programa que declara e inicializa dos variables numéricas enteras y calcula e imprime su
suma
4. Programa que lee dos números enteros y calcula e imprime su suma y resta
5. Programa que lea cuatro valores numéricos desde teclado, calcula y muestra en pantalla
su suma y promedio.
6. Programa que lee desde teclado el lado de un cuadrado, calcula y muestra en pantalla el
perímetro y área del mismo
7. Programa que lee desde el teclado el radio de un circulo y calcula e imprime el área y
perímetro del circulo
8. Programa que lee desde el teclado el largo y ancho de un rectángulo y calcula e imprime
el área y perímetro del rectángulo
9. Programa que lee desde el teclado la base y altura de un triángulo equilátero y calcula e
imprime el área y perímetro del triangulo
10. Programa que lee desde el teclado el lado de un cubo y calcula e imprime el área y
volumen del cubo
11. Programa que lee desde el teclado el radio de la base de un cilindro, su altura y calcula e
imprime el volumen del cilindro
12. Programa que lee desde el teclado lee el precio de un artículo y la cantidad de artículos
que lleva el cliente, el programa calcula y Muestra lo que debe pagar el comprador.
13. Programa que calcula el pago de las compras realizadas en una tienda, considerando las
siguientes compras:
a) Un horno de 16000 con un descuento del 5%
b) Una sala de 13000 con un descuento del 20%
c) Un refrigerador de 8900 con un descuento del 12%
d) Una pantalla de 18000 con un descuento del 15%
14. Programa que calcula e imprime el pago mensual de un empleado que trabaja 8 horas
diarias, 5 días a la semana, al trabajador se le aplica un ISR del 22%, el pago por hora se
lee desde teclado.
15. 7. Diseñar el algoritmo en pseudocódigo y diagrama de flujo para realizar la conversión de
grados Celsius a grados fahrenheit
Nota: ºF= 9/5ºC +32
16. 8. Diseñar el algoritmo en pseudocódigo y diagrama de flujo para realizar la conversión de
grados fahrenheit a grados Celsius
Nota: ºC= 5/9(ºF – 32)
II. Programas con sentencias de control de toma de decisión
1. Programa que lee la edad de una persona y en base a esta imprima los mensajes “Es
un niño “ si la edad es menor o igual a 12, sino imprime “No es un niño”
2. Programa que lee desde el teclado dos números enteros N1 y N2, si N1 es mayor que
N2, calcula e imprime la suma, sino calcula e imprime la resta
3. Programa que lee desde el teclado un numero entero N y determina e imprime si es par,
impar o nulo
4. Programa que lee desde el teclado un numero entero N y determina e imprime si es
positivo, negativo o cero
5. Programa que lee desde el teclado 3 calificaciones de un alumno, Calcula su promedio y
en base a este determina e imprime si está aprobado o reprobado (calificación mínima
aprobatoria 7)
6. Programa que lee desde el teclado tres calificaciones de un alumno, calcula el promedio e
imprima un mensaje según las siguientes condiciones:
Si el promedio es >=7 mostrar "Aprobado".
Si el promedio es >=6 y <7 mostrar "Regular".
Si el promedio es <6 mostrar "Reprobado".
7. Programa que lee desde el teclado tres números enteros y determina e imprime cual es
el mayor
8. Programa que lee desde el teclado una cantidad
a. Si la cantidad es menor a 500 se le suma el 50%
b. Si la cantidad es mayor o igual a 500, pero menor a 1000 se le suma el 20%
c. Si la cantidad es mayor o igual a 1000, pero menor a 5000 se le suma el 15%
d. Si la cantidad es mayor o igual a 5000 se le resta el 5%
9. Programa que resuelve una ecuación de segundo grado, considerando las siguientes
condiciones (b2 - 4AC=0, b2 - 4AC>0 , b2 - 4AC=<0), el programa lee desde el teclado
los coeficientes de la ecuación, calcula e imprime la o las soluciones de la ecuación.
10. Programa que permita leer desde el teclado un número entero positivo de hasta tres cifras
y muestre un mensaje indicando si tiene 1, 2, o 3 cifras. Mostrar un mensaje de error si el
número de cifras es mayor de tres cifras.
11. programa que simula una calculadora para realizar las operaciones básicas(+, -, *, /, %,
potencia y raíz cuadrada ) utilizando switch, el programa lee los valores desde el teclado

III. Programas con sentencias de control de repetición

1. Programa que imprime los números enteros del 1 al 10 y calcula su suma
2. Programa que imprime la serie del 5 en un rango de 0 a N (N leído desde el teclado
3. Programa que cuenta e imprime los números pares comprendidos en el rango del 1 al
100, calculando e imprimiendo su suma
4. Programa que cuenta e imprime los números nones comprendidos en el rango del 1 al
50, calculando e imprimiendo su suma
5. Programa que calcula e imprime el factorial de un número entero positivo leído desde
teclado.
 6. Programa que determina cuantos números de una lista de N números leídos desde el
teclado cumplen las siguientes condiciones:
a. Cuantos son menores a 50
b. Cuantos están entre 50 y 80
c. Cuantos son mayores de 80
Nota El programa debe indicar el total de números leídos
7. Programa que lee desde el teclado un número indeterminado de números enteros positivos
y negativos, determina e imprime cuantos son positivos, cuántos son negativos y el total
de números leídos. El programa termina al teclear un cero.
8. Programa que lee desde el teclado un número indeterminado de números enteros y
determina e imprime cuantos son pares, cuántos son nones y el total de números leídos.
El programa termina al teclear un cero.
9. Programa que lee desde el teclado la calificación de los N alumnos de un grupo y calcula
e imprime el promedio del grupo
10. Programa que lee desde el teclado 3 calificaciones de un grupo de N alumnos, el programa
calcula el promedio de cada alumno y determina el número de aprobados reprobados del
grupo (Calificación mínima aprobatoria 7)
11. Programa que permite leer desde teclado un conjunto de n estaturas de personas. El
programa Calcular y Muestra la altura promedio de las personas y cuantas están por
debajo y por arriba del promedio.
12. En una empresa trabajan n empleados cuyos sueldos oscilan entre $4000 y $8000, realizar
un programa que lea los sueldos que cobra cada empleado e informe cuántos empleados
cobran entre $4000 y $6000 y cuántos cobran más de $6000. Además el programa deberá
informar el importe que gasta la empresa en sueldos al personal.
13. Una fábrica de perfiles de hierro posee un lote de n piezas. Diseñar un programa que lee
desde el teclado la cantidad de piezas a procesar y luego lea la longitud de cada perfil;
sabiendo que la pieza cuya longitud esté comprendida en el rango de 1,20 y 1,30 son
aptas. Imprimir por pantalla la cantidad de piezas aptas que hay en el lote.
14. Programa que lee un numero entero positivo e imprime su tabla de multiplicar con el
formato (N * 1=Resultado)
15. Programa que imprime las tablas de multiplicar del 1 al 10 con el formato (N * 1= Resultado)

IV. Arreglos y Números aleatorios Ordenamiento y búsqueda

1. Programa que permite insertar en un arreglo unidimensional de tamaño 8 datos desde
el teclado. El programa imprime el arreglo
2. Programa que permite insertar en un arreglo unidimensional de tamaño 20 datos
mediante la generación de números aleatorios en un rango de 0 a 100, el programa
imprime el arreglo
3. Programa que permite insertar en un arreglo bidimensional de tamaño 10 x 10 datos
mediante la generación de números aleatorios en un rango de 0 a 50, el programa
imprime el arreglo en forma de tabla

4. Programa que permite inserta en un arreglo unidimensional de tamaño 10 datos

mediante la generación de números aleatorios en el rango de 0 a 20, el programa
ordena de forma ascendente mediante el método de la burbuja el arreglo y lo imprime
antes y después de ordenarlo
5. Programa que permite inserta en un arreglo unidimensional de tamaño 10 datos
mediante la generación de números aleatorios en el rango de 0 a 20, el programa
ordena de forma descendente mediante el método de la burbuja el arreglo y lo imprime
antes y después de ordenarlo
6. Programa que permite inserta en un arreglo unidimensional de tamaño 10 datos
mediante la generación de números aleatorios en el rango de 0 a 100, el programa
busca el valor mayor almacenado en el arreglo y lo imprime
7. Programa que permite inserta en un arreglo unidimensional de tamaño 10 datos
mediante la generación de números aleatorios en el rango de 0 a 100, el programa
busca un dato especifico almacenado en el arreglo y lo imprime