YMR

Fundamentos de Programación

El lenguaje de programación C fue creado por Brian Kernighan y Dennis Ritchie a mediados de los años 70. La
primera implementación de este la realizó Dennis Ritchie sobre un computador DEC PDP-11 con sistema
operativo UNIX. C es el resultado de un proceso de desarrollo que comenzó con un lenguaje anterior, el
BCPL, el cual influyó en el desarrollo por parte de Ken Thompson de un lenguaje llamado B, el cual es el
antecedente directo del lenguaje C. El lenguaje C es un lenguaje para programadores en el sentido de que
proporciona una gran flexibilidad de programación y una muy baja comprobación de incorrecciones, de
forma que el lenguaje deja bajo la responsabilidad del programador acciones que otros lenguajes realizan
por si mismos. Así, por ejemplo, C no comprueba que el índice de referencia de un vector (llamado array en
la literatura informática) no sobrepase el tamaño del mismo; que no se escriba en zonas de memoria que no
pertenecen al área de datos del programa, etc.
YMR

Desde su creación, surgieron distintas versiones de C, que incluían unas u otras características, palabras
reservadas, etc. Este hecho provoco la necesidad de unificar el lenguaje C, y es por ello que surgió un
standard de C, llamado ANSI-C, que declara una serie de características, etc., que debe cumplir todo lenguaje
C. Por ello, y dado que todo programa que se desarrolle siguiendo el standard ANSI de C será fácilmente
portable de un modelo de ordenador a otro modelo de ordenador, y de igual forma de un modelo de
compilador a otro, en estos apuntes explicaremos un C basado en el standard ANSI-C.

Para empezar a programar es necesario tener una interfaz o un IDE, IDE es el acrónimo del término inglés
Integrated Development Environment o, lo que es lo mismo, Entorno de Desarrollo Integrado. Es el
escenario digital utilizado en programación para desarrollar aplicaciones, juegos… Es imprescindible tanto en
el ámbito del Desarrollo de Aplicaciones Web (DAW) como en el Desarrollo de Aplicaciones Multiplataforma
(DAM). Hace que la tarea del programador sea más sencilla, gracias a las herramientas que tiene
incorporadas, como compiladores, depuradores o bibliotecas, y esto se traduce en un aumento de la
productividad.

Lenguaje Maquina

El lenguaje de máquina o código máquina es el sistema de códigos directamente interpretable por un

circuito microprogramable, como el microprocesador de una computadora o el microcontrolador de un
autómata. Este lenguaje está compuesto por un conjunto de instrucciones que determinan acciones a ser
tomadas por la máquina. Un programa consiste en una cadena de estas instrucciones más un conjunto cual
se trabaja. Estas instrucciones son normalmente ejecutadas en secuencia, con eventuales cambios de flujo
causados por el propio programa o eventos externos. El lenguaje de máquina es específico de la arquitectura
de la máquina, aunque el conjunto de instrucciones disponibles pueda ser similar entre arquitecturas
distintas.

SISTEMA BINARIOActualmente la mayoría de las personas utilizamos el sistema decimal (de 10 dígitos) para
realizar operaciones matemáticas, este sistema se basa en la combinación de 10 dígitos (del 0 al 9);
Construimos números con 10 dígitos y por eso decimos que su base es 10.

Por ejemplo, el 23, el 234, 1093 etc. Todos son dígitos del 0 al 9.

Pero hay otro sistema o lenguaje muy utilizado que es el sistema binario de numeración, que en algunos
casos, como por ejemplo en informática, se puede llamar Lenguaje Binario, debido a que es el lenguaje que
usamos para entendernos con el ordenador.

¿Qué es el Sistema Binario?

El sistema binario es un sistema de numeración en el que los números se representan utilizando las cifras 0 y
1, es decir solo 2 dígitos (bi = dos).
YMR

Esto en informática y en electrónica tiene mucha importancia ya que las computadoras trabajan
internamente con 2 niveles: hay o no hay de Tensión, hay o no hay corriente, pulsado o sin pulsar, etc. Esto
provoca que su sistema de numeración natural sea el binario, por ejemplo 1 para encendido y 0 para
apagado, también se utiliza en electrónica y en electricidad (encendido o apagado, activado o desactivado,
etc.). El lenguaje binario es muy utilizado en el mundo de la tecnología.

Convertir decimal a Binario

Aunque puede parecer extraño, cualquier número del sistema decimal (el más empleado en la vida
cotidiana) puede expresarse a través del sistema binario. Sólo hay que seguir alguno de los métodos
establecidos para encontrar la equivalencia. Existen algunos casos especiales para los cuales no es necesario
recurrir a ningún procedimiento; por ejemplo, el 0 y el 1, que se mantienen iguales en ambos sistemas.

El método más común consiste en dividir la cantidad del sistema decimal por 2: el número entero que da
como resultado se divide nuevamente por 2, de forma sucesiva hasta que el dividendo resulta inferior al
divisor. Hecho esto, los restos de cada división se ordenan desde el último resto hasta el primero. Partes de
una División

Así, si queremos expresar el número 34 en el sistema binario, haremos lo siguiente:

24 / 2 = 12 (resto = 0)
12 / 2 = 6 (resto = 0)
6 / 2 = 3 (resto = 0)
3 / 2 = 1 (resto = 1)
1 / 2 = 0 (resto = 1)

Ejercicio 1.- Convertir los siguientes números decimales a sus equivalentes binarios:
a. 64 _________________________________________________________
b. 100 _________________________________________________________
c. 111 _________________________________________________________
d. 145 _________________________________________________________
e. 255 _________________________________________________________
f. 500 _________________________________________________________
g. 3475 _________________________________________________________
h. 2525 _________________________________________________________
i. 271875 _________________________________________________________
j. 231 _________________________________________________________
YMR

Ejercicio 2.- Convertir los siguientes números binarios a sus equivalentes decimales:
a. 001100 __________________________
b. 000011 __________________________
c. 011100 __________________________
d. 111100 __________________________
e. 101010 __________________________
f. 111111 __________________________
g. 100001 __________________________
h. 111000 __________________________
i. 11110001111 __________________________
j. 11100011 __________________________
k. 11001110011 __________________________
l. 10101010101 __________________________

Ahora que hemos repasado el sistema binario, hablaremos acerca de la herramienta que nos permitirá
plasmar nuestros programas a un lenguaje de programación, utilizando un Entorno de Desarrollo Integrado,
por sus siglas en ingles IDE.

¿Cuáles son las características de los entornos de desarrollo?

Cualquier IDE debe tener una serie de características básicas que garanticen que la experiencia del usuario
será satisfactoria. Todo IDE debe contar con:

Editor de código. Se trata de un editor de texto creado exclusivamente para trabajar con el código fuente de
programas informáticos.
Compilador. Un programa encargado de traducir las instrucciones en código fuente, escritas en lenguaje de
programación, a código objeto, el único lenguaje que el ordenador entiende.
Depurador o debugger. Un programa que permite probar y buscar errores en otros programas.
Linker. Es la herramienta con la que combinar diferentes archivos de código fuente para convertirlos en un
único fichero ejecutable.
Refactorización de código. Proceso en el que se recurre a funciones como el reformateo o la encapsulación
para mejorar el código fuente.

Dev-C++ es un compilador y entorno de desarrollo para el lenguaje C/C++. Se trata de una aplicación de
código abierto, que ofrece todo tipo de facilidades para desarrollar grandes proyectos en C++. La aplicación
presenta resaltado de sintaxis, depurador, una utilidad para crear instalaciones de nuestros programas,
docenas de librerías y ficheros de ejemplo, etc. Como opciones extra, Dev-C++ incluye múltiples idiomas
(incluido el español), explorador de clases y variables, plantillas, facilidad para instalar librerías adicionales,
etc. Todo esto sólo es una pequeña parte de las posibilidades que se pueden encontrar en Dev-C++, un
entorno de programación verdaderamente recomendable para desarrolladores de cualquier nivel.

Pensar en programar

En los procesos informáticos, es necesario plasmar la lógica del programa. Un diagrama de flujo es una forma
visual la cual nos permite representar un algoritmo o proceso. En un diagrama de flujo se usan diferentes
elementos y conexiones las cuales son permiten representar el algoritmo de una manera visual, estructurada
y organizada.
YMR

La manera más fácil de poder crear un algoritmo es creando su representación gráfica. Ya que, si empezamos
a realizarlo directamente con código, puede llegar a ser más complejo de lo que parece. Es ideal, que antes
de programar un algoritmo, lo representemos en un diagrama de flujos, diseñando así su lógica. Gracias a
ello, ya dispondremos de una gran parte del trabajo realizado, únicamente quedará plasmarlo en formato de
código.

Los símbolos principales que se usan para realizar los diagramas de flujo son los siguientes:

Terminal Indica el principio o fin de un programa

Entrada/Salida Indica una operación de entrada o salida

Proceso Indica cálculo o manipulación de datos

Usadas para conectar los otros símbolos del diagrama de

Líneas de flujo
flujo e indica el flujo lógico

Decisión Indica un punto de ramificación del programa

Indica los valores inicial, límite y de incremento de una

Iteración
iteración

Indica un proceso predefinido, como llamar a una

Proceso predefinid
función

Indica una entrada a, o salida de, otra parte de un

Conector diagrama de flujo o un punto de conexión

Reporte Indica un reporte de salida escrito

Ejemplo 1: resolver el siguiente problema: Calcular el sueldo de un empleado conociendo la cantidad de

horas trabajadas y el precio por horas.

Ejemplo 2: resolver el siguiente problema

YMR

Pedir al usuario dos números, calcular la suma, y guardar el resultado

en otra variable, imprimir el resultado.

Resolver los siguinetes problemas con Diagramas de Flujo.

Ejercicio 1.-Indicar si un numero introducido por el usuario es Par o impar

Ejercicio 2.- Inidcar cuantos años tiene una persona, solicitando el año en que nacio.

Ejercicio 3.-Realizar el factorial de un numero

¿Qué herrameinta puedo utilizar para hacer un diagrama de flujo?

Realizar diagramas de flujo con una herramienta

Dia es una aplicación para crear diagramas técnicos. Útil para crear diagramas de flujo, diagramas UML,
diagramas entidad-relación, diagramas de redes y circuitos eléctricos sencillos.

Entre sus características incluye:

Impresión de múltiples paginas
Exportación a varios formatos (EPS, SVG, CGM y PNG entre otros)
Es posible expandir su librería de objetos, a partir de archivos definidos por el usuario.
YMR
YMR

Identificadores en C

Antes de proceder a explicar los identificadores en C, es necesario resaltar que C es un lenguaje sensible al
contexto, C diferencia entre mayúsculas y minúsculas, y por tanto, diferencia entre una palabra escrita total
o parcialmente en mayúsculas y otra escrita completamente en minúsculas.

En el lenguaje C, un identificador es cualquier palabra no reservada que comience por una letra o por un
subrayado, pudiendo contener en su interior letras, números y subrayados. La longitud máxima de un
identificador depende del compilador que se esté usando, pero, generalmente, suelen ser de 32 caracteres,
ignorándose todos aquellos caracteres que compongan el identificador y sobrepasen la longitud máxima.
Recuérdese, además, que al ser C sensible al contexto, un identificador escrito como esto_es_un_ident y
otra vez como Esto_Es_Un_Ident será interpretado como dos identificadores completamente distintos.

Los nombres admitidos para funciones y clases también se usan para nombrar otros elementos del lenguaje C+
+ y se denominan de manera colectiva identificadores. Los identificadores pueden formarse por cualquier
combinación de letras, dígitos o subrayados (_) seleccionados de acuerdo con las siguientes reglas:

1. El primer carácter del nombre debe ser una letra o subrayado (_).

2. Sólo pueden seguir a la letra inicial, letras, dígitos o subrayados. No se permiten espacios en blanco; se
usa el subrayado para separar palabras en un nombre consistente de múltiples palabras o se usan
mayúsculas para la primera letra de una o más palabras.

3. El nombre de una función no puede ser una de las palabras clave enumeradas en la tabla (Una palabra
clave es una palabra que es apartada por el lenguaje para un propósito especial y sólo puede usarse en
una manera especificada.)

4. El número máximo de caracteres en una función es 1024

Palabras Clave
YMR

La función main()

Para facilitar la colocación y ejecución ordenada de los módulos, cada programa C++ debe tener una y sólo
una función llamada main(). La función main() se conoce como una función controladora, porque controla, o
indica, a los otros módulos la secuencia en la que tienen que ejecutarse

La función main en programación es una función o método especial para que el lenguaje de
programación sepa por dónde tiene que empezar.

Lo habitual es encontrártelo en un programa basado en la línea de comandos, pero es posible que te

lo puedas encontrar, cuando escribes código fuente, en lenguajes de programación como C# o Visual
Basic en Visual Studio a la hora de hacer un programa basado en escritorio (con formularios).
Todos los programas de C++ deben tener una función main. Si se intenta compilar un programa de C+
+ sin una función main, el compilador genera un error. (Las bibliotecas static y las bibliotecas de
vínculos dinámicos carecen de función main). La función main es donde el código fuente empieza a
ejecutarse, pero antes de que un programa entre en la función main, todos los miembros de clase
static sin inicializadores explícitos se establecen en cero. En Microsoft C++, los objetos static globales
también se inicializan antes de entrar en main. A la función main se le aplican varias restricciones que
no se aplican a otras funciones de C++.
Programa 1.-
YMR

No te preocupes demasiado si aún no captas todos los matices de este pequeño programa. Vamos a
repasar linea por linea, el programa:
1: int main()
Se trata de una línea muy especial, y la encontrarás en todos los programas en C++. Es el principio de
la definición de una función. Todas las funciones toman unos valores de entrada, llamados
parámetros o argumentos, y devuelven un valor de retorno.
La primera palabra: "int", nos dice el tipo del valor de retorno de la función, en este caso un número
entero.La segunda palabra es el nombre de la función, en general será el nombre que usaremos
cuando queramos usar o llamar a la función. En este caso "main" es una función especial, ya que
nosotros no la usaremos nunca explicitamente, esta función será la que tome el control cuando se
ejecute nuestro programa.
También se sabe que es una función por los paréntesis, todas las definiciones de funciones incluyen
una lista de argumentos de entrada entre paréntesis, en nuestro ejemplo es una lista vacía, es decir,
nuestra función no admite parámetros.
2: "{"
Aparentemente es una línea muy simple, las llaves encierran el cuerpo o definición de la función.
Más adelante veremos que tienen otros usos.
3: "int a;"
Esta es nuestra primera sentencia, todas las sentencias terminan con un punto y coma.
Esta concretamente es una declaración de variable, y nos dice, a nosotros y al compilador, que
usaremos una variable 'a' de tipo entero. Esta declaración obliga al compilador a reservar un espacio
de memoria para almacenar la variable 'a', pero no le da ningún valor inicial. En general contendrá
"basura", es decir, lo que hubiera en esa zona de memoria cuando se reservó.
En C++ se distingue entre mayúsculas y minúsculas, así que "int a;" es distinto de "int A;", y también
de "INT a;"
4:
Una línea vacía, no sirve para nada, desde el punto de vista del compilador, pero sirve para separar
visualmente la parte de declaración de variables de la parte de código que va a continuación. Una
labor análoga la desempeña el tabulado de las líneas: ayuda a hacer los programas más fáciles de
leer.
5: a = 2 + 2;
Se trata de otra sentencia, ya que acaba con punto y coma. Esta es una sentencia de asignación. Le
asigna a la variable 'a' el valor resultante de la operación "2 + 2".
6: return 0;
De nuevo una sentencia, "return" es una palabra reservada, propia de C++. Indica al programa que
debe abandonar la ejecución de la función y continuar a partir del punto en que se la llamó. El '0' es
el valor de retorno de nuestra función. Cuando "main" retorna con 0 indica que todo ha ido bien.
7: }
Esta es la llave que cierra el cuerpo o definición de la función.Lo malo de este programa, a pesar de
sumar correctamente "2+2", es que aparentemente no hace nada. No acepta datos externos y no
YMR

proporciona ninguna salida de ningún tipo.En realidad es absolutamente inútil, salvo para fines
didácticos, que es para lo que fue creado. Paciencia, iremos poco a poco.!!!!!

El objeto cout
Uno de los objetos más versátiles y usados en C++ se llama cout (pronunciado “si out”). Este objeto, cuyo
nombre se deriva de Console OUTput, es un objeto de salida que envía datos introducidos en él al dispositivo
estándar de salida. temas, este dispositivo de salida es una pantalla de video. El objeto cout muestra en el
monitor cualquier cosa enviada a él. Por ejemplo, si se envían los datos ¡Hola mundo! A cout, estos datos se
imprimen (o despliegan) en la pantalla de la terminal. Los datos ¡Hola mundo! se envían al objeto cout
encerrando el texto entre comillas, “poner cadena aquí”, y colocando el símbolo de inserción << (“enviar a”),
antes del mensaje y después del nombre del objeto, como se muestra a continuación.

cout<<“¡Hola mundo!”;
Programa 1:
#include<iostream> using
namespace std; int
main()
{
cout <<"Hola mundo!"; return0;
}
La primera línea del programa, #include<iostream> es un comando preprocesador que utiliza la palabra
reservada include. Los comandos preprocesadores comienzan con un signo de número (#) y ejecutan alguna
acción antes que el compilador traduzca el programa fuente a código de máquina. De manera específica, el
comando preprocesador #include causa que el contenido del archivo invocado, en este caso el archivo
iostream, sea insertado en donde el comando #include aparezca en el programa. El iostream es una parte de
la biblioteca estándar que contiene, entre otro código, dos clases nombradas istream y ostream. Estas dos
clases proporcionan las declaraciones de datos y métodos utilizados para la entrada y salida de datos,
respectivamente. El archivo iostream se conoce como un archivo de encabezado debido a que siempre se
coloca una referencia a él en la parte superior, o cabeza, de un programa C++ usando el comando #include.
Puede ser que se pregunte qué tiene que ver el archivo iostream con este programa simple. La respuesta es
que el objeto cout se crea a partir de la clase ostream. Por tanto, el archivo de encabezado iostream debe
incluirse en programas que usen cout.

¿Qué es la sintaxis?
La sintaxis de un lenguaje de programación es el conjunto de reglas para formular instrucciones
gramaticalmente correctas en un lenguaje. En la práctica esto significa que una instrucción en C++ con
sintaxis correcta tiene la forma apropiada especificada para el compilador. Como tal, el compilador aceptará
la instrucción y no generará un mensaje de error. Debe señalarse que una instrucción o programa individual
puede ser correcto desde el punto de vista sintáctico, pero incorrecto desde el punto de vista lógico. Una
instrucción o programa así estaría estructurado de manera correcta, pero produciría un resultado incorrecto.
Esto es similar a un enunciado en español que es correcto desde el punto de vista gramatical pero no tiene
sentido. Por ejemplo, aunque el enunciado “El árbol es un gato andrajoso” es gramaticalmente correcto, no
tiene sentido.

Después del comando preprocesador include hay una instrucción que contiene la palabra reservada using.
La instrucción, using namespace std; le dice al compilador dónde buscar para encontrar los archivos de
encabezado en ausencia de cualquier designación explícita adicional. Se puede pensar en un espacio de
nombres como un archivo de código fuente al que tiene acceso el compilador cuando busca clases o
funciones preescritas. Debido a que el archivo de encabezado iostream está contenido dentro de un espacio
de nombres llamado std, el compilador usará de manera automática el objeto cout de iostream a partir de
YMR

este espacio de nombres siempre que se haga referencia a cout. El uso de espacio de nombres le permite
crear sus propias clases y funciones con los mismos nombres provistos por la biblioteca estándar y colocarlos
en espacios de nombres invocados de manera diferente. Puede señalar al programa cuál clase o función usar
al indicar el espacio de nombres donde desea que el compilador busque la clase o función.

La instrucción using es seguida por el inicio de la función main() del programa. Esta función comienza con la
línea de encabezado desarrollada al principio de esta sección. El cuerpo de la función, entre llaves, consta de
sólo dos instrucciones. La primera instrucción en main() pasa un mensaje al objeto cout. El mensaje es la
cadena “¡Hola mundo!”. Debido a que cout es un objeto de una clase preescrita, no tenemos que escribirlo;
está disponible para su uso con sólo activarlo en forma correcta. Como todos los objetos de C++, cout sólo
puede ejecutar ciertas acciones bien definidas. Para cout, la acción es ensamblar datos para mostrar la
salida.
Cuando se pasa una cadena de caracteres a cout, el objeto asegura que la cadena se despliegue de manera
correcta en su monitor, como se muestra:

¡Hola mundo!
Programa 2.-Realizar un programa en c++ que imprima 20 veces la palabra Hola Mundo

Programa 3.-Realizar un programa en c++ que imprima tus datos personales, tales como nombre, edad,
escuela de procedencia, carrera, entretenimientos.

Programa 4:

Cuando se ejecuta el siguiente programa, la salida es la siguiente:

En lenguaje C puedes imprimir valores especiales que son interpretados para realizar diferentes acciones en
lugar de imprimir un carácter. En principio se podía escribir como 0x0a, 0x10, … dependiendo del carácter
específico.

Como nemotecnia y para facilitar se realize que los valores de escape se igualaran a estos valores colocando
una barra invertida (\) seguida de un carácter. Los más usados son “\n” (newline) y “\t” (tabulador), pero hay
más como “\r” (retroceso, para ir al inicio de la línea, hay sistemas donde un salto de línea debe hacerse
como \r\n), o también “\b” (bell, reproduce un sonido).

Si se desea imprimir “Hola mundo\n\tEsto es una cadena.\n” La salida sera:

YMR

Ten presente que “\t” se traduce como espacios en pantalla pudiendo ser 4 u 8. En consola normalmente
son 8 espacios.

Programa 5.-Realiza la impresión de cadena literal en un programa c++ donde coloques el siguiente texto con
su retorno de carro y tabuladores correspondientes:

Cuestionario.

1.- ¿Como Nació C?_________________________________________________________________

2.- ¿Quiénes desarrollaron C? _________________________________________________________

3.- ¿Qué es un IDE? _________________________________________________________________

4.- Defina los siguientes términos:

a. programa de computadora: _______________________________________________________

b. programación: _________________________________________________________________
YMR

c. lenguaje de programación: ________________________________________________________

d. lenguaje de alto nivel: ____________________________________________________________

e. lenguaje de bajo nivel____________________________________________________________

f. lenguaje de máquina____________________________________________________________

g. lenguaje ensamblador___________________________________________________________

h. lenguaje orientado a procedimientos_______________________________________________

i. compilador_____________________________________________________________________

5.- ¿Que es una directiva de preprocesador? ____________________________________________

6.- ¿Qué significa int main () _________________________________________________________

7.- ¿Para qué sirve el \n y \t _________________________________________________________

8.- ¿Que es una cadena literal? ______________________________________________________

9.- ¿Qué es Using namespace std? ____________________________________________________

10. ¿Para qué sirve el cot <<? ________________________________________________________

Código ASCII
YMR

Ejercicio .- Muestra cómo se almacenaría tu nombre en mayúsculas usando el código ASCII

_________________________________________________________________________________

Comentarios
Los comentarios son observaciones explicativas que se hacen dentro de un programa. Cuando se usan con
cuidado, los comentarios pueden ser muy útiles para aclarar de qué trata el programa completo, qué
pretende lograr un grupo específico de instrucciones o qué pretende hacer una línea. C++ acepta dos tipos
de comentarios: de línea y de bloque. Ambos tipos de comentarios pueden colocarse en cualquier parte
dentro de un programa y no tienen efecto en la ejecución de este. El compilador ignora todos los
comentarios; están ahí estrictamente para la conveniencia de cualquiera que lea el programa.
Un comentario de línea empieza con dos diagonales (//) y continúa hasta el final de la línea.
Por ejemplo, las siguientes líneas son comentarios de línea:

//éste es un comentario
//este programa imprime un mensaje
//este programa calcula una raíz cuadrada
Ejemplo

Los comentarios que abarcan dos o más líneas se escriben de manera más conveniente como comentarios
en bloque tipo C que como múltiples comentarios de línea. Los comentarios en bloque comienzan con los
símbolos /* y terminan con los símbolos */.
Ejemplo

Por lo general, cualquier programa que escriba deberá comenzar con una serie de comentarios iniciales al
programa que incluyan una descripción breve de éste, su nombre y la fecha de la última modificación.

Programa 6.- Vuelva a escribir los siguientes programas para que se ajusten a una buena práctica de
programación y una sintaxis correcta.
YMR

Tipo de Datos
El objetivo de todos los programas es procesar datos, sean numéricos, alfabéticos, de audio o de video. Es
fundamental para este objetivo la clasificación de los datos en tipos específicos. Por ejemplo, calcular la
trayectoria de un cohete requiere operaciones matemáticas con datos numéricos, y alfabetizar una lista de
nombres requiere operaciones de comparación con datos basados en caracteres. Además, algunas
operaciones no son aplicables a ciertos tipos de datos. Por ejemplo, no tiene sentido sumar nombres. Para
impedir que los programadores intenten ejecutar una operación inapropiada, C++ sólo permite que se
ejecuten ciertas operaciones con ciertos tipos de datos.
Los tipos de dato permitidos y las operaciones apropiadas definidas para cada tipo se conocen como tipo de
dato. De manera formal, un tipo de dato se define como un conjunto de valores y un conjunto de
operaciones que pueden aplicarse a estos valores. Por ejemplo, el conjunto de todos los números enteros
constituye un conjunto de valores, como lo es el conjunto de todos los números reales (números que
contienen un punto decimal). Estos dos conjuntos de números, sin embargo, no constituyen un tipo de dato
hasta que se incluye un conjunto de operaciones. Estas operaciones, por supuesto, son las operaciones
matemáticas y de comparación. La combinación de un conjunto de valores más las operaciones se vuelve un
tipo de dato verdadero.

C++ clasifica los tipos de datos en uno de dos agrupamientos fundamentales: tipos de dato de clase y tipos
de dato integrados. Un tipo de dato de clase, al cual se hace referencia como una clase, para abreviar, es un
tipo de dato creado por el programador. Esto significa que el conjunto de valores y operaciones admitidas es
definido por un programador, usando código C++.

Un tipo de dato integrado es proporcionado como una parte integral del compilador C++ y no requiere
código C++ externo. Por tanto, un tipo de dato integrado puede usarse sin recurrir a adiciones de lenguaje
complementarias, como las proporcionadas por el archivo de encabezado iostream necesario para el objeto
cout. Los tipos de dato integrados, los cuales también se conocen como tipos primitivos, consisten en los
tipos numéricos básicos mostrados.

Al introducir tipos de dato integrados de C++, usaremos literales. Una literal es un valor aceptable para un
tipo de dato. El término literal refleja que dicho valor se identifica de manera explícita a sí mismo. (Otro
nombre para una literal es un valor literal o constante.) Por ejemplo, todos los números, como 2, 3.6 y –8.2,
se denominan valores literales porque despliegan sus valores de manera literal.
YMR

El tipo de dato int

El conjunto de valores admitidos por el tipo de dato int son números enteros. Un valor entero consiste sólo
de dígitos y de manera opcional puede estar precedido por un signo de más
(+) o menos (–). Por tanto, un valor entero puede ser el número cero o cualquier valor numérico positivo o
negativo sin un punto decimal. Ejemplos de enteros válidos son:
0 5 –10 +25 1000 253 –26 351 +36
No se permiten signos de dólar, puntos, ni comas, ni símbolos especiales, la asignación de almacenamiento
más común es de 4 bytes.

El tipo de dato char

El tipo de dato char se usa para almacenar caracteres individuales. Los caracteres incluyen las letras del
alfabeto (mayúsculas y minúsculas), los diez dígitos 0 a 9 y símbolos especiales como los siguientes:
+$.,–y!

Un valor de carácter individual es cualquier letra, dígito o símbolo especial encerrado entre comillas
sencillas. Los siguientes son ejemplos de valores de carácter válidos:

Un carácter que tiene un significado especial en C++ es la diagonal inversa, \, que se conoce como
carácter de escape:
YMR

El tipo de datos bool

En C++, el tipo de datos bool se usa para representar datos booleanos (lógicos). Por ello, este tipo de datos
está restringido a uno de dos valores: verdadero o falso. Este tipo de datos es más útil cuando un programa
debe examinar una condición específica y, debido a la condición de ser verdadera o falsa, tomar un curso de
acción prescrito.

Determinación del tamaño de almacenamiento

Una característica única de C++ es que le permite al programador ver dónde y cómo se almacenan los
valores. Por ejemplo, C++ proporciona un operador denominado sizeof() que proporciona el número de
bytes usados para almacenar valores para cualquier nombre de tipo de datos incluidos dentro de los
paréntesis del operador. Éste es un operador integrado que no usa un símbolo aritmético para ejecutar su
operación.
YMR

Tipos de punto flotante

Un número de punto flotante, al cual se le llama número real, puede ser el número cero o cualquier número
positivo o negativo que contenga un punto decimal. Los siguientes son ejemplos de números de punto flotante:

C++ acepta tres tipos de datos de punto flotante: float, double y long double. La diferencia entre estos tipos
de datos es la cantidad de almacenamiento que usa un compilador para cada tipo. La mayor parte de los
compiladores usan el doble de cantidad de almacenamiento para dobles que, para flotantes, lo cual permite
que un double tenga aproximadamente el doble de precisión de un float. Por esta razón, a veces se hace
referencia a un valor float como un número de precisión simple y a un valor double como un número de
precisión doble.

Programa 7.- determinar el almacenamiento usado por su compilador para todos los tipos de
datos enteros de C++.
YMR

Programa 8.- Realizar un programa donde la salida sea la siguiente:

Operaciones aritméticas Los operadores usados en operaciones aritméticas se llaman operadores

aritméticos y son los siguientes

La forma de programar una operación aritmética puede tener varias variantes: cout << (6+15);
División de enteros
La división de dos valores enteros puede producir resultados bastante extraños para los incautos. Por
ejemplo, la expresión 15/2 produce el resultado entero 7. Debido a que los enteros no pueden contener una
parte fraccionaria, no puede obtenerse un valor de 7.5. La parte fraccionaria obtenida cuando se dividen dos
enteros, es decir, el residuo, siempre se elimina (se trunca). Por tanto, el valor de 9/4 es 2, y 20/3 es 6. Sin
embargo, con frecuencia puede ser necesario conservar el residuo de una división de enteros. Para hacer
esto, C++ proporciona un operador aritmético que tiene el símbolo %. Este operador, llamado módulo (y
también conocido como operador de residuo), captura el residuo cuando un número entero es dividido
entre un entero (usar un valor no entero con el operador de módulo produce un error en el compilador):

Ejercicio ____
A continuación, se enumeran expresiones algebraicas correctas y expresiones C++ incorrectas
correspondientes a ellas. Encuentre los errores y escriba las expresiones C++ corregidas.
YMR

Programa 9.-Realizar en tu cuaderno los 3 ejercicios algebraicos y expresiones en C++ en un solo programa.

Programa 10.- Escriba un programa C++ que despliegue los resultados de las expresiones 3.0 * 5.0,
7.1 * 8.3 - 2.2 y 3.2 / (6.1 * 5). Calcule el valor de estas expresiones en forma manual para verificar
que los valores desplegados son correctos.

Variables e Instrucciones de Declaración

Una variable es tan sólo un nombre dado por el programador para referirse a ubicaciones de
almacenamiento de la computadora. Se usa el término variable porque el valor almacenado en la
variable puede cambiar, o variar. Para cada nombre que usa el programador, la computadora se
mantiene al tanto de la dirección de memoria real correspondiente a ese nombre. Las reglas para
seleccionar nombre de variables.
• El nombre de la variable debe comenzar con una letra o subrayado (_) y sólo puede
contener letras, subrayados o dígitos. No puede contener ningún espacio en blanco,
comas ni símbolos especiales, como ( ) & , $ # . ! \ ?
• Un nombre de variable no puede ser una palabra clave.
• El nombre de la variable no puede consistir en más de 1024 caracteres.

Declaración de una variable Una instrucción de declaración tiene la forma general

Tipo-de-dato nombreDeVariable;
Int suma;
Long dechanum;
Float primernum;
Ejemplo de una
variable para
asignación de
memoria.
YMR

Para determinar la dirección de num, podemos usar el operador de dirección de C++, &, el cual
significa “la dirección de”. Excepto cuando se usa en una expresión, el operador de dirección
colocado enfrente del nombre de una variable se refiere a la dirección de la variable

Ejercicio. -Establezca si los siguientes nombres de variables son válidos o no. Si son inválidos,
explique por qué.

prod_a c1234 abcd _c3 12345 ampnuevo vatios $total $alnuevo a1b2c3d4 9ab6 suma.de
promedio voltios1 finvoltio

Pregunta: Toda variable tiene tres elementos asociados. ¿Cuáles son estos tres elementos?

Programa 11.- La corriente eléctrica, i, en amperios, que fluye a través del circuito ilustrado en la
figura 2.18 está dada por la donde E es el voltaje de la batería en voltios, R es el valor del resistor en
ohmios, L es el valor del inductor en henrios, t es el tiempo en segundos después de cerrar el
interruptor y e es el número de Euler, el cual es 2.718 con una precisión de tres cifras decimales.
Usando esta fórmula, escriba, compile y ejecute un programa en C++ para determinar el flujo de
corriente en el circuito ilustrado en la figura, cuando t es 0.12 segundos

Expresiones de Asignación
YMR

Las expresiones de asignación como suma =suma+25, que usan la misma variable en ambos lados
del operador de asignación, pueden escribirse usando los siguientes atajos de operadores de
asignación:

Al utilizar estos operadores de asignación es importante observar que la variable de la izquierda

del operador de asignación se aplica a la expresión de la derecha completa. Por ejemplo, precio * =
tasa + 1 es equivalente a la expresión precio = precio * (tasa + 1)

Acumulación

Las expresiones de asignación como suma+=10 o su equivalente, suma=suma+10, son muy

comunes en programación. Estas expresiones se requieren para acumular subtotales cuando los
datos se introducen un número a la vez. Por ejemplo, si se desea sumar los números 96, 70, 85 y
60 en forma de calculadora, podrían usarse las siguientes instrucciones:

Programa 11.-Realiza el programa para la acumulación de la variable suma en donde el resultado final se
387

Conteo Una instrucción de asignación que es muy similar a la instrucción de acumulación es la

instrucción de conteo. Las instrucciones de conteo tienen la forma.

Son ejemplos de instrucciones de conteo

Programa 12.- Escriba una instrucción de asignación para convertir temperatura en grados
Fahrenheit a grados Celsius. La ecuación para esta conversión es Celsius = 5/9 (Fahrenheit – 32).

Programa 13.-Escribir un programa que ejemplifique cada una de las salidas de manipulación de
los datos
YMR

Librería de Funciones Matemáticas

Como se ha visto, las instrucciones de asignación pueden usarse para ejecutar cálculos aritméticos.
Por ejemplo, la instrucción de asignación voltios = resistencia * corriente; multiplica el valor en
corriente por el valor en resistencia y asigna el valor resultante a voltios. Aunque la adición,
sustracción, multiplicación y división se logran con facilidad usando operadores aritméticos de C+
+, no existen operadores para elevar un número a una potencia, encontrar la raíz cuadrada de un
número o determinar valores trigonométricos.
YMR

Para facilitar estos cálculos, C++ proporciona funciones preprogramadas estándares que pueden
incluirse en un programa. Antes de usar una de las funciones matemáticas de C++, necesita saber

• El nombre de la función matemática deseada

• Qué hace la función matemática

• El tipo de datos requerido por la función matemática

• El tipo de datos del resultado devuelto por la función matemática

• Cómo incluir la biblioteca Para ilustrar el uso de las funciones matemáticas de C++, considere la función
matemática llamada sqrt, la cual calcula la raíz cuadrada de un número. La raíz cuadrada de un número
se calcula usando la expresión sqrt(número)

Programa 14.-Escribir un programa que ejemplifique cada una de las salidas de funciones
matemáticas

Programa 15.- Escriba instrucciones de C++ para lo siguiente:

YMR

ENTRADA DE DATOS AL PROGRAMA USANDO EL OBJETO cin

Cuando se encuentra una instrucción como cin>>num1; la computadora detiene la ejecución del
programa y acepta datos del teclado. Cuando se escribe un elemento de datos, el objeto cin
almacena el elemento en la variable mostrada después del operador de extracción (“obtener de”),
>>. El programa continúa luego su ejecución con la siguiente instrucción después de la llamada a
cin.
Ejemplos

Programa 16.-Escribir un programa que complete la siguiente tabla

Programa 17.- Escriba, compile y ejecute un programa en C++ que despliegue los siguientes
indicadores: Introduzca un número: Introduzca un segundo número: Introduzca un tercer número:
YMR

Introduzca un cuarto número: Después que se despliega cada indicador, su programa deberá usar
una instrucción cin para aceptar un número desde el teclado para el indicador desplegado.
Después que se ha introducido el cuarto número, su programa deberá calcular y desplegar el
promedio de los números. El promedio deberá incluirse en un mensaje apropiado. Verifique el
promedio desplegado por su programa usando los siguientes datos de prueba:

Conjunto de datos de prueba 1: 100, 100, 100, 100 Conjunto de datos de prueba 2: 100, 0, 100, 0

Cuando haya completado su verificación, use su programa para completar la siguiente tabla:

Programa 18.- Repita el ejercicio 5a, asegurándose que usa el mismo nombre de variable, numero,
para cada entrada de número. También use la variable suma para la suma de los números.

Programa 19.- Escriba, compile y ejecute un programa en C++ que calcule y despliegue el valor de
polinomio de segundo orden ax2 + bx + c para valores introducidos por el usuario de los
coeficientes a, b, c y la variable x

Programa 20.-Identiifcar el siguiente código y explicarlo

Código Fuente
Diariamente cuando nos sentamos frente a la pantalla de nuestra computadora, la mayoría de nosotros quizás no
somos conscientes de que las tareas que podemos realizar a través de los programas instalados son posibles gracias
a un elemento fundamental, el cual se denomina código fuente.

Básicamente, el código fuente es el archivo o archivos con las instrucciones necesarias, realizadas en un lenguaje de
programación, que sirve para compilar posteriormente un programa o programas para que puedan ser utilizados
por el usuario de forma directa, tan sólo ejecutándolo.
YMR

Para lograr esto, es decir que el usuario común pueda utilizar un software sin inconvenientes y sin preocuparse por
cómo ha sido desarrollado el mismo, los creadores de programas informáticos utilizan distintos tipos de lenguajes de
programación para escribir el código fuente de un determinado software.

En este sentido, existen una gran cantidad de lenguajes de programación, cada uno de ellos orientados de una u otra
forma a la creación de distintos tipos de programas, siendo los más conocidos los lenguajes llamados HTML, C++,
Java y Delphi, entre otros.

Compiladores Vs Interpretes
¿Como se ejecuta un programa?

Además de un compilador se necesitan otros programas para crear un programa objeto ejecutable. Un
preprocesador sirve para reunir los módulos de un programa escrito en varios archivos diferentes (por ejemplo, los
archivos de inclusión indicados en las sentencias #include en C) y/o expandir las macros del lenguaje (por ejemplo,
las constantes simbólicas de las sentencias #define en C).

El programa objeto puede requerir procesamiento adicional antes de poderlo ejecutar. Por ejemplo un código
ensamblador debe ser traducido a código de máquina y después se enlaza a algunas rutinas de biblioteca (como los
códigos de las funciones printf() y scanf() en C) para producir el código que realmente se ejecuta.
YMR

INTERPRETE
Un intérprete es un programa informático que procesa el código fuente de un proyecto de software durante su
tiempo de ejecución, es decir, mientras el software se está ejecutando, y actúa como una interfaz entre ese
proyecto y el procesador. Un intérprete siempre procesa el código líneo por línea, de modo que lee, analiza y
prepara cada secuencia de forma consecutiva para el procesador. Este principio también se aplica a las secuencias
recurrentes, que se ejecutan de nuevo cada vez que vuelven a aparecer en el código. Para procesar el código fuente
del software, el intérprete recurre a sus propias bibliotecas internas: en cuanto una línea de código fuente se ha
traducido a los correspondientes comandos legibles por máquina, esta se envía directamente al procesador.

COMPILADOR
Un compilador es un programa informático que traduce todo el código fuente de un proyecto de software a código
máquina antes de ejecutarlo. Solo entonces el procesador ejecuta el software, obteniendo todas las instrucciones en
código máquina antes de comenzar. De esta manera, el procesador cuenta con todos los componentes necesarios
para ejecutar el software, procesar las entradas y generar los resultados. No obstante, en muchos casos, durante el
proceso de compilación tiene lugar un paso intermedio fundamental: antes de generar la traducción final en código
máquina, la mayoría de los compiladores suelen convertir el código fuente en un código intermedio (también
llamado código objeto) que, a menudo, es compatible con diversas plataformas y que, además, también puede ser
utilizado por un intérprete.
YMR

Estructura General de un Programa

Un programa en C se compone de una o más funciones, debe ser obligatoriamente le Main.

Una función en C es un grupo de instrucciones que realizan una o más acciones, asimismo un programa contendrá
una serie de directivas # inlcude que permitirá incluir en el mismo archivo de cabecera que a su vez constara de
funciones y datos predefinidos por ellos.

De modo más explícito, un programa en C puede incluir

Directivas de preprocesador
Declaraciones Globales
La función main
Funciones definidas por el usuario
Comentarios de programa

Directivas de Preprocesador
El preprocesador es un programa que forma parte del compilador y que “prepara” o modifica el código fuente antes
de ser traducido a código binario. Los cambios los hace interpretando aquellas líneas del código que comienzan por
el símbolo “#”. El uso de estas directivas es tan común en los programas en C que parece que forman parte del
lenguaje, pero en realidad son parte de un lenguaje que sólo entiende el procesador.

La directiva #include
La directiva #include debe ir seguida del nombre de un fichero y su efecto es de reemplazar esta línea en el código
fuente por el contenido del fichero que se especifica. La siguiente figura ilustra un ejemplo de esta directiva.

Con esta directiva debes tener en cuenta lo siguiente:

YMR

Si el fichero que va a continuación de #include está rodeado por “<” y “>”, el preprocesador lo busca en los
directorios internos del sistema. Esta versión se utiliza por tanto para incluir ficheros dados por el sistema.

Si el fichero está rodeado de doble comilla, entonces se busca en el directorio en el que se está compilando. Esta
versión de la directiva se utiliza para incluir ficheros que ha escrito el usuario. La opción -L del compilador permite
especificar una lista adicional de directorios en los que buscar este tipo de ficheros.

La extensión “.h” se suele utilizar para ficheros que se incluyen en un programa con esta directiva

Antes de incluir el contenido del fichero, se procesan las directivas contenidas en su interior. Esto permite que un
fichero que se incluye en un programa incluya a su vez otros.

Este tipo de ficheros suele incluir definiciones que se necesitan en más de un fichero. En lugar de repetir estas
definiciones en los ficheros de código (con extensión “.c”), se pasan a un fichero con extensión “.h” que se incluye en
todos ellos.

Los ficheros incluidos con la directiva #include no se escriben en el comando que invoca al compilador. Su utilización
la decide el preprocesador cuando encuentra la directiva #include.

En ocasiones encontramos palabras cuyo significado no sabemos, pues para hablar un determinado idioma no
necesitamos conocer todas las palabras existentes. Se podría decir que conocemos la mayoría y cuando
encontramos una que no conocemos recurrimos a un diccionario, una vez que conocemos su significado podemos
usarla. Lo mismo sucede con los compiladores, por eso cuando queremos usar una función o método que él
desconoce, debemos primero decirle dónde aprender qué es.

Librería o biblioteca
Normalmente son llamadas librerías en español, aunque es técnicamente más apropiado llamarles bibliotecas, pues
la palabra de la que surgen es de la palabra en inglés library cuya traducción inmediata es biblioteca. Esto no
importa demasiado pues para quienes hablamos español, ambas palabras nos dan una idea muy similar. También
hay quienes se refieren a ellas como cabeceras o en inglés headers.

Una librería es un archivo que el compilador puede leer y en el que encuentra las instrucciones de uso de muchos y
distintos métodos y funciones. Existen cientos de librerías, la mayoría de IDE ya las tienen incluidas, pero no las
incluyen en todos los códigos fuente que se crean, con el propósito de que estos no sean demasiado grandes. Por
esto debemos declarar en nuestro código fuente qué librerías necesitaremos.

Una librería en C++ es un archivo en donde se define la función y uso de muchas funciones diferentes.

Si incluimos una librería en nuestro programa entonces podemos usar rápida y fácilmente las instrucciones que se
definen en ella.

Declaración
Si vamos a usar una determinada librería en nuestro programa, debemos incluirla o declararla en nuestro código
fuente. Para incluir algo a nuestro archivo fuente usamos la expresión #include, después de esto y entre signos de
menor qué (<) y mayor qué (>) ponemos el nombre de la librería. De manera general sería:

Librerias
YMR

Bibliotecas o librerías en C++. Declaración y uso de librerías. Include en C++

Junto con los compiladores de C y C++, se incluyen ciertos archivos llamados bibliotecas más comúnmente librerías.
Las bibliotecas contienen el código objeto de muchos programas que permiten hacer cosas comunes, como leer el
teclado, escribir en la pantalla, manejar números, realizar funciones matemáticas, etc.

Las bibliotecas están clasificadas por el tipo de trabajos que hacen, hay bibliotecas de entrada y salida, matemáticas,
de manejo de memoria, de manejo de textos y como imaginarás existen muchísimas librerías disponibles y todas con
una función específica.

Hay un conjunto de bibliotecas (o librerías) muy especiales, que se incluyen con todos los compiladores de C y de C+
+. Son las librerías (o bibliotecas) ANSI o estándar. También hay librerías que no son parte del estándar pero en esta
sección sólo usaremos algunas bibliotecas (o librerías) ANSI.

¿Qué son exactamente las librerías?

En C++, se conoce como librerías (o bibliotecas) a cierto tipo de archivos que podemos importar o incluir en nuestro
programa. Estos archivos contienen las especificaciones de diferentes funcionalidades ya construidas y utilizables
que podremos agregar a nuestro programa, como por ejemplo leer del teclado o mostrar algo por pantalla entre
muchas otras más.

Al poder incluir estas librerías con definiciones de diferentes funcionalidades podremos ahorrarnos gran cantidad de
cosas, imaginemos por ejemplo que cada vez que necesitemos leer por teclado, debamos entonces crear una
función que lo haga (algo realmente complejo), al poder contar con las librerías en C++, podremos hacer uso de una
gran variedad de funciones que nos facilitaran la vida y aumentarán la modularidad de nuestros códigos.

Las librerías no son únicamente archivos externos creados por otros, también es posible crear nuestras propias
librerías y utilizarlas en nuestros programas. Las librerías pueden tener varias extensiones diferentes, las más
comunes son: .lib, .bpl, .a, .dll, .h y algunas más ya no tan comunes.

Sintaxis para declarar Librerías en C++

La declaración de librerías, tanto en C como en C++, se debe hacer al principio de todo nuestro código, antes de la
declaración de cualquier función o línea de código, debemos indicarle al compilador que librerías usar, para el saber
que términos estaran correctos en la escritura de nuestro código y cuáles no. La sintaxis es la siguiente: #include
<nombre de la librería> o alternativamente #include "nombre de la librería". Cualquiera de las 2 formas es válida en
C++ (no estoy seguro si en C sea válido), ten en cuenta que siempre el nombre de la librería debe ir entre " y " o
entre < y >. En tu código puedes declarar todas las librerías que quieras aunque en realidad no tienen sentido
declarar una librería que no vas a usar en tu programa, sin embargo no existe límite para esto.

A continuación, pondré algunas de las librerías de uso más común de C++ y que forman parte de las librerías
estandar de este lenguaje.

fstream: Flujos hacia/desde ficheros. Permite la manipulación de archivos desde el programar, tanto leer como
escribir en ellos.

iosfwd: Contiene declaraciones adelantadas de todas las plantillas de flujos y sus typedefs estándar. Por ejemplo
ostream.

iostream: Parte del a STL que contiene los algoritmos estándar, es quizá la más usada e importante (aunque no
indispensable).
YMR

La biblioteca list: Parte de la STL relativa a contenedores tipo list; listas doblemente enlazadas

math: Contiene los prototipos de las funciones y otras definiciones para el uso y manipulación de funciones
matemáticas.

memory: Utilidades relativas a la gestión de memoria, incluyendo asignadores y punteros inteligentes (auto_ptr).
"auto_ptr" es una clase que conforma la librería memory y permite un fácil manejo de punteros y su destrucción
automaticamente.

Biblioteca new: Manejo de memoria dinámica

numeric: Parte de la librería numérica de la STL relativa a operaciones numéricas.

ostream: Algoritmos estándar para los flujos de salida.

queue: Parte de la STL relativa a contenedores tipo queue (colas de objetos).

Librería stdio: Contiene los prototipos de las funciones, macros, y tipos para manipular datos de entrada y salida.

Librería stdlib: Contiene los prototipos de las funciones, macros, y tipos para utilidades de uso general.

string: Parte de la STL relativa a contenedores tipo string; una generalización de las cadenas alfanuméricas para
albergar cadenas de objetos. Muy útil para el fácil uso de las cadenas de caracteres, pues elimina muchas d elas
dificultades que generan los char

typeinfo: Mecanismo de identificación de tipos en tiempo de ejecución

vector: Parte de la STL relativa a los contenedores tipo vector; una generalización de las matrices unidimensionales
C/C++

forward_list: Esta librería es útil para implementar con gran facilidad listas enlazadas simples.

list: Permite implementar listas doblemente enlzadas (listas enlazadas dobles) facilmente.

iterator: Proporciona un conjunto de clases para iterar elementos.

regex: Proporciona fácil acceso al uso de expresiones regulares para la comparación de patrones.

thread: Útil para trabajar programación multihilos y crear múltiples hilos en nuestra aplicación.

time: Útil para obtener marcas de tiempo durante ejecución. Se usa con frecuencia para conocer el tiempo exacto
durante un programa.
YMR

#include <algorithm> // Algoritmos de la plantilla estándar

#include <chrono> // Librería para usar mediciones de tiempo
#include <complex> // Librería para usar números complejos
#include <exception> // Exepciones estándar
#include <functional> // Objetos para funciones
#include <initializer_list> // Para inicilizar listas
#include <iterator> // Para definir iteradores
#include <limits> // Calcula límites numéricos
#include <locale> // Librería para localizaciones
#include <memory> // Elementos de memoria
#include <new> // Para uso dinámico de memoria
#include <numeric> // Operaciones numéricas generales
#include <random> // Funciones para obtener cosas aleatorias
#include <ratio> // Librería para proporciones
#include <regex> // Para manejar expresiones regulares
#include <stdexcept> // Clases de exepciones
#include <string> // Crea y maneja elementos string
#include <system_error> // Gestión de errores del sistema
#include <tuple> // Librería para objetos tipo tuple
#include <typeinfo> // Obtener información sobre tipos de datos
#include <type_traits> // Tipos de traits
#include <utility> // Componentes variados de utilería
#include <valarray> // Para arreglos de elementos numéricos

Veamos a continuación como se haría la declaración de unas cuantas librerías conocidas, recuerda que ese puede
declarar todas las librerías necesarias y siempre debe hacerse al comienzo del código fuente

#include "iostream"
#include "string"
#include <math.h>
#include <conio.h>

Using namespace std;

Con esto debió quedar claro, como declarar librerías C++ al interior de un código fuente. Lo único adicional, es la
línea que dice using namespace std; esta línea nos ayuda a declarar un espacio de nombre que evita tener que
usarlo cada que accedemos a alguna función especifica de una librería. Teniendo este namespace declarado
podemos llamar por ejemplo el comando cout >>, que pertenece a la librería iostream, sin embargo sin este
namespace sería std::cout >>, imagina tener que hacer esto cada vez que uses algún comando o función de las
librerías, sería bastante tedioso.

Acerca del namespace std

YMR

Todas las librerías estándar de C++ contienen una declaración del espacio de nombre std, es decir que todas las
librerías que hacen parte del estándar de C++ colocan entidades dentro de este espacio de nombre.

Por esta razón cuando declaramos el uso del espacio de nombre std por medio de "using namespace std;", podemos
evitar estar escribiendo std::cout o std::cin, etc en nuestro código.

El espacio de nombre std como tal no es una librería sino simplemente un namespace, por esta razón no reemplaza
la declaración de las librerías del código, simplemente facilita la escritura de éste al momento de usar las entidades
de las librerías estándar. Sin embargo si vamos a hacer uso de una o varias librerías estándar de C++ es
recomendable que declaremos el namespace std, para no tener que estar constantemente escribiendo cosas
similares a las que puse hace unas líneas como std::cin o similares, dado que únicamente se puede acceder a la
entidades de las librerías estándar por medio del espacio nombre std.
Programa ______

Realizar un programa en C++ que utilice los objetos Cin y Cout sin la declaración de using namespace std;

Estructuras de Selección

Han ocurrido muchos avances en los fundamentos teóricos de la programación desde el comienzo de los lenguajes
de alto nivel a finales de la década de los años 50. Uno de los más importantes de estos avances fue el
reconocimiento a finales de la década de los años 60 que cualquier algoritmo, sin importar cuán complejo fuera,
podía ser construido
usando combinaciones de cuatro estructuras de flujo de control estandarizadas: secuencial, de selección, de
repetición y de invocación. El término flujo de control se refiere al orden en que las instrucciones de un programa
son ejecutadas. A menos que se dirijan de otra manera, el flujo de control normal para todos los programas es
secuencial. Esto significa que las instrucciones son ejecutadas en secuencia, una tras otra, en el orden en que son
colocadas dentro del programa. Estructuras de selección

Las estructuras de selección, repetición e invocación permiten que el flujo de control secuencial sea alterado en
formas definidas con precisión, las estructura de selección se usa para seleccionar cuáles instrucciones se han de
ejecutar a continuación y la estructura de repetición se usa para repetir un conjunto de instrucciones.

En la solución de muchos problemas, deben emprenderse diferentes acciones dependiendo del valor de los datos.
Los ejemplos de situaciones simples incluyen calcular un área sólo si las mediciones son positivas, ejecutar una
división sólo si el divisor no es cero, imprimir diferentes mensajes dependiendo del valor de una calificación recibida,
y así en forma sucesiva. La instrucción if-else en C++ se usa para poner en práctica una estructura de decisión en su
forma más simple, la de elegir entre dos alternativas. La sintaxis de seudocódigo
más usada de esta instrucción es

Cuando un programa en ejecución encuentra la instrucción if, la condición es evaluada para determinar su valor
numérico, el cual es interpretado entonces como verdadero o falso. Si la condición produce cualquier valor
YMR

numérico positivo o negativo diferente de cero, la condición es considerada como una condición “verdadera” y se
ejecuta la instrucción que sigue a if. Si la condición produce un valor numérico de cero, la condición es considerada
como una condición “falsa” y se ejecuta la instrucción que sigue a else. La parte else de la instrucción es opcional y
puede omitirse. La condición usada en una instrucción if puede ser cualquier expresión válida de C++ (incluyendo,
como se verá, una expresión de asignación). Las expresiones más usadas por lo común, sin embargo, se llaman
expresiones relacionales. Una expresión relacional simple consiste en un operador relacional que compara dos
operandos.

Mientras cada operando en una expresión relacional puede ser una variable o una constante, los operadores
relacionales deben ser uno de los expuestos. Estos operadores relacionales pueden usarse con operados de
números enteros, de punto flotante, de precisión doble o de carácter, pero deben escribirse con exactitud como se
muestran a continuación Por tanto, mientras todos los siguientes ejemplos son válidos:

Los siguientes son inválidos:

Programa___ Realizar un programa que realice el cálculo del IMC, y que indique si una persona es delgada,
normal u obesa.
YMR

Programa___ Realizar un programa en c++ que indique si la calificación de un alumno es en el alfabeto, de

acuerdo con la siguiente imagen, utilizando el promedio de 5 calificaciones continuas, donde la escala es de 0 a
100

Programa____ Realizar un programa para un cine, en donde el costo del boleto es de $90 pesos, y tienen varias
promociones si se compran mas de 4 boletos se le aplicara un descuento del 15%, pero si son mas de 6 boletos se
aplicara el 25%, el programa debe imprimir el coto total con descuento aplicado.

Estructura de selección Múltiple

La cadena if-else se usa en aplicaciones de programación donde un conjunto de instrucciones debe ser seleccionada
entre muchas alternativas posibles. La instrucción switch proporciona una alternativa a la cadena if-else para casos
que comparan el valor de una expresión de número entero con un valor específico. La forma general de una
instrucción switch es:
YMR

La instrucción switch usa cuatro palabras clave nuevas: switch, case, break y default. Veamos lo que hace cada una
de estas palabras.
La palabra clave switch identifica el inicio de la instrucción switch. La expresión entre paréntesis que sigue a la
palabra es evaluada y el resultado de la expresión comparado con diversos valores alternativos contenidos dentro
de la instrucción compuesta. La expresión en la instrucción switch debe evaluar un resultado en número entero o
resultará un error de compilación.

Dentro de la instrucción switch, la palabra clave case se usa para identificar o etiquetar valores individuales que se
comparan con el valor de la expresión switch. El valor de la expresión switch se compara con cada uno de estos
valores case en el orden en que se enlistan estos valores hasta que se encuentra una correspondencia. Cuando los
valores corresponden, la ejecución comienza con la instrucción que sigue inmediatamente a la correspondencia. Por
tanto, el valor de la expresión determina en qué parte de la instrucción switch comienza en realidad la ejecución.

Una instrucción switch puede contener cualquier número de etiquetas case, en cualquier orden. Sin embargo, si el
valor de la expresión no corresponde con ninguno de los valores case, no se ejecuta ninguna instrucción a menos
que se encuentre la palabra clave default. La palabra default es opcional y opera igual que la última else en una
cadena if-else. Si el valor de la expresión no corresponde con ninguno de los valores case, la ejecución del programa
comienza con la instrucción que sigue a la palabra default. Una vez que la instrucción switch ha localizado un punto
de entrada, todas las demás evaluaciones case son ignoradas y la ejecución continúa hasta el final de la instrucción
compuesta a menos que se encuentre una instrucción break. Ésta es la razón por la que la instrucción break, la cual
identifica el fin de un case particular y causa una salida inmediata de la instrucción switch. Por tanto, del mismo
modo en que la palabra case identifica los puntos de partida posibles en la instrucción compuesta, la instrucción
break determina puntos de terminación. Si se omiten las instrucciones break, se ejecutan todos los casos que
siguen al valor case que tiene la correspondencia, incluyendo el caso default.
YMR

Ejemplo de un programa con la sentencia SWITCH

Programa _____ Hacer un programa en C++ que ayude a una empresa a incrementar los salarios de los
trabajadores de la siguiente manera:
Tipo de salario %
De 0 a $9 000 20%
De $9 000 a $15 000 10%
De $15 000 a $20 000 5%
Más de $20 000 3%

Programa_______ Realizar una calculadora científica con la estructura de control switch.

YMR

Programa_______ Realizar un programa para un kínder donde se pida un número del 1 al 7 y diga el día de la
semana correspondiente.
Una vez verificando el día de la semana
1.-Los lunes se realizarán clases de matemáticas sencillas.
2.-Los martes se realizarán clases de inglés donde se enseñarán tres palabras básicas: Hola, adiós, Buenos días.
3.-Los miércoles Deportes y se verificará el rendimiento de un niño en su competencia
4.-Los jueves Salud personal se verificará si los dientes están limpios o no
5.-Los viernes Cine, se harán descuentos si van mas de 5 niños al cine.

Programa_______ Realizar un programa para control escolar de una secundaria, donde se pueda acceder como
profesor, alumno y padre de familia. El programa es libre, en las acciones de cada tipo de usuario.

Ciclos

El poder real de un programa se demuestra cuando debe hacerse una y otra vez el mismo tipo de
operación. Volver a escribir el mismo conjunto de instrucciones es tedioso, consume tiempo y está sujeto
a errores. Por supuesto que sería conveniente si pudiéramos escribir esas instrucciones repetitivas sólo
una vez y luego implementar un método para informar al programa que repita la ejecución de las
instrucciones tres veces.
Dicho método está disponible usando secciones de código repetitivas.
YMR

Construir una sección de código repetitiva requiere que estén presentes cuatro elementos. El primer
elemento necesario es una instrucción de repetición. Esta instrucción de repetición define los límites que
contienen la sección de código repetitiva y controla si el código se ejecutará o no.

En general, hay tres formas diferentes de instrucciones de repetición, todas las cuales son proporcionadas
en C++:
1. while
2. for
3. do – while

Cada una de estas instrucciones requiere una condición que debe evaluarse, la cual es el segundo
elemento requerido para construir secciones de código repetitivas. Las condiciones válidas son idénticas a
las usadas en las instrucciones de selección. Si la condición es verdadera, el código es ejecutado; de lo
contrario, no lo es.

El tercer elemento requerido es una instrucción que establece la condición al inicio. Esta instrucción debe
colocarse siempre antes que la condición sea evaluada por primera vez para asegurar la ejecución
correcta del ciclo. Por último, debe haber una instrucción dentro de la sección de código repetitiva que
permita que la condición se vuelva falsa. Esto es necesario para asegurar que, en algún punto, se
detengan las repeticiones
YMR

While

Ejemplo de un programa While con anidación de un if

En C++, un ciclo while se construye usando una instrucción while. La sintaxis de esta instrucción es

La expresión contenida dentro del paréntesis es la condición probada para determinar si se ejecuta la instrucción
que sigue al paréntesis. La expresión es evaluada exactamente en la misma manera que la contenida en una
instrucción if-else; la diferencia está en cómo se usa la expresión. Como se ha visto, cuando la expresión es
verdadera (tiene un valor diferente de cero) en una instrucción if-else, la instrucción que sigue a la expresión se
ejecuta una vez. En una instrucción while, la instrucción que sigue a la expresión se ejecuta en forma repetida hasta
que la expresión reconozca un valor diferente de cero. Considerando sólo la expresión y la instrucción que sigue al
paréntesis, el proceso usado por la computadora al evaluar una instrucción while es:
YMR

Programa_______ Realizar un programa con el ciclo while, donde pida un numero e imprima la tabla de
multiplicar para ese numero del 1 al 10.
YMR

Programa_______ Realizar un programa con un menú, donde se realicen las siguientes opciones
1.-Muestre los primeros 100 números enteros iniciando desde 1
2.-Los primeros 100 números de forma inversa de 100 a 1
3.-Que muestre los pares en un rango del 1 al 100
4.-Que muestre la suma de los números impares del 1 al 100
5.-Que muestre la suma de los números del 1 al 100

DO-While

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

En efecto los ciclos while, son bastante útiles, sin embargo, desde el punto de vista de la eficiencia al igual
que con los ciclos for, es recomendable evitarlos en la medida de lo posible, siempre que vayas a usar un
ciclo while o cualquier tipo de ciclo en realidad, deberías preguntarte primero si es totalmente necesario
o si existe una manera más efectiva de hacerlo. Evidentemente habrá situaciones en las que será casi que
imprescindible usar el ciclo, pues por algo existen, esta entonces en nuestra habilidad determinar cuándo
usarlos y mejor aún como usarlos de manera efectiva.
YMR

Declarando funciones en C++

La sintaxis para declarar una función es muy simple, veamos:

tipo nombreFuncion([tipo nombreArgumento,[tipo nombreArgumento]...])

{
/*
* Bloque de instrucciones
*/

return valor;
}
Recordemos que una función siempre retorna algo, por lo tanto es obligatorio declararle un tipo (el primer
componente de la sintaxis anterior), luego debemos darle un nombre a dicha función, para poder identificarla y
llamarla durante la ejecución, después al interior de paréntesis, podemos poner los argumentos o parámetros.
Luego de la definición de la "firma" de la función, se define su funcionamiento entre llaves; todo lo que esté dentro
de las llaves es parte del cuerpo de la función y éste se ejecuta hasta llegar a la instrucción return.

Acerca de los argumentos o parámetros

Hay algunos detalles respecto a los argumentos de una función, veamos:

Una función o procedimiento pueden tener una cantidad cualquier de parámetros, es decir pueden tener cero, uno,
tres, diez, cien o más parámetros. Aunque habitualmente no suelen tener más de 4 o 5.
Si una función tiene más de un parámetro cada uno de ellos debe ir separado por una coma.
Los argumentos de una función también tienen un tipo y un nombre que los identifica. El tipo del argumento puede
ser cualquiera y no tiene relación con el tipo de la función.
Consejos acerca de return
Debes tener en cuenta dos cosas importantes con la sentencia return:

Cualquier instrucción que se encuentre después de la ejecución de return NO será ejecutada. Es común encontrar
funciones con múltiples sentencias return al interior de condicionales, pero una vez que el código ejecuta una
sentencia return lo que haya de allí hacia abajo no se ejecutará.
El tipo del valor que se retorna en una función debe coincidir con el del tipo declarado a la función, es decir si se
declara int, el valor retornado debe ser un número entero.
Veamos algunos ejemplos.

Ejemplos de funciones
Veamos algunos ejemplos prácticos de funciones en C++.

Ejemplo 1:

int funcionEntera()//Función sin parámetros

{
int suma = 5+5;
YMR

return suma; //Acá termina la ejecución de la función

return 5+5;//Este return nunca se ejecutará
//Intenta intercambiar la línea 3 con la 5
int x = 10; //Esta línea nunca se ejecutará
}

Como puedes ver es un ejemplo sencillo, si ejecutas esto, la función te retornará el valor de suma que es 10 (5+5).
Las líneas posteriores no se ejecutarán nunca, aunque no generan error alguno, no tienen utilidad. Puedes notar que
para este caso es lo mismo haber escrito return suma que escribir return 5+5. Ambas líneas funcionan
equivalentemente.

Ejemplo 2
char funcionChar(int n)//Función con un parámetro
{
if(n == 0)//Usamos el parámetro en la función
{
return 'a'; //Si n es cero retorna a
//Notar que de aquí para abajo no se ejecuta nada más
}
return 'x';//Este return sólo se ejecuta cuando n NO es cero
}

Aquí hicimos uso se múltiples sentencia return y aprovechamos la característica de que al ser ejecutadas finalizan
inmediatamente la ejecución de la parte restante de la función. De este modo podemos asegurar que la función
retornará 'a' únicamente cuando el valor del parámetro n sea cero y retornará un 'x' cuando dicho valor no sea cero.

bool funcionBool(int n, string mensaje)//Función con dos parámetros

{
if(n == 0)//Usamos el parámetro en la función
{
cout << mensaje;//Mostramos el mensaje
return 1; //Si n es cero retorna 1
return true;//Equivalente
}
return 0;//Este return sólo se ejecuta cuando n NO es cero
return false;//Equivalente
}

Aquí ya tenemos una función que recibe dos parámetros, uno de ellos es usado en el condicional y el otro para
mostrar su valor por pantalla con cout, esta vez retornamos valores booleanos 0 y 1, pudo ser true o false también.

Procedimeintos:

Los procedimientos son similares a las funciones, aunque más resumidos. Debido a que los procedimientos no
retornan valores, no hacen uso de la sentencia return para devolver valores y no tienen tipo específico, solo void.
Veamos un ejemplo:

void procedimiento(int n, string nombre)

{
if(n == 0)
YMR

{
cout << "hola" << nombre;
return;
}
cout << "adios" << nombre;
}

De este ejemplo podemos ver que ya no se usa un tipo sino que se pone void, indicando que no retorna valores,
también podemos ver que un procedimiento también puede recibir parámetros o argumentos.
Atención: Los procedimientos también pueden usar la sentencia return, pero no con un valor. En los procedimientos
el return sólo se utiliza para finalizar allí la ejecución de la función.

Invocando funciones y procedimientos en C++

Ya hemos visto cómo se crean y cómo se ejecutan las funciones en C++, ahora veamos cómo hacemos uso de ellas.

nombreFuncion([valor,[valor]...]);

Como puedes notar es bastante sencillo invocar o llamar funciones en C++ (de hecho en cualquier lenguaje actual),
sólo necesitas el nombre de la función y enviarle el valor de los parámetros. Hay que hacer algunas salvedades
respecto a esto.

Detalles para invocar funciones

El nombre de la función debe coincidir exactamente al momento de invocarla.

El orden de los parámetros y el tipo debe coincidir. Hay que ser cuidadosos al momento de enviar los parámetros,
debemos hacerlo en el mismo orden en el que fueron declarados y deben ser del mismo tipo (número, texto u
otros).
Cada parámetro enviado también va separado por comas.
Si una función no recibe parámetros, simplemente no ponemos nada al interior de los paréntesis, pero SIEMPRE
debemos poner los paréntesis.
Invocar una función sigue siendo una sentencia habitual de C++, así que ésta debe finalizar con ';' como siempre.
El valor retornado por una función puede ser asignado a una variable del mismo tipo.
Una función puede llamar a otra dentro de sí misma o incluso puede ser enviada como parámetro a otra.

Ejemplo de Funciones
En el siguiente código vamos a hacer un llamado a algunas de las funciones y al procedimiento, que declaramos
anteriormente.

int main()
{
funcionEntera(); //Llamando a una función sin argumentos

bool respuesta = funcionBool(1, "hola"); //Asignando el valor retornado a una variable

procedimiento(0, "Juan");//Invocando el procedimiento

//Usando una función como parámetro

procedimiento(funcionBool(1, "hola"), "Juan");

return 0;
}
YMR

En el código anterior podemos ver cómo todas las funciones han sido invocadas al interior de la función main (la
función principal), esto nos demuestra que podemos hacer uso de funciones al interior de otras. También vemos
cómo se asigna el valor retornado por la función a la variable 'respuesta' y finalmente, antes del return, vemos cómo
hemos usado el valor retornado por 'funcionBool' como parámetro del procedimiento.

Programas:

Realice un programa en C++ que muestre un menú con las 4 opciones siguientes:
1. Area de un Triangulo equilatero
2. Area de un Rombo (basado en las medidas de su diagonal mayor y diagonal menor)
3. Volumen de un cubo.
4. Salir
Para cada una de las 3 primeras opciones del menú anterior, debe crear una función diferente para resolver el
cálculo correspondiente.
Restricciones:
• Cada una de las funciones debe borrar el contenido de la pantalla y solicitar los datos apropiados al
usuario según la medida elegida en el menu, asi como mostrar la respuesta.
• Luego que usuario seleccione una opcion y se le muestre la respuesta, debe limpiarse la pantalla y mostrar
de nuevo el menu inicial.
• El usuario no podrá salir del programa hasta que haya selecciona