├── .gitignore ├── README.md ├── completo.md ├── curso ├── pdf │ ├── presentacion1.pdf │ ├── presentacion2.pdf │ └── presentacion3.pdf ├── u01 │ ├── README.md │ └── u01.pdf ├── u02 │ ├── README.md │ └── u02.pdf ├── u03 │ ├── README.md │ └── u03.pdf ├── u04 │ └── README.md ├── u05 │ └── README.md ├── u06 │ ├── README.md │ └── img │ │ ├── zinjai1.png │ │ ├── zinjai2.png │ │ ├── zinjai3.png │ │ ├── zinjai4.png │ │ └── zinjai5.png ├── u07 │ └── README.md ├── u08 │ └── README.md ├── u09 │ └── README.md ├── u10 │ └── README.md ├── u11 │ └── README.md ├── u12 │ └── README.md ├── u13 │ └── README.md ├── u14 │ └── README.md ├── u15 │ └── README.md ├── u16 │ ├── README.md │ └── img │ │ ├── si.png │ │ └── sidoble.png ├── u17 │ ├── README.md │ └── img │ │ └── segun.png ├── u18 │ └── README.md ├── u19 │ ├── README.md │ └── img │ │ └── mientras.png ├── u20 │ ├── README.md │ └── img │ │ └── repetir.png ├── u21 │ ├── README.md │ └── img │ │ └── para.png ├── u22 │ └── README.md ├── u23 │ └── README.md ├── u24 │ └── README.md ├── u25 │ └── README.md ├── u26 │ └── README.md ├── u27 │ └── README.md ├── u28 │ └── README.md ├── u29 │ └── README.md ├── u30 │ └── README.md ├── u31 │ ├── README.md │ └── img │ │ ├── enteros.png │ │ ├── operadores.png │ │ └── variable.png ├── u32 │ ├── README.md │ └── img │ │ └── puntero.png ├── u33 │ └── README.md ├── u34 │ └── README.md ├── u35 │ └── README.md ├── u36 │ └── README.md ├── u37 │ └── README.md ├── u38 │ └── README.md ├── u39 │ └── README.md ├── u40 │ ├── README.md │ └── punto.cpp ├── u41 │ └── README.md ├── u42 │ ├── README.md │ ├── circulo.cpp │ └── punto3d.cpp └── u43 │ └── README.md ├── curso1.md ├── curso2.md ├── curso3.md ├── ejercicios ├── alternativas │ ├── ejercicio1.cpp │ ├── ejercicio10.cpp │ ├── ejercicio11.cpp │ ├── ejercicio12.cpp │ ├── ejercicio13.cpp │ ├── ejercicio14.cpp │ ├── ejercicio15.cpp │ ├── ejercicio16.cpp │ ├── ejercicio17.cpp │ ├── ejercicio18.cpp │ ├── ejercicio19.cpp │ ├── ejercicio2.cpp │ ├── ejercicio20.cpp │ ├── ejercicio3.cpp │ ├── ejercicio4.cpp │ ├── ejercicio5.cpp │ ├── ejercicio6.cpp │ ├── ejercicio7.cpp │ ├── ejercicio8.cpp │ └── ejercicio9.cpp ├── arrays │ ├── ejercicio1.cpp │ ├── ejercicio10.cpp │ ├── ejercicio11.cpp │ ├── ejercicio12.cpp │ ├── ejercicio13.cpp │ ├── ejercicio14.cpp │ ├── ejercicio15.cpp │ ├── ejercicio2.cpp │ ├── ejercicio3.cpp │ ├── ejercicio4.cpp │ ├── ejercicio5.cpp │ ├── ejercicio6.cpp │ ├── ejercicio7.cpp │ ├── ejercicio8.cpp │ └── ejercicio9.cpp ├── cadenas │ ├── ejercicio1.cpp │ ├── ejercicio10.cpp │ ├── ejercicio2.cpp │ ├── ejercicio3_con_find.cpp │ ├── ejercicio3_con_recorrido.cpp │ ├── ejercicio4.cpp │ ├── ejercicio5.cpp │ ├── ejercicio6.cpp │ ├── ejercicio7.cpp │ ├── ejercicio8.cpp │ └── ejercicio9.cpp ├── funciones │ ├── ejercicio1.cpp │ ├── ejercicio10.cpp │ ├── ejercicio11.cpp │ ├── ejercicio12.cpp │ ├── ejercicio13.cpp │ ├── ejercicio14.cpp │ ├── ejercicio15.cpp │ ├── ejercicio2.cpp │ ├── ejercicio3.cpp │ ├── ejercicio4.cpp │ ├── ejercicio5.cpp │ ├── ejercicio6.cpp │ ├── ejercicio7.cpp │ ├── ejercicio8.cpp │ └── ejercicio9.cpp ├── mas_ejercicios │ ├── ejercicio1.cpp │ ├── ejercicio10.cpp │ ├── ejercicio2.cpp │ ├── ejercicio3.cpp │ ├── ejercicio4.cpp │ ├── ejercicio5.cpp │ ├── ejercicio6.cpp │ ├── ejercicio7.cpp │ ├── ejercicio8.cpp │ └── ejercicio9.cpp ├── objetos │ ├── ejercicio1.cpp │ ├── ejercicio2.cpp │ └── ejercicio3.cpp ├── repetitivas │ ├── ejercicio10.cpp │ ├── ejercicio11.cpp │ ├── ejercicio12.cpp │ ├── ejercicio13.cpp │ ├── ejercicio14.cpp │ ├── ejercicio15.cpp │ ├── ejercicio16.cpp │ ├── ejercicio17.cpp │ ├── ejercicio18.cpp │ ├── ejercicio19.cpp │ ├── ejercicio1_con_for.cpp │ ├── ejercicio1_con_while.cpp │ ├── ejercicio2.cpp │ ├── ejercicio20.cpp │ ├── ejercicio3_con_do.cpp │ ├── ejercicio3_con_while.cpp │ ├── ejercicio4.cpp │ ├── ejercicio5_con_repetir.cpp │ ├── ejercicio5_con_while.cpp │ ├── ejercicio6.cpp │ ├── ejercicio7.cpp │ ├── ejercicio8.cpp │ └── ejercicio9.cpp └── secuencial │ ├── ejercicio1.cpp │ ├── ejercicio10.cpp │ ├── ejercicio11.cpp │ ├── ejercicio12.cpp │ ├── ejercicio13.cpp │ ├── ejercicio14.cpp │ ├── ejercicio15.cpp │ ├── ejercicio16.cpp │ ├── ejercicio17.cpp │ ├── ejercicio18.cpp │ ├── ejercicio19.cpp │ ├── ejercicio2.cpp │ ├── ejercicio20.cpp │ ├── ejercicio3.cpp │ ├── ejercicio4.cpp │ ├── ejercicio5.cpp │ ├── ejercicio6.cpp │ ├── ejercicio7.cpp │ ├── ejercicio8.cpp │ └── ejercicio9.cpp ├── pildoras ├── Pildora_ Compiladores C++.pptx ├── Pildora_ Compilar C++ en Visual Code.pptx ├── Pildora_ Standard Template Library de C++.pptx ├── Pildora_ Tipos de datos en C++.pptx ├── README.md └── STL │ ├── iterador.cpp │ ├── map.cpp │ ├── ordenar.cpp │ └── verctor.cpp └── recursos.md /.gitignore: -------------------------------------------------------------------------------- 1 | *.bin 2 | *.swp 3 | *.psc 4 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Curso: Introducción a la programación con C++ 2 | 3 | * [Curso 1: Curso de C++: Introducción a C++](curso1.md) 4 | * [Curso 2: Curso de C++: Estructuras de control y tipos de datos](curso2.md) 5 | * [Curso 3: Curso de C++: Programación estructurada y orientación a objetos](curso3.md) 6 | 7 | 8 | * [Índice completo](completo.md) 9 | -------------------------------------------------------------------------------- /completo.md: -------------------------------------------------------------------------------- 1 | # Curso: Introducción a la programación con C++ 2 | 3 | ## Introducción a la programación 4 | 5 | 1. [Análisis de problemas y diseño de algoritmos](curso/u01) 6 | 2. [Introducción a los lenguajes de programación](curso/u02) 7 | 3. [Introducción a C++](curso/u03) 8 | 9 | ## Introducción a C++ 10 | 11 | 4. [Instalación del IDE Zinjai](curso/u04) 12 | 5. [Estructura del programa](curso/u05) 13 | 6. [Compilación y ejecución de programas](curso/u06) 14 | 15 | ## Tipos de datos básicos 16 | 17 | 7. [Datos y tipos de datos](curso/u07) 18 | 8. [Literales y constantes](curso/u08) 19 | 9. [Variables. Operadores de asignación.](curso/u09) 20 | 10. [Tipos de datos numéricos. Operadores aritméticos](curso/u10) 21 | 11. [Introducción a las cadenas de caracteres](curso/u11) 22 | 12. [Entrada y salida estándar](curso/u12) 23 | 13. [Pasando de pseudocódigo a C++](curso/u13) 24 | 14. [Ejercicios estructura secuencial](curso/u14) 25 | 26 | ## Estructuras alternativas 27 | 28 | 15. [Tipo de datos booleano. Operadores relacionales y lógicos](curso/u15) 29 | 16. [Estructuras alternativas: if](curso/u16) 30 | 17. [Estructuras alternativas: switch](curso/u17) 31 | 18. [Ejercicios estructuras alternativas](curso/u18) 32 | 33 | ## Estructuras repetitivas 34 | 35 | 19. [Estructuras repetitivas: while](curso/u19) 36 | 20. [Estructuras repetitivas: do-while](curso/u20) 37 | 21. [Estructuras repetitivas: for](curso/u21) 38 | 22. [Uso específico de variables: contadores, acumuladores e indicadores](curso/u22) 39 | 23. [Ejercicios estructuras repetitivas](curso/u23) 40 | 41 | ## Cadenas de caracteres 42 | 43 | 24. [Cadenas de caracteres con la clase string](curso/u24) 44 | 25. [Ejercicios cadenas de caracteres](curso/u25) 45 | 46 | ## Tipos de datos complejos: Arrays 47 | 48 | 26. [Introducción a los arrays](curso/u26) 49 | 27. [Arrays unidimensionales: Vectores](curso/u27) 50 | 28. [Cadenas de caracteres estilo C](curso/u28) 51 | 29. [Arrays multidimensionales: Tablas](curso/u29) 52 | 30. [Ejercicios de Arrays](curso/u30) 53 | 54 | ## Punteros y estructuras 55 | 56 | 31. [Introducción a los punteros (I)](curso/u31) 57 | 32. [Introducción a los punteros (II)](curso/u32) 58 | 33. [Introducción a las referencias en C++](curso/u33) 59 | 34. [Tipos de datos complejos: estructuras](curso/u34) 60 | 61 | ## Programación estructurada 62 | 63 | 35. [Programación estructurada](curso/u35) 64 | 36. [Funciones y procedimientos](curso/u36) 65 | 37. [Funciones recursivas](curso/u37) 66 | 38. [Ejercicios con funciones](curso/u38) 67 | 39. [Más ejercicios](curso/u39) 68 | 69 | ## Programación orientada a objetos 70 | 71 | 40. [Introducción a la programación orientada a objetos](curso/u40) 72 | 41. [Encapsulamiento en la programación orientada a objetos](curso/u41) 73 | 42. [Herencia y delegación](curso/u42) 74 | 43. [Ejercicios de programación orientada a objetos](curso/u43) 75 | 76 | 77 | 78 | -------------------------------------------------------------------------------- /curso/pdf/presentacion1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/curso/pdf/presentacion1.pdf -------------------------------------------------------------------------------- /curso/pdf/presentacion2.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/curso/pdf/presentacion2.pdf -------------------------------------------------------------------------------- /curso/pdf/presentacion3.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/curso/pdf/presentacion3.pdf -------------------------------------------------------------------------------- /curso/u01/README.md: -------------------------------------------------------------------------------- 1 | # Análisis de problemas y diseño de algoritmos 2 | 3 | Un **programador** es una persona que resuelve problemas, y para llegar a ser un programador eficaz se **necesita aprender a resolver problemas de un modo riguroso y sistemático**: 4 | 5 | * *Definición o análisis del problema*: consiste en el estudio detallado del problema. Se debe identificar los datos de entrada, de salida y la descripción del problema. 6 | * *Diseño del algoritmo*: que describe la secuencia ordenada de pasos que conduce a la solución de un problema dado: **algoritmo**. 7 | * *Transformación del algoritmo en un programa (codificación)*: Se expresa el algoritmo como un programa en un **lenguaje de programación**. 8 | * *Ejecución y validación del programa*. 9 | 10 | ## Análisis del problema 11 | 12 | El primer paso, análisis del problema, requiere un estudio a fondo del problema y de todo lo que hace falta para poder abordarlo. 13 | 14 | El propósito del análisis de un problema es ayudar al programador (Analista) para llegar a una cierta comprensión de la naturaleza del problema. Una buena definición del problema, junto con una descripción detallada de las especificaciones de entrada/salida, son los requisitos más importantes para llegar a una solución eficaz. 15 | 16 | Para realizar el análisis del problema realizamos varios pasos: 17 | 18 | * **Definición del problema**: Tenemos que entender y comprender la naturaleza del problema, tenemos que dominar los conceptos con los que estamos trabajando y conocer que operaciones hay que realizar para solucionar el problema y obtener la información de salida. 19 | * **Especificación de los datos de entrada**: Hay que determinar que datos de entrada necesitamos para resolver el problema. 20 | * **Especificación de los datos de salida**: También hay que determinar los datos de salida que van a ofrecer la solución del problema. 21 | 22 | ## Diseño de algoritmos 23 | 24 | A partir de los requerimientos, resultados del análisis, empieza la etapa de **diseño** donde tenemos que construir un **algoritmo** que resuelva el problema. 25 | 26 | ### Definición de algoritmo 27 | 28 | Un **algoritmo** es un conjunto de acciones que especifican la secuencia de operaciones realizar, en orden, para resolver un problema. 29 | 30 | Los algoritmos son independientes tanto del lenguaje de programación como del ordenador que los ejecuta. 31 | 32 | Las características de los algoritmos son: 33 | 34 | * Un algoritmo debe ser preciso e indicar el orden de realización de cada paso. 35 | * Un algoritmo debe estar definido. Si se sigue un algoritmo dos veces, se debe 36 | obtener el mismo resultado cada vez. 37 | * Un algoritmo debe ser finito. Si se sigue un algoritmo, se debe terminar en 38 | algún momento; o sea, debe tener un número finito de pasos. 39 | 40 | ### Herramientas de representación de algoritmos 41 | 42 | * Un **diagrama de flujo** es una de las técnicas de representación gráfica de 43 | algoritmos más antiguas. Ventajas: permite altos niveles de estructuración y modularización y es fácil de usar. Desventajas: son difíciles de actualizar y se complican cuando el algoritmo es grande. 44 | * El **pseudocódigo**, nos permite una aproximación del algoritmo al lenguaje natural y por tanto un a redacción rápida del mismo. 45 | -------------------------------------------------------------------------------- /curso/u01/u01.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/curso/u01/u01.pdf -------------------------------------------------------------------------------- /curso/u02/README.md: -------------------------------------------------------------------------------- 1 | # Introducción a los lenguajes de programación 2 | 3 | Para que un ordenador realice un proceso, se le debe suministrar en primer lugar un algoritmo adecuado, que llamamos **programa**. El procesador debe ser capaz de interpretar el algoritmo, lo que significa: 4 | 5 | * Comprender las instrucciones de cada paso. 6 | * Realizar las operaciones correspondientes. 7 | 8 | ## Clasificación de los lenguajes de programación 9 | 10 | ### Lenguaje Máquina 11 | 12 | Son aquellos que están escritos en lenguajes que directamente entiende el ordenador, ya que sus instrucciones son cadenas binarias (secuencias de 13 | ceros y unos) que especifican una operación y las posiciones (dirección) de memoria implicadas en la operación. Se denominan instrucciones de máquina o **código máquina**. Características: 14 | 15 | * Las instrucciones en lenguaje máquina dependen del hardware del ordenador y por tanto serán diferentes de un ordenador a otro. 16 | * Se puede transferir un programa a memoria sin necesidad de traducción posterior, lo que supone una mayor velocidad de ejecución a cualquier otro lenguaje. 17 | * Dificultad y lentitud en la codificación. 18 | * Conjunto de instrucciones reducido (operaciones muy elementales) 19 | 20 | ### Lenguaje de bajo nivel (Ensamblador) 21 | 22 | Los lenguajes de bajo nivel son más fáciles de utilizar que los lenguajes máquina, pero, al igual que ellos, dependen de la máquina en particular. 23 | El lenguaje de bajo nivel por excelencia es el **ensamblador**. 24 | 25 | Las instrucciones en lenguaje ensamblador son instrucciones conocidas como mnemónicos. 26 | 27 | Un programa escrito en lenguaje ensamblador no puede ser ejecutado directamente por la máquina, sino que requiere una fase de traducción al lenguaje máquina. El programa original escrito en lenguaje ensamblador se denomina **programa fuente** y el programa traducido en lenguaje máquina se conoce como **programa objeto**, ya directamente entendible por el ordenador. 28 | 29 | ### Lenguaje de alto nivel 30 | 31 | Los lenguajes de alto nivel son los mas utilizados por los programadores. Están diseñados para que las personas escriban y entiendan los programas de un modo mucho más fácil que los lenguajes máquina y ensambladores. Otra razón es que un programa escrito en un lenguaje de alto nivel es independiente de la máquina, o sea, las instrucciones del programa del ordenador no dependen del diseño hardware de un ordenador en particular. Por lo tanto los programas escritos en lenguajes de alto nivel son portables o transportables, lo que significa la posibilidad de poder ser ejecutados con poca o ninguna modificación en diferentes tipos de ordenadores. 32 | 33 | Al igual que sucede con los lenguajes ensambladores, los programas fuente tienen que ser traducidos por **programas traductores**, llamados en este caso 34 | compiladores o intérpretes. 35 | 36 | Ejemplos de lenguajes de programación de alto nivel: 37 | 38 | BASIC, COBOL, PASCAL, C, VISUAL BASIC, JAVA, PYTHON, PERL, GO, PHP, RUBY,... 39 | 40 | ## Programas traductores 41 | 42 | Los traductores transforman programas escritos en un lenguaje de alto nivel en programas escritos en código máquina. Podemos indicar distintos tipos: 43 | 44 | ### Compiladores 45 | 46 | * Convierte un programa escrito en alto nivel (código fuente) a un programa máquina (código ejecutable). 47 | * Para generar el código ejecutable el código no debe tener errores de sintaxis. 48 | * Necesitamos un compilador para cada arquitectura y sistema operativo. 49 | * Los programas ejecutables no son compatibles entre plataformas. 50 | * Una vez generado el programa ejecutable, no es necesario tener el código fuente. 51 | * Ejemplos: C, Pascal,... 52 | 53 | ### Interpretes 54 | 55 | * La traducción y ejecución de código fuente a código máquina se hace línea por línea. 56 | * Los errores de sintaxis aparecen cuando se interpreta la instrucción con error. 57 | * Necesitamos el código fuente para ejecutar el programa. 58 | * Los lenguajes interpretados suelen ser más lentos en su ejecución 59 | * Ejemplos: Python, PHP, ... 60 | 61 | ### Máquina virtual 62 | 63 | * La traducción se hace en dos pasos. 64 | * Primero se compila el código fuente a un código intermedio (bytecode). 65 | * Segundo, este bytecode se interpreta y ejecuta por una "máquina virtual". 66 | * El bytecode es multiplataforma. 67 | * Necesito una "máquina virtual" para cada plataforma. 68 | * No necesito el código fuente. 69 | * Ejemplo: Java, C#, ... 70 | -------------------------------------------------------------------------------- /curso/u02/u02.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/curso/u02/u02.pdf -------------------------------------------------------------------------------- /curso/u03/README.md: -------------------------------------------------------------------------------- 1 | # Introducción a C++ 2 | 3 | * **C++** es un lenguaje de programación diseñado en 1979 por Bjarne Stroustrup. Para su creación se tomó como base un lenguaje de programación popular en aquella época el cual era C. 4 | 5 | * Por lo tanto, C++ es un derivado del mítico lenguaje C, el cual fue creado en la década de los 70 por la mano Dennis Ritchie para la programación del sistema operativo Unix (un sistema parecido a Unix es GNU/Linux), el cual surgió como un lenguaje orientado a la programación de sistemas y aplicaciones siendo su principal característica la eficiencia del código que produce. 6 | 7 | * La expresión "C++" significa "incremento de C" y se refiere a que C++ es una extensión de C. 8 | 9 | * C++ añade otro paradigma de programación a C: **la Programación Orientada a Objetos**, que nos permite ampliar los tipos de datos que podemos usar, definiendo clases y objetos. 10 | 11 | * C++ es un lenguaje de programación compilado. Utilizaremos un compilador que convertirá nuestro programa (código fuente) en un programa ejecutable. Existen compiladores de C++ para las distintas plataformas y sistemas operativos. 12 | 13 | * Para escribir un programa en C++ necesitamos un editor de texto (para escribir el código fuente) y un compilador para la plataforma y sistema operativo que estemos utilizando. Normalmente estas herramientas se unifican en los Entornos Integrados de Desarrollo (IDE) que son aplicaciones que nos ofrecen en un mismo programa distintas funcionalidades (editor de texto, compilador,...). 14 | 15 | * Algunos ejemplos de IDE que podemos usar: Visual Studio Code, Dev-C++, Visual C++, Zinjai, Eclipse, ... 16 | 17 | * Durante los últimos años se han estandarizados distintas versiones de C++ donde se han ido añadiendo nuevas funcionalidades al lenguaje. Estas versiones se nombran con el año en que son publicadas, de esta manera tenemos: C++98, C++03, C++11, C++14, C++17 (versión estable actual), C++20 (versión en desarrollo). 18 | 19 | * Podemos indicar como características fundamentales de C++: 20 | 21 | * Su sintaxis es heredada del lenguaje C. 22 | * Programa orientado a objetos (POO). 23 | * Lenguaje muy didáctico, con este lenguaje puedes aprender muchos otros lenguaje con gran facilidad. 24 | * Es portable y tiene un gran número de compiladores en diferentes plataformas y sistemas operativos. 25 | * Permite la separación de un programa en módulos que admiten compilación independiente. 26 | * Es un lenguaje de alto nivel. 27 | 28 | -------------------------------------------------------------------------------- /curso/u03/u03.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/curso/u03/u03.pdf -------------------------------------------------------------------------------- /curso/u04/README.md: -------------------------------------------------------------------------------- 1 | # Instalación del IDE Zinjai 2 | 3 | *ZinjaI* es un IDE (entorno de desarrollo integrado) libre y gratuito para programar en C/C++. Pensado originalmente para ser utilizado por estudiantes de programación durante el aprendizaje, presenta una interfaz inicial muy sencilla, pero sin dejar de incluir funcionalidades avanzadas. puedes acceder al programa en su [página web](http://zinjai.sourceforge.net/). 4 | 5 | Un IDE (del inglés: Integrated Development Enviroment = Entorno Integrado de Desarrollo) incluye una interfaz visual que nos proporciona: 6 | 7 | * Un editor de texto, que nos permite editar el código del programa, y tiene distintas funcionalidades que nos permite trabajar con comodidad. 8 | * Un acceso al enlazador y compilador, que nos permite compilar y ejecutar el programa desde la misma interfaz. 9 | * Otras herramientas: por ejemplo un depurador. 10 | 11 | Puedes ver las [características](http://zinjai.sourceforge.net/index.php?page=features.php) de ZanjaI en su página web y en la sección de [descargas](http://zinjai.sourceforge.net/index.php?page=descargas.php) puedes encontrar el programa para las distintas plataformas e instrucciones de instalación. -------------------------------------------------------------------------------- /curso/u05/README.md: -------------------------------------------------------------------------------- 1 | # Estructura de un programa en C++ 2 | 3 | Veamos nuestro primer programa para estudiar su estructura: 4 | 5 | #include 6 | using namespace std; 7 | 8 | /* funcion main() 9 | Es la función donde empieza la ejecución */ 10 | 11 | int main() { 12 | cout << "Hola Mundo!!!"; // Imprime Hola Mundo 13 | return 0; 14 | } 15 | 16 | Veamos algunas elementos que forman parte de la estructura de un programa c++: 17 | 18 | * `#include ` con esta instrucción indicamos que vamos a utilizar la librería `iostream`. En esta librería están definida las funciones de entrada/salida, por ejemplo `cout`. 19 | * `using namespace std;`: Para que usemos el espacio de nombres estándar (`std`). Como podemos tener diferentes elementos en el lenguaje que se llamen igual se utiliza espacios de nombres para agruparlas. El espacio de nombres de las funciones de entrada / salida como `cout` o `cin` están definidos en el el espacio de nombres `std`, por lo tanto, si indicamos que vamos a usarlos no será necesario nombrarlo cuando escribamos las instrucciones. Si no indicamos que vamos a usar el espacio de nombres `std` la instrucción que escribe en pantalla quedaría de la siguiente forma: 20 | 21 | std::cout << "Hola Mundo!!!"; 22 | 23 | * `int main()`: Es la función principal del programa. Al ejecutar el programa son las instrucciones de esta función las que se empiezan a ejecutar. La función principal devuelve un valor entero (`int`) al sistema operativo. Si el programa va a tener parámetros en la línea de comandos, nos podemos encontrar esta función definida de esta manera: 24 | 25 | int main(int argc, char *argv[]) 26 | 27 | * `cout << "Hola Mundo!!!";`: Instrucción que imprime en pantalla. 28 | * `return 0;`: Como hemos dicho anteriormente la función `main()` devuelve un valor entero (0 si todo ha salido bien, distinto de 0 si se ha producido algún error). Esta instrucción devuelve el valor 0. 29 | * Los bloques de instrucciones se guardan entre los caracteres `{` y `}`. 30 | * Todas las instrucciones deben acabar en `;`. 31 | * En C++ podemos poner comentarios de una línea (utilizando los caracteres `//`) o comentarios de varias líneas (con los carácteres `/*` y `*/`). Todos los comentarios son ignorados por el compilador. 32 | * El lenguaje C++ distingue entre mayúsculas y minúsculas. Hay ciertas convenciones al nombrar, por ejemplo el nombre de las variables se suele poner siempre en minúsculas, mientras que el nombre de las constantes se suele poner en mayúsculas. 33 | -------------------------------------------------------------------------------- /curso/u06/README.md: -------------------------------------------------------------------------------- 1 | # Compilación y ejecución de programas 2 | 3 | Vamos a compilar y ejecutar nuestro primer programa en C++: 4 | 5 | #include 6 | using namespace std; 7 | 8 | /* funcion main() 9 | Es la función donde empieza la ejecución */ 10 | 11 | int main(int argc, char *argv[]) { 12 | cout << "Hola Mundo!!!"; // Imprime Hola Mundo 13 | return 0; 14 | } 15 | 16 | Para ello vamos a seguir los siguientes pasos: 17 | 18 | * **Paso 1**: Lo primero que debe hacer, es crear un nuevo programa. Para ello seleccione la opción `Nuevo...` del menú `Archivo` (o pulsando `CTRL + N`). 19 | 20 | Se desplegará inmediatamente el Asistente para Nuevo Archivo. Allí seleccione la opción `Utilizar Plantilla` y haga click en el botón `Continuar`: 21 | 22 | ![zinjai](img/zinjai1.png) 23 | 24 | A continuación elegimos la versión de C++ que vamos a usar, por ejemplo `Programa C++14 en blanco` y obtendremos un fichero con la estructura de nuestro programa: 25 | 26 | ![zinjai](img/zinjai2.png) 27 | 28 | * **Paso 2**: Escribimos el programa en el editor. Recuerda que el programa se puede guardar (Opción `Archivo` -> `Guardar` o `CTRL + S`) en un fichero en nuestro sistema de archivos con la extensión `cpp`. 29 | 30 | ![zinjai](img/zinjai3.png) 31 | 32 | * **Paso 3**: Para intentar ejecutar el programa presione `F9`, o seleccione la opción `Ejecutar` del menú `Ejecutar`. 33 | 34 | Esta acción guarda el archivo (si aún no tiene nombre la hará en un directorio temporal), lo compila, y si la compilación es exitosa lo ejecuta. Aparecerá en la parte inferior de la ventana principal el **Panel de Resultados del Compilador**, en el cual se muestra el estado de la compilación y los resultados de la misma. 35 | 36 | Si la compilación no tiene errores se ejecuta el programa y aparece una ventana de terminal donde vemos la ejecución. Luego de finalizar la ejecución,ZinjaI informará el código de retorno de su programa (el 0 de la línea final `return 0;`, el cual sirve para saber si se ejecutó correctamente) y esperará aque presione `enter` una vez más antes de cerrar la ventana, para permitirle observar los resultados. 37 | 38 | ![zinjai](img/zinjai4.png) 39 | 40 | Sin embargo si hemos tenido algún error pasamos al siguiente paso. 41 | 42 | * **Paso 4**: Si hemos cometido algún error, por ejemplo se nos ha olvidado un `;` al final de una instrucción, en el proceso de compilación obtendremos errores: 43 | 44 | Al hacer doble click sobre el error en el panel de compilación el cursor se desplaza hacia la linea que lo provocó. 45 | 46 | ![zinjai](img/zinjai5.png) 47 | 48 | Por lo tanto tenemos que corregir todos los errores sintácticos para que el proceso de compilación no nos de ningún error y se pueda ejecutar el programa. 49 | 50 | ## Atajos de teclado 51 | 52 | A continuación se listan algunas combinaciones de teclas para aprovechar mejor algunas facilidades de edición ZinjaI: 53 | 54 | * `F9`: Este atajo realiza todos los pasos necesarios para probar un programa (guardar, compilar y ejecutar). Si se presiona `Shift+F9`, se evita el último paso; es decir, sólo se compila. Esto sirve para saber si el código es sintácticamente correcto. 55 | * `Ctrl+<`: Si la compilación arroja errores o advertencias, con esta combinación se pueden recorrer los mismos. 56 | * `Ctrl+H`: Esta combinación busca la librería que contiene la declaración de una determinada clase, función, variable o macro e inserta al principio del archivo el #include que corresponda para poder utilizarla. 57 | * `Ctrl+L, Ctrl+Shift+L`: La primera duplica la linea actual o las líneas seleccionadas. Es útil en muchos casos en que el código incluye líneas casi idénticas, equivale a copiar y pegar esas líneas. La segunda combinación elimina la línea actual o las líneas seleccionadas. 58 | * `Ctrl+T, Ctrl+Shift+T`: estas combinaciones desplazan la línea actual o las líneas seleccionadas una posición más arriba en el código. Sirven para mover fragmentos de código lineas arriba o abajo. 59 | 60 | -------------------------------------------------------------------------------- /curso/u06/img/zinjai1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/curso/u06/img/zinjai1.png -------------------------------------------------------------------------------- /curso/u06/img/zinjai2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/curso/u06/img/zinjai2.png -------------------------------------------------------------------------------- /curso/u06/img/zinjai3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/curso/u06/img/zinjai3.png -------------------------------------------------------------------------------- /curso/u06/img/zinjai4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/curso/u06/img/zinjai4.png -------------------------------------------------------------------------------- /curso/u06/img/zinjai5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/curso/u06/img/zinjai5.png -------------------------------------------------------------------------------- /curso/u07/README.md: -------------------------------------------------------------------------------- 1 | # Datos y tipos de datos 2 | 3 | El tipo de dato representa la clase de datos con el que vamos a trabajar. 4 | 5 | Podemos clasificar los tipos de datos de la siguiente manera: 6 | 7 | * **Tipos de datos simples**: 8 | * Números enteros (`int`) 9 | * Números reales (`float` o `double`) 10 | * Valores lógicos (`bool`) 11 | * Caracteres (`char`) 12 | * **Tipos de datos complejos**: 13 | * Arrays 14 | * Cadena de caracteres 15 | * Estructuras de datos 16 | 17 | Los datos con los que podemos trabajar en un programa lo podemos indicar de tres formas distintas: 18 | 19 | * **Literales**: Los literales nos permiten representar valores. Por ejemplo un literal entero podría ser el 5. 20 | * **Variables**: Una variables es un identificador que guarda un valor. Las variables se declaran de un determinado tipo de datos. Por ejemplo una variable entera puede guardar datos enteros. 21 | * **Constantes**: Podemos declarar un valor de un determinado tipo por medio de un identificador. Mientras el valor de una variable puede cambiar a lo largo de la ejecución de un programa, las constantes no pueden cambiar. 22 | * **Expresiones**: Por último indicar que podemos hacer operaciones entre los distintos datos. El tipo de dato de una expresión dependerá del resultado de la operación. Según el tipo de datos con los que trabajemos tenemos distintos tipos de operadores que estudiaremos durante este curso: 23 | 24 | * **Operadores aritméticos**: Para hacer operaciones con tipos de datos numéricos. 25 | * **Operadores relacionados**: Nos permiten comparar datos y nos devuelven valores lógicos 26 | * **Operadores lógicos**: Nos permiten trabajar con valores lógicos. 27 | * **Operadores de asignación**: Nos permiten asignar valores a variables. 28 | * **Otros operadores**: Durante el curso veremos algunos operadores más, por ejemplo para trabajar con bits o para trabajar con punteros. 29 | 30 | La precedencia de operadores es la siguiente: 31 | 32 | * Los paréntesis rompen la precedencia. 33 | * Operadores unarios (soĺo tienen un operador, por ejemplo el `-9`) 34 | * Multiplicar, dividir y módulo 35 | * Suma y resta 36 | * Operador lógico `&&` (Y lógico) 37 | * Operadores lógico `||` (O lógico) 38 | * Operadores de comparación 39 | * Operadores de asignación 40 | 41 | 42 | -------------------------------------------------------------------------------- /curso/u08/README.md: -------------------------------------------------------------------------------- 1 | # Literales y constantes 2 | 3 | ## Literales 4 | 5 | Los literales nos permiten representar valores. Estos valores pueden ser de diferentes tipos, de esta manera tenemos diferentes tipos de literales: 6 | 7 | * **Literales enteros**: Para representar números enteros utilizamos cifras enteras. Ejemplos números en base decimal: `5`,`-12`..., en base octal: `077` y en hexadecimal `0xfe`. 8 | * **Literales reales**: Utilizamos un punto para separar la parte entera de la decimal. Por ejemplo: `3.14159`. También podemos usar la letra `e` o `E` seguida de un exponente con signo para indicar la potencia de 10 a utilizar, por ejemplo: `6.63e-34`, `35E20`. 9 | * **Literales booleanos o lógicos**: Los valores lógicos solo tienen dos valores: `false` para indicar el valor falso, y `true` para indicar el valor verdadero. 10 | * **Literales carácter**: Para indicar un valor de tipo carácter usamos la comilla simple `'`. Por ejemplo `'a'`. tenemos algunos caracteres especiales que son muy útiles, por ejemplo `\n` indica nueva línea y `\t` indica tabulador. 11 | * **Literales cadenas de caracteres**: Una cadena de caracteres es un conjunto de caracteres. Para indicar cadenas de caracteres usamos las dobles comillas `"`, por ejemplo: `"Hola"`. 12 | 13 | ## Constantes 14 | 15 | Una constante es un valor que identificamos con un nombre cuyo valor no cambia durante la ejecución del programa. Para crear constantes usamos: 16 | 17 | # define identificador valor 18 | 19 | Veamos un ejemplo: 20 | 21 | #include 22 | using namespace std; 23 | 24 | #define ANCHURA 10 25 | #define ALTURA 5 26 | #define NUEVALINEA '\n' 27 | 28 | int main() { 29 | int area; 30 | 31 | area = ANCHURA * ALTURA; 32 | cout << area; 33 | cout << NUEVALINEA; 34 | return 0; 35 | } 36 | 37 | Otra forma de crear constantes es usar el modificador `const` al crear una variable. Lo veremos cuando estudiemos las variables. -------------------------------------------------------------------------------- /curso/u09/README.md: -------------------------------------------------------------------------------- 1 | # Variables 2 | 3 | Una variable nos permite almacenar información. Cada variable tiene un nombre y al crearlas hay que indicar el tipo de datos que va a almacenar. 4 | 5 | El nombre de una variable puede estar formado por letras, dígitos y subrayados, pero no puede empezar por un dígito. Los nombres se suelen indicar en minúsculas. 6 | 7 | ## Declaración de variables 8 | 9 | Para poder usar una variable tenemos que declarar, la declaración consiste en indicar el tipo y el nombre de la variable. Además en una declaración también podemos inicializar la variable con un valor. Veamos distintos ejemplos donde declaramos variables de tipo entero: 10 | 11 | int variable1; 12 | int variable2=10; 13 | int variable3, variable4, variable5; 14 | int variable6=100, variable7=-10; 15 | 16 | Podemos declarar una variable y posteriormente inicializarla (con el operador de asignación `=`). 17 | 18 | int variable8; 19 | variable8=1000; 20 | 21 | Si declaramos una variable y no la inicializamos tendrá un valor por defecto: la variables numéricas tendrá un valor de `0` y los caracteres tendrán un valor de `\0`. 22 | 23 | Las variables hay que declararla antes de usarla, pero es muy recomendable declarar todas las variables al principio de la función (esto era obligatorio en el lenguaje C). 24 | 25 | 26 | ## Ámbito de las variables 27 | 28 | Según donde declaremos las variables podrán ser: 29 | 30 | ### Variables locales 31 | 32 | Están definidas dentro de una función o un bloque de instrucciones. Existen y se pueden usar sólo en esa función o bloque. Ejemplo: 33 | 34 | 35 | #include 36 | using namespace std; 37 | 38 | int main () { 39 | // Declaración de variable local 40 | int a, b; 41 | int c; 42 | 43 | // Inicializamos las variables 44 | a = 10; 45 | b = 20; 46 | c = a + b; 47 | 48 | cout << c; 49 | 50 | return 0; 51 | } 52 | 53 | ### Variables globales 54 | 55 | Están declaradas fuera de las funciones, se pueden usar en cualquier función del programa. No es recomendable su uso. Ejemplo: 56 | 57 | #include 58 | using namespace std; 59 | 60 | // Declaración de variable global 61 | int g; 62 | 63 | int main () { 64 | // Declaración de variable local 65 | int a, b; 66 | 67 | // Inicializamos las variables 68 | a = 10; 69 | b = 20; 70 | g = a + b; 71 | 72 | cout << g; 73 | 74 | return 0; 75 | } 76 | 77 | ## Operadores de asignación 78 | 79 | Nos permiten guardar información en las variables. En una variable podemos guardar un literal, otra variable o el resultado de una expresión. Los operadores de asignación son los siguientes: 80 | 81 | * `=`: Asignación simple, por ejemplo: `a=b+7;` 82 | * `+=`: Suma y a continuación asigna. Por ejemplo: `a+=b` es igual que `a=a+b`. También podemos usar los operadores, `-=`, `*=`, `/=`,... 83 | 84 | -------------------------------------------------------------------------------- /curso/u10/README.md: -------------------------------------------------------------------------------- 1 | # Tipos de datos numérico 2 | 3 | Los principales tipos de datos numéricos son los siguientes: 4 | 5 | * `int`: Nos permite guardar valores enteros. 6 | * `float`: Nos permiten guardar números reales de precisión simple (7 dígitos decimales). 7 | * `double`: Nos permite guardar números reales de doble precisión (16 dígitos decimales). 8 | 9 | El tipo de un dato determina el tamaño de memoria que se va a utilizar para guardarlo y por lo tanto determina los valores que podemos representar. 10 | 11 | | Tipo | Memoria | Rango de valores | 12 | | ---------- |:----------:|-------------------------------:| 13 | | int | 4 bytes | -2147483648 a 2147483647 | 14 | | float | 4 bytes | -3.4E+38 a +3.4E+38 | 15 | | double | 8 bytes | -1.7E+308 to +1.7E+308 | 16 | 17 | ## El tipo de dato carácter 18 | 19 | Para guardar un carácter usamos el tipo de dato `char`. Realmente el tipo de dato `char` es un tipo entero, ocupa 1 byte de memoria por lo que puede guardar 256 valores. En un variable de tipo `char` guardaremos un número que corresponde código ASCII del carácter. 20 | 21 | Veamos un ejemplo donde se imprimen dos caracteres `a`: 22 | 23 | #include 24 | using namespace std; 25 | 26 | int main(int argc, char *argv[]) { 27 | char caracter1='a'; 28 | char caracter2=97; 29 | cout << caracter1 << endl; 30 | cout << caracter2 << endl; 31 | return 0; 32 | } 33 | 34 | ## Modificadores de tipos 35 | 36 | Podemos modificar los tipos anteriores para dos cosas: para aumentar la memoria utilizada y por lo tanto aumentar el rango de valores representables, y para indicar si se usan número negativos o no. 37 | 38 | Los modificadores son los siguientes: `signed`, `unsigned`, `long` y `short`. 39 | 40 | * Los modificadores `signed`, `unsigned`, `long` y `short` se pueden aplicar al tipo `int`. 41 | * Los modificadores `signed`, `unsigned` se puede aplicar al tipo `char`. 42 | * El modificador `long` se puede aplicar al tipo `double`. 43 | * Los modificadores `signed`, `unsigned` tambien se pueden usar como prefijos de los modificadores `long` y `short`. 44 | 45 | Con estas reglas nos quedarían esta tabla con todos los tipos: 46 | 47 | | Tipo | Memoria | Rango de valores | 48 | | -------------------|:----------:|-------------------------------------------:| 49 | | char | 1 byte | -127 a 127 o 0 a 255 | 50 | | signed char | 1 byte | -127 a 127 | 51 | | unsigned char | 1 byte | 0 a 255 | 52 | | int | 4 bytes | -2147483648 a 2147483647 | 53 | | signed int | 4 bytes | -2147483648 a 2147483647 | 54 | | unsigned int | 4 bytes | 0 a 4294967295 | 55 | | short int | 2 bytes | -32768 a 32767 | 56 | | signed short int | 2 bytes | -32768 a 32767 | 57 | | unsigned short int | 2 bytes | 0 a 65535 | 58 | | long int | 8 bytes | -9223372036854775808 a 9223372036854775807 | 59 | | signed long int | 8 bytes | -9223372036854775808 a 9223372036854775807 | 60 | | unsigned long int | 8 bytes | 0 a 18446744073709551615 | 61 | | float | 4 bytes | -3.4E+38 a +3.4E+38 | 62 | | double | 8 bytes | -1.7E+308 a +1.7E+308 | 63 | | long double | 16 bytes | 3.3621e-4932 a 1.18973e+4932 | 64 | 65 | 66 | Al declarar variables podemos usar una notación corta para declarar enteros largos, cortos o sin signos, donde no tenemos que indicar el tipo `int`, por ejemplo estas dos declaraciones son correctas: 67 | 68 | unsigned short var1; 69 | long var2; 70 | 71 | Podemos usar sufijos para indicar literales numéricos largos (con el sufijo `L`) y sin signo (con el sufijo `U`). Por ejemplo: 72 | 73 | var1=123U; 74 | var2=123L; 75 | 76 | ## Conversión de tipos 77 | 78 | * Por defecto C++ hace ciertas conversiones de forma implícitas: Por ejemplo de `char` a `int` o de `int` a `float`. Por ejemplo, esto es correcto: 79 | 80 | int i = 10; 81 | float d = i; 82 | 83 | * Si tenemos expresiones donde hacemos operaciones entre datos del mismo tipo, el resultado de la expresión será del mismo tipo. 84 | * Si tenemos expresiones donde hacemos operaciones entre datos de distintos tipos el resultado de la expresión será del tipo con más precisión de los datos operados. 85 | * Por último podemos hacer una conversión explicita usando una expresión de typecast, por ejemplo para convertir un `int` a un `float`: 86 | 87 | int num1=10,num2=3; 88 | float res; 89 | res=(float)num1 / float(num2) //Tenemos dos formas de hacer la conversión 90 | 91 | Veamos un ejemplo con el operador aritmético de división: 92 | 93 | #include 94 | using namespace std; 95 | 96 | int main(int argc, char *argv[]) { 97 | int num1=4,num2=3; 98 | cout << 4 / 3 << endl; 99 | cout << 4.0 / 3 << endl; 100 | cout << float(num1) / num2 << endl; 101 | return 0; 102 | } 103 | 104 | 1. El resultado de la primera instrucción `cout` es `1`, porque hemos dividido dos enteros y el resultado es entero. Realmente hemos hecho una división entero donde la parte decimal la hemos truncado. 105 | 2. El resultado de las otras instrucciones `cout` es `1.3333` ya que dividimos un `float` por un `int` y el resultado es `float`. 106 | 107 | ## Operadores aritméticos 108 | 109 | * `+`: Suma dos números 110 | * `-`: Resta dos números 111 | * `*`: Multiplica dos números 112 | * `/`: Divide dos números. 113 | * `%`: Módulo o resto de la división 114 | * `+`, `-`: Operadores unarios positivo y negativo 115 | * `++`: Operador de incremento. Suma uno a la variable, `i++` es lo mismo que `i=i+1`. 116 | * `--`: Operador de decremento. Resta uno a la variable. 117 | 118 | ## Funciones matemáticas 119 | 120 | En la librería `cmath` tenemos distintas funciones matemática. Las más útiles que podemos usar en nuestros programas son: 121 | 122 | * `double pow(double, double);`: Realiza la potencia, la base es el primer parámetro y el exponente el segundo. Recibe datos de tipo `double` y devuelve también una valor `double`. 123 | * `double sqrt(double);`: Realiza la raíz cuadrada del parámetro `double` que recibe. Devuelve un valor `double. 124 | * `int abs(int);`: Devuelve el valor absoluto (valor entero) del número entero que recibe como parámetro. 125 | 126 | Veamos un ejemplo: 127 | 128 | #include 129 | #include 130 | using namespace std; 131 | 132 | int main(int argc, char *argv[]) { 133 | int num1=4, num2=2; 134 | cout << "Potencia:" << pow(num1,num2) << endl; //Potencia 135 | cout << "Raíz Cuadrada:" << sqrt(num1) << endl; //Raíz cuadrada 136 | num1=-4; 137 | cout << "Valor absoluto:" << abs(num1) << endl; //Valor absoluto 138 | return 0; 139 | } -------------------------------------------------------------------------------- /curso/u11/README.md: -------------------------------------------------------------------------------- 1 | # Introducción a las cadenas de caracteres 2 | 3 | En C++ tenemos dos formas de trabajar con cadenas de caracteres: 4 | 5 | * La forma tradicional del lenguaje C: una cadena de caracteres es un array de caracteres (un conjunto de caracteres). 6 | * C++ nos ofrece la clase `string` que nos permite trabajar con cadenas de caracteres. 7 | 8 | ## Usando la clase string 9 | 10 | Para declarar una variable de tipo cadena utilizamos el tipo de datos (que en este caso es una clase) `string`, además podemos inicializar las cadenas en la declaración, ejemplos: 11 | 12 | string cadena1; 13 | string cadena2="Hola Mundo" 14 | 15 | ## Indexación de caracteres 16 | 17 | Los caracteres que forman una cadena se pueden referenciar por un indice (un número), de tal modo que el primer carácter está en la posición 0, el segundo en la posición 1, y así consecutivamente. Por ejemplo para imprimir el primer carácter: 18 | 19 | cout << cadena2[0]; 20 | H 21 | 22 | El método `length` o `size` nos devuelve el número de caracteres de una cadena, por ejemplo: 23 | 24 | cout << cadena2.length(); 25 | 10 26 | 27 | Por lo tanto para mostrar el último carácter de la cadena (que está en la posición 9): 28 | 29 | cout << cadena2[cadena2.length() - 1]; 30 | o 31 | 32 | ## Concatenación de cadenas 33 | 34 | El operador `+` me permite unir datos de tipo cadenas. 35 | 36 | #include 37 | using namespace std; 38 | 39 | int main(int argc, char *argv[]) { 40 | string nombre="Pepe"; 41 | string apellidos="García"; 42 | string nombre_completo; 43 | nombre_completo=nombre+" "+apellidos; 44 | cout << nombre_completo; 45 | return 0; 46 | } 47 | 48 | -------------------------------------------------------------------------------- /curso/u12/README.md: -------------------------------------------------------------------------------- 1 | # Entrada y salida estándar 2 | 3 | Veamos un ejemplo para estudiar la entrada y salida estándar: 4 | 5 | #include 6 | using namespace std; 7 | 8 | int main(int argc, char *argv[]) { 9 | string nombre; 10 | int edad; 11 | cout << "Bienvenido..." << endl; 12 | cout << "Dime el nombre:"; 13 | getline(cin,nombre); 14 | cout << "Dime la edad de " << nombre << ":"; 15 | cin >> edad; 16 | cout << nombre << " tiene " << edad << " años."; 17 | return 0; 18 | } 19 | 20 | 21 | La librería `iostrem` que incluimos al principio del programa tiene las funciones necesarias para gestionar la entra y salida estándar. 22 | 23 | ## Salida por pantalla 24 | 25 | El identificador `cout` representa la salida estándar (pantalla). El operador `<<` nos permite enviar información a la salida estándar. Como vemos en el programa en una misma instrucciones podemos enviar a la salida estándar varias datos de distintos tipos. El identificador `endl` cambia de línea al terminar de imprimir por pantalla, sería lo mismo que imprimir un carácter `\n`. 26 | 27 | ## Entrada por teclado 28 | 29 | El identificador `cin` representa la entrada estándar (teclado). El operador `>>` nos permite guardar la información que introducimos por teclado en una variable. El operador `>>` hace la conversión necesaria para guardar la información en la variable según del tipo que la hayamos declarado. Por ejemplo en la siguiente instrucción: 30 | 31 | cin >> edad; 32 | 33 | Sabemos que edad es de tipo entero, si introducimos por teclado un dato que no sea entero, no se guardará nada en la variable y su valor será el que tiene por defecto, un 0. 34 | 35 | ## Lectura de cadenas de caracteres 36 | 37 | Por defecto el operador `>>` no es capaz de leer los espacios que podemos poner entre palabras al leer una variable cadena, por ejemplo: 38 | 39 | ... 40 | string nombre; 41 | cout << "Dime el nombre:"; 42 | cin >> nombre; 43 | cout << nombre; 44 | ... 45 | 46 | Si introducimos por teclado "Pepe García", la salida del programa será "Pepe". 47 | 48 | Por lo tanto para poder leer los espacios al leer cadenas de caracteres vamos a usar la función `getline`, donde indicamos como parámetros el la entrada estándar (`cin`) y la variable que de tipo `string` que vamos a leer. Por ejemplo: 49 | 50 | ... 51 | string nombre; 52 | cout << "Dime el nombre:"; 53 | getline(cin,nombre); 54 | cout << nombre; 55 | ... 56 | 57 | En ocasiones cuando hemos leído con `cin >>`, la siguiente instrucción `getline` no lee nada por teclado, en realidad lo que pasa es que lee del buffer de entrada el carácter de retorno. Para evitar esto antes de usar la instrucción `getline` hay que borrar el buffer usando `cin.ignore()`, veamos un ejemplo: 58 | 59 | #include 60 | using namespace std; 61 | 62 | int main(int argc, char *argv[]) { 63 | 64 | int edad; 65 | string nombre; 66 | cout << "Introduce la edad:"; 67 | cin >> edad; 68 | cout << "Introduce el nombre:"; 69 | cin.ignore(); 70 | getline(cin,nombre); 71 | return 0; 72 | } 73 | -------------------------------------------------------------------------------- /curso/u13/README.md: -------------------------------------------------------------------------------- 1 | # Pasando de pseudocódigo a C++ 2 | 3 | Antes de empezar hacer ejercicios con la estructura secuencial, vamos a ver como convertimos algunas instrucciones en pseudocódigo a C++: 4 | 5 | ## Leer variables por teclado 6 | 7 | ### Leer cadenas de caracteres 8 | 9 | En pseudocódigo: 10 | 11 | Definir nombre Como Cadena; 12 | Escribir "Dime tu nombre:"; 13 | Leer nombre; 14 | 15 | En C++: 16 | 17 | string nombre; 18 | cout << "Dime tu nombre:"; 19 | getline(cin, nombre); 20 | 21 | ### Leer números enteros 22 | 23 | En pseudocódigo: 24 | 25 | Definir numero Como Entero; 26 | Escribir "Dime un número entero:"; 27 | Leer numero; 28 | 29 | En C++: 30 | 31 | int numero; 32 | cout << "Dime un número entero:"; 33 | cin >> numero; 34 | 35 | ### Leer números reales 36 | 37 | En pseudocódigo: 38 | 39 | Definir numero Como Real; 40 | Escribir "Dime un número real:"; 41 | Leer numero; 42 | 43 | En C++: 44 | 45 | float numero; 46 | cout << "Dime un número real:"; 47 | cin >> numero; 48 | 49 | ## Escribir una variable en pantalla 50 | 51 | En pseudocódigo: 52 | 53 | Escribir "Hola ",nombre; 54 | 55 | En C++: 56 | 57 | cout << "Hola " << nombre; 58 | 59 | ## Escribir sin saltar a otra línea 60 | 61 | En pseudocódigo: 62 | 63 | Escribir Sin Saltar var," "; 64 | 65 | En C++: 66 | 67 | cout << "Hola " << nombre << endl; 68 | 69 | 70 | ## Asignar valor a una variable 71 | 72 | En pseudocódigo: 73 | 74 | numero <- 7; 75 | 76 | En C++: 77 | 78 | numero = 7; 79 | 80 | Por ejemplo para incrementar el valor de una variable, en pseudocódigo: 81 | 82 | num <- num + 1 83 | 84 | En C++ lo podemos hacer de dos maneras: 85 | 86 | num = num + 1; 87 | 88 | O de esta forma: 89 | 90 | num++; 91 | 92 | ## Calcular la parte entera de una división 93 | 94 | En pseudocódigo: 95 | 96 | trunc(7/2) 97 | 98 | En C++: 99 | 100 | 7 / 2; 101 | 102 | ## Calcular la raíz cuadrada 103 | 104 | En pseudocódigo: 105 | 106 | Escribir raiz(9) 107 | 108 | En C++: 109 | 110 | #include 111 | cout << sqrt(9); 112 | 113 | ## Obtener el carácter de una cadena 114 | 115 | En pseudocódigo: 116 | 117 | subcadena(cadena,0,0) 118 | 119 | En C++: 120 | 121 | cadena[0]; 122 | 123 | ## Unir dos cadenas de caracteres 124 | 125 | En pseudocódigo: 126 | 127 | cadena3 <- concatenar(cadena1,cadena2) 128 | 129 | En C++: 130 | 131 | cadena3 = cadena1 + cadena2; 132 | 133 | ## Convertir un carácter a Mayúsculas 134 | 135 | En pseudocódigo: 136 | 137 | cadena <- Mayusculas(cadena) 138 | 139 | En C++ podemos convertir a mayúsculas un carácter: 140 | 141 | char cadena = 'a'; 142 | cadena = toupper(cadena) -------------------------------------------------------------------------------- /curso/u14/README.md: -------------------------------------------------------------------------------- 1 | # Ejercicios estructura secuencial 2 | 3 | ### Ejercicio 1 4 | 5 | Escribir un programa que pregunte al usuario su nombre, y luego lo salude. 6 | 7 | ### Ejercicio 2 8 | 9 | Calcular el perímetro y área de un rectángulo dada su base y su altura. 10 | 11 | ### Ejercicio 3 12 | 13 | Dados los catetos de un triángulo rectángulo, calcular su hipotenusa. 14 | 15 | ### Ejercicio 4 16 | 17 | Dados dos números, mostrar la suma, resta, división y multiplicación de ambos. 18 | 19 | ### Ejercicio 5 20 | 21 | Escribir un programa que convierta un valor dado en grados Fahrenheit a grados Celsius. Recordar que la fórmula para la conversión es: 22 | 23 | C = (F-32)*5/9 24 | 25 | ### Ejercicio 6 26 | 27 | Calcular la media de tres números pedidos por teclado. 28 | 29 | ### Ejercicio 7 30 | 31 | Realiza un programa que reciba una cantidad de minutos y muestre por pantalla a cuantas horas y minutos corresponde. 32 | Por ejemplo: 1000 minutos son 16 horas y 40 minutos. 33 | 34 | ### Ejercicio 8 35 | 36 | Un vendedor recibe un sueldo base mas un 10% extra por comisión de sus ventas, el vendedor desea saber cuanto dinero obtendrá por concepto de comisiones por las tres ventas que realiza en el mes y el total que recibirá en el mes tomando en cuenta su sueldo base y comisiones. 37 | 38 | ### Ejercicio 9 39 | 40 | Una tienda ofrece un descuento del 15% sobre el total de la compra y un cliente desea saber cuanto deberá pagar finalmente por su compra. 41 | 42 | ### Ejercicio 10 43 | 44 | Un alumno desea saber cual será su calificación final en la materia de Algoritmos. Dicha calificación se compone de los siguientes porcentajes: 45 | * 55% del promedio de sus tres calificaciones parciales. 46 | * 30% de la calificación del examen final. 47 | * 15% de la calificación de un trabajo final. 48 | 49 | ### Ejercicio 11 50 | 51 | Pide al usuario dos números y muestra la "distancia" entre ellos (el valor absoluto de su diferencia, de modo que el resultado sea siempre positivo). 52 | 53 | ### Ejercicio 12 54 | 55 | Pide al usuario dos pares de números x1,y2 y x2,y2, que representen dos puntos en el plano. Calcula y muestra la distancia entre ellos. 56 | 57 | ### Ejercicio 13 58 | 59 | Realizar un algoritmos que lea un número y que muestre su raíz cuadrada y su raíz cúbica. PSeInt no tiene ninguna función predefinida que permita calcular la raíz cúbica, ¿Cómo se puede calcular? 60 | 61 | ### Ejercicio 14 62 | 63 | Dado un número de dos cifras, diseñe un algoritmo que permita obtener el número invertido. Ejemplo, si se introduce 23 que muestre 32. 64 | 65 | ### Ejercicio 15 66 | 67 | Dadas dos variables numéricas A y B, que el usuario debe teclear, se pide realizar un algoritmo que intercambie los valores de ambas variables y muestre cuanto valen al final las dos variables. 68 | 69 | ### Ejercicio 16 70 | 71 | Dos vehículos viajan a diferentes velocidades (v1 y v2) y están distanciados por una distancia d. El que está detrás viaja a una velocidad mayor. Se pide hacer un algoritmo para ingresar la distancia entre los dos vehículos (km) y sus respectivas velocidades (km/h) y con esto determinar y mostrar en que tiempo (minutos) alcanzará el vehículo más rápido al otro. 72 | 73 | ### Ejercicio 17 74 | 75 | Un ciclista parte de una ciudad A a las HH horas, MM minutos y SS segundos. El tiempo de viaje hasta llegar a otra ciudad B es de T segundos. Escribir un algoritmo que determine la hora de llegada a la ciudad B. 76 | 77 | ### Ejercicio 18 78 | 79 | Pedir el nombre y los dos apellidos de una persona y mostrar las iniciales. 80 | 81 | ### Ejercicio 19 82 | 83 | Escribir un algoritmo para calcular la nota final de un estudiante, considerando que: por cada respuesta correcta 5 puntos, por una incorrecta -1 y por respuestas en blanco 0. Imprime el resultado obtenido por el estudiante. 84 | 85 | ### Ejercicio 20 86 | 87 | Diseñar un algoritmo que nos diga el dinero que tenemos (en euros y céntimos) después de pedirnos cuantas monedas tenemos (de 2€, 1€, 50 céntimos, 20 céntimos o 10 céntimos). 88 | 89 | # Ejercicios resueltos 90 | 91 | [Ejercicios estructura secuencial](../../ejercicios/secuencial) -------------------------------------------------------------------------------- /curso/u15/README.md: -------------------------------------------------------------------------------- 1 | # Tipo de datos booleano. Operadores relacionales y lógicos 2 | 3 | El tipo booleano o lógico `bool` puede tener dos estados expresados por las constantes predefinidas `true` (lo que lo convierte en el entero 1) y `false` (lo que lo convierte en el entero 0). Realmente cualquier valor entero distinto de 0 será verdadero, y el 0 será falso. 4 | 5 | ## Operadores de comparación 6 | 7 | El valor devuelto por una operación de comparación es un valor lógico: 8 | 9 | * `>`: Mayor que 10 | * `<`: Menor que 11 | * `==`: Igual que 12 | * `<=`: Menor o igual 13 | * `>=`: Mayor o igual 14 | * `!=`: Distinto 15 | 16 | ## Operadores lógicos 17 | 18 | El valor devuelto por una operación lógica es un valor lógico: 19 | 20 | * `&&`: Conjunción, operación AND. 21 | * `||`: Disyunción, operación OR. 22 | * `!`: Negación, operación NOT. 23 | 24 | **Tabla de verdad del operador Y** 25 | 26 | | a | b | a && b | 27 | |---|---|--------------| 28 | | V | V | V | 29 | | V | F | F | 30 | | F | V | F | 31 | | F | F | F | 32 | 33 | **Tabla de verdad del operador O** 34 | 35 | | a | b | a \\|\\| b | 36 | |---|---|--------------| 37 | | V | V | V | 38 | | V | F | V | 39 | | F | V | V | 40 | | F | F | F | 41 | 42 | **Tabla de verdad del operador NO** 43 | 44 | | a | !a | 45 | |---|---| 46 | | V | F | 47 | | F | V | 48 | 49 | ## Comparación de cadenas de caracteres 50 | 51 | Las cadenas se comparan carácter a carácter, en el momento en que dos caracteres no son iguales se compara alfabéticamente (es decir, se convierte a código ASCII y se comparan). 52 | 53 | Ejemplos 54 | 55 | * "a">"A" es verdadero. 56 | * "informatica">"informacion" es verdadero. 57 | * "abcde">"abcdef" es falso. -------------------------------------------------------------------------------- /curso/u16/README.md: -------------------------------------------------------------------------------- 1 | # Estructuras alternativas: Si 2 | 3 | ## Alternativa simple: if 4 | 5 | ![si](img/si.png) 6 | 7 | La estructura es la siguiente: 8 | 9 | if (expresión lógica) 10 | { 11 | instrucciones 12 | } 13 | 14 | Al ejecutarse la instrucción `if` se evalúa la condición lógica. Si la condición lógica es `true` se ejecutan de manera secuencial el bloque de instrucciones *Acciones A*. Si la condición es `false` no se ejecuta el bloque de instrucciones. Una vez ejecutado el `si` (opción verdadera o falsa) se continúa la ejecución de forma secuencial por la siguiente instrucción detrás del final de bloque `}`. Se suelen indentar las instrucciones dentro del bloque `if` para que se más legible el código. 15 | 16 | ### Ejemplo 17 | 18 | Programa que pida la edad y diga si es mayor de edad. 19 | 20 | #include 21 | using namespace std; 22 | 23 | int main(int argc, char *argv[]) { 24 | int edad; 25 | cout << "Dime tu edad:"; 26 | cin >> edad; 27 | if (edad>=18) 28 | { 29 | cout << "Eres mayor de edad" << endl; 30 | } 31 | cout << "Programa terminado"; 32 | return 0; 33 | } 34 | 35 | 36 | ## Alternativa doble: if - else 37 | 38 | La estructura es la siguiente: 39 | 40 | if (expresión lógica) 41 | { 42 | instrucciones A 43 | } 44 | else 45 | { 46 | instrucciones B 47 | } 48 | 49 | ![si](img/sidoble.png) 50 | 51 | Al ejecutarse la instrucción `ifi` se evalúa la condición lógica. Si la condición lógica es `true` se ejecutan de manera secuencial el bloque de instrucciones *Acciones A*. Si la condición es `false` se ejecuta el bloque de instrucción *Acciones B*. Una vez ejecutado el `if` (opción verdadera o falsa) se continúa la ejecución de forma secuencial por la siguiente instrucción detrás del final de bloque `}`. 52 | 53 | ### Ejemplo 54 | 55 | Programa que pida la edad y diga si es mayor de edad o menor de edad. 56 | 57 | #include 58 | using namespace std; 59 | 60 | int main(int argc, char *argv[]) { 61 | int edad; 62 | cout << "Dime tu edad:"; 63 | cin >> edad; 64 | if (edad>=18) 65 | { 66 | cout << "Eres mayor de edad" << endl; 67 | } 68 | else 69 | { 70 | cout << "Eres menor de edad" << endl; 71 | } 72 | cout << "Programa terminado"; 73 | return 0; 74 | } -------------------------------------------------------------------------------- /curso/u16/img/si.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/curso/u16/img/si.png -------------------------------------------------------------------------------- /curso/u16/img/sidoble.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/curso/u16/img/sidoble.png -------------------------------------------------------------------------------- /curso/u17/README.md: -------------------------------------------------------------------------------- 1 | # Estructuras alternativas: switch 2 | 3 | ## Alternativa múltiple: switch 4 | 5 | ![segun](img/segun.png) 6 | 7 | La secuencia de instrucciones ejecutada por una instrucción `switch` depende del valor de una variable numérica. 8 | 9 | switch(expresión) 10 | { 11 | case valor1: 12 | instrucciones; 13 | break; //opcional 14 | case valor2: 15 | instrucciones; 16 | break; //opcional 17 | ... 18 | default: //opcional 19 | statement(s); 20 | } 21 | 22 | * Esta instrucción permite ejecutar opcionalmente varias acciones posibles, dependiendo del valor de una expresión. 23 | * La expresión que se utiliza en una instrucción switch debe ser un entero (`int` o `char`). 24 | * Un switch puede tener varios comparaciones `case` donde indicaremos el valor con el que se va a comparar, terminado por `:`. El valor debe ser del mismo tipo de la variable que hemos indicado en la instrucción `switch`. 25 | * En el momento que una comparación `case` se ejecutarán todas las instrucciones (incluido los `case` posteriores) hasta que se encuentre una instrucción `break`. 26 | * Podemos indicar una opción por defecto `default`, que debe aparecer al final de la instrucción y que se ejecuta sin ninguna opción anterior se ha cumplido. 27 | 28 | 29 | ### Ejemplo 30 | 31 | Programa que pide una nota de un examen por teclado y muestra la nota como "Sobresaliente", "Notable", "Bien", "Suficiente", "Suspendido": 32 | 33 | #include 34 | using namespace std; 35 | 36 | int main(int argc, char *argv[]) { 37 | int nota; 38 | cout << "Dime tu nota:"; 39 | cin >> nota; 40 | switch(nota) 41 | { 42 | case 1: 43 | case 2: 44 | case 3: 45 | case 4: 46 | cout << "Suspenso"; 47 | break; 48 | case 5: 49 | cout << "Suficiente"; 50 | break; 51 | case 6: 52 | case 7: 53 | cout << "Bien"; 54 | break; 55 | case 8: 56 | cout << "Notable"; 57 | break; 58 | case 9: 59 | case 10: 60 | cout << "Sobresaliente"; 61 | break; 62 | default: 63 | cout << "Nota incorrecta"; 64 | } 65 | cout << endl << "Programa terminado"; 66 | return 0; 67 | } -------------------------------------------------------------------------------- /curso/u17/img/segun.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/curso/u17/img/segun.png -------------------------------------------------------------------------------- /curso/u18/README.md: -------------------------------------------------------------------------------- 1 | # Ejercicios estructuras alternativas 2 | 3 | ### Ejercicio 1 4 | 5 | Algoritmo que pida dos números e indique si el primero es mayor que el segundo o no. 6 | 7 | ### Ejercicio 2 8 | 9 | Algoritmo que pida un número y diga si es positivo, negativo o 0. 10 | 11 | ### Ejercicio 3 12 | 13 | Escribe un programa que lea un número e indique si es par o impar. 14 | 15 | ### Ejercicio 4 16 | 17 | Crea un programa que pida al usuario dos números y muestre su división si el segundo no es cero, o un mensaje de aviso en caso contrario. 18 | 19 | ### Ejercicio 5 20 | 21 | Escribe un programa que pida un nombre de usuario y una contraseña y si se ha introducido "pepe" y "asdasd" se indica "Has entrado al sistema", sino se da un error. 22 | 23 | ### Ejercicio 6 24 | 25 | Programa que lea una cadena por teclado y compruebe si es una letra mayúscula. 26 | 27 | ### Ejercicio 7 28 | 29 | Realiza un algoritmo que calcule la potencia, para ello pide por teclado la base y el exponente. Pueden ocurrir tres cosas: 30 | 31 | * El exponente sea positivo, sólo tienes que imprimir la potencia. 32 | * El exponente sea 0, el resultado es 1. 33 | * El exponente sea negativo, el resultado es 1/potencia con el exponente positivo. 34 | 35 | ### Ejercicio 8 36 | 37 | Algoritmo que pida dos números 'nota' y 'edad' y un carácter 'sexo' y muestre el 38 | mensaje 'ACEPTADA' si la nota es mayor o igual a cinco, la edad es mayor o igual a 39 | dieciocho y el sexo es 'F'. En caso de que se cumpla lo mismo, pero el sexo sea 'M', debe 40 | imprimir 'POSIBLE'. Si no se cumplen dichas condiciones se debe mostrar 'NO ACEPTADA'. 41 | 42 | ### Ejercicio 9 43 | 44 | Algoritmo que pida tres números y los muestre ordenados (de mayor a menor); 45 | 46 | ### Ejercicio 10 47 | 48 | Algoritmo que pida los puntos centrales x1,y1,x2,y2 y los radios r1,r2 de dos 49 | circunferencias y las clasifique en uno de estos estados: 50 | * exteriores 51 | * tangentes exteriores 52 | * secantes 53 | * tangentes interiores 54 | * interiores 55 | * concéntricas 56 | 57 | ### Ejercicio 11 58 | 59 | Programa que lea 3 datos de entrada A, B y C. Estos corresponden a las dimensiones de los lados de un triángulo. El programa debe determinar que tipo de triangulo es, teniendo en cuenta los siguiente: 60 | 61 | * Si se cumple Pitágoras entonces es triángulo rectángulo 62 | * Si sólo dos lados del triángulo son iguales entonces es isósceles. 63 | * Si los 3 lados son iguales entonces es equilátero. 64 | * Si no se cumple ninguna de las condiciones anteriores, es escaleno. 65 | 66 | ### Ejercicio 12 67 | 68 | Escribir un programa que lea un año indicar si es bisiesto. Nota: un año es bisiesto si es un número divisible por 4, pero no si es divisible por 100, excepto que también sea divisible por 400. 69 | 70 | ### Ejercicio 13 71 | 72 | Escribe un programa que pida una fecha (día, mes y año) y diga si es correcta. 73 | 74 | ### Ejercicio 14 75 | 76 | La asociación de vinicultores tiene como política fijar un precio inicial al kilo de uva, la cual se clasifica en tipos A y B, y además en tamaños 1 y 2. Cuando se realiza la venta del producto, ésta es de un solo tipo y tamaño, se requiere determinar cuánto recibirá un productor por la uva que entrega en un embarque, considerando lo siguiente: si es de tipo A, 77 | se le cargan 20 céntimos al precio inicial cuando es de tamaño 1; y 30 céntimos si es de tamaño 2. Si es de tipo B, se rebajan 30 céntimos cuando es de tamaño 1, y 50 céntimos cuando es de tamaño 2. Realice un algoritmo para determinar la ganancia obtenida. 78 | 79 | ### Ejercicio 15 80 | 81 | El director de una escuela está organizando un viaje de estudios, y requiere determinar cuánto debe cobrar a cada alumno y cuánto debe pagar a la compañía de viajes por el servicio. La forma de cobrar es la siguiente: si son 100 alumnos o más, el costo por cada alumno es de 65 euros; de 50 a 99 alumnos, el costo es de 70 euros, de 30 a 49, de 95 euros, y si son menos de 30, el costo de la renta del autobús es de 4000 euros, sin importar el número de alumnos. 82 | Realice un algoritmo que permita determinar el pago a la compañía de autobuses y lo que debe pagar cada alumno por el viaje. 83 | 84 | ### Ejercicio 16 85 | 86 | La política de cobro de una compañía telefónica es: cuando se realiza una llamada, el cobro es por el tiempo que ésta dura, de tal forma que los primeros cinco minutos cuestan 1 euro, los siguientes tres, 80 céntimos, los siguientes dos minutos, 70 céntimos, y a partir del décimo minuto, 50 céntimos. 87 | Además, se carga un impuesto de 3 % cuando es domingo, y si es otro día, en turno de mañana, 15 %, y en turno de tarde, 10 %. Realice un algoritmo para determinar cuánto debe pagar por cada concepto una persona que realiza una llamada. 88 | 89 | ### Ejercicio 17 90 | 91 | Realiza un programa que pida por teclado el resultado (dato entero) obtenido al lanzar un dado de seis caras y muestre por pantalla el número en letras (dato cadena) de la cara opuesta al resultado obtenido. 92 | 93 | * Nota 1: En las caras opuestas de un dado de seis caras están los números: 1-6, 2-5 y 3-4. 94 | * Nota 2: Si el número del dado introducido es menor que 1 o mayor que 6, se mostrará el mensaje: "ERROR: número incorrecto.". 95 | 96 | Ejemplo: 97 | 98 | Introduzca número del dado: 5 99 | En la cara opuesta está el "dos". 100 | 101 | ### Ejercicio 18 102 | 103 | Realiza un programa que pida el día de la semana (del 1 al 7) y escriba el día correspondiente. Si introducimos otro número nos da un error. 104 | 105 | ### Ejercicio 19 106 | 107 | Escribe un programa que pida un número entero entre uno y doce e imprima el número de días que tiene el mes correspondiente. 108 | 109 | ### Ejercicio 20 110 | 111 | Una compañía de transporte internacional tiene servicio en algunos países de América del Norte, América Central, América del Sur, Europa y Asia. El costo por el servicio de transporte se basa en el peso del paquete y la zona a la que va dirigido. Lo anterior se muestra en la tabla: 112 | 113 | 114 | |Zona|Ubicación|Costo/gramo| 115 | |----|---------|-----------| 116 | |1|América del Norte|24.00 euros| 117 | |2|América Central|20.00 euros| 118 | |3|América del Sur|21.00 euros| 119 | |4|Europa|10.00 euros| 120 | |5|Asia|18.00 euros| 121 | 122 | Parte de su política implica que los paquetes con un peso superior a 5 kg no son transportados, esto por cuestiones de logística y de seguridad. 123 | Realice un algoritmo para determinar el cobro por la entrega de un paquete o, en su caso, el rechazo de la entrega. 124 | 125 | # Ejercicios resueltos 126 | 127 | [Ejercicios estructuras alternativas](../../ejercicios/alternativas) -------------------------------------------------------------------------------- /curso/u19/README.md: -------------------------------------------------------------------------------- 1 | # Estructuras repetitivas: while 2 | 3 | ![mientras](img/mientras.png) 4 | 5 | La instrucción `while` ejecuta una secuencia de instrucciones mientras una condición sea verdadera. 6 | 7 | while(condición) 8 | { 9 | instrucciones; 10 | } 11 | 12 | * Al ejecutarse esta instrucción, la condición es evaluada. Si la condición resulta verdadera, se ejecuta una vez la secuencia de instrucciones que forman el cuerpo del ciclo. Al finalizar la ejecución del cuerpo del ciclo se vuelve a evaluar la condición y, si es verdadera, la ejecución se repite. Estos pasos se repiten mientras la condición sea verdadera. 13 | * Se puede dar la circunstancia que las instrucciones del bucle no se ejecuten nunca, si al evaluar por primera vez la condición resulta ser falsa. 14 | * Si la condición siempre es verdadera, al ejecutar esta instrucción se produce un ciclo infinito. A fin de evitarlo, las instrucciones del cuerpo del ciclo deben contener alguna instrucción que modifique la o las variables involucradas en la condición, de modo que ésta sea falsificada en algún momento y así finalice la ejecución del ciclo. 15 | 16 | ## Ejemplo: 17 | 18 | Crea un programa que pida al usuario una contraseña, de forma repetitiva mientras que no introduzca "asdasd". Cuando finalmente escriba la contraseña correcta, se le dirá "Bienvenido" y terminará el programa. 19 | 20 | #include 21 | using namespace std; 22 | 23 | int main(int argc, char *argv[]) { 24 | string secreto, clave; 25 | secreto = "asdasd"; 26 | cout << "Dime la clave:"; 27 | getline(cin,clave); 28 | while (clave!=secreto) 29 | { 30 | cout << "Clave incorrecta!!!" << endl; 31 | cout << "Dime la clave:"; 32 | getline(cin,clave); 33 | } 34 | cout << "Bienvenido!!!" << endl; 35 | cout << "Programa terminado"; 36 | return 0; 37 | } 38 | 39 | ## Instrucciones break y continue 40 | 41 | Estas instrucciones funciones en todos los tipos de bucles que vamos a estudiar. 42 | 43 | ### break 44 | 45 | Termina la ejecución del bucle, además no ejecuta el bloque de instrucciones. 46 | 47 | Veamos un programa similar al anterior pero que tiene otra condición de salida: 48 | 49 | #include 50 | using namespace std; 51 | 52 | int main(int argc, char *argv[]) { 53 | char otra; 54 | string secreto, clave; 55 | secreto = "asdasd"; 56 | cout << "Dime la clave:"; 57 | getline(cin,clave); 58 | while (clave!=secreto) 59 | { 60 | cout << "Clave incorrecta!!!" << endl; 61 | cout << "¿Quieres introducir otra clave (S/N)?"; 62 | cin >> otra; 63 | if (toupper(otra)=='N') break; 64 | cout << "Dime la clave:"; 65 | getline(cin,clave); 66 | } 67 | if (clave == secreto) cout << "Bienvenido!!!" << endl; 68 | cout << "Programa terminado"; 69 | return 0; 70 | } 71 | 72 | ### continue 73 | 74 | Deja de ejecutar las restantes instrucciones del bucle y vuelve a iterar. 75 | 76 | Aunque podemos de hacerlo de varias formas, vamos a usar la instrucción `continue` para mostrar los número pares del 1 al 10: 77 | 78 | #include 79 | using namespace std; 80 | 81 | int main(int argc, char *argv[]) { 82 | int cont = 0; 83 | while (cont<10) 84 | { 85 | cont ++; 86 | if (cont % 2 != 0) continue; 87 | cout << cont << " "; 88 | } 89 | return 0; 90 | } 91 | -------------------------------------------------------------------------------- /curso/u19/img/mientras.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/curso/u19/img/mientras.png -------------------------------------------------------------------------------- /curso/u20/README.md: -------------------------------------------------------------------------------- 1 | # Estructuras repetitivas: do - while 2 | 3 | ![mientras](img/repetir.png) 4 | 5 | La instrucción `do-while` ejecuta una secuencia de instrucciones mientras que la condición sea verdadera. 6 | 7 | do 8 | { 9 | instrucciones; 10 | } 11 | while(condición lógica); 12 | 13 | * Al ejecutarse esta instrucción, la secuencia de instrucciones que forma el cuerpo del ciclo se ejecuta una vez y luego se evalúa la condición. Si la condición es verdadera, el cuerpo del ciclo se ejecuta nuevamente y se vuelve a evaluar la condición. Esto se repite hasta que la condición sea falsa. 14 | * Note que, dado que la condición se evalúa al final, las instrucciones del cuerpo del ciclo serán ejecutadas al menos una vez. 15 | * Además, a fin de evitar ciclos infinitos, el cuerpo del ciclo debe contener alguna instrucción que modifique la o las variables involucradas en la condición de modo que en algún momento la condición sea false y se finalice la ejecución del ciclo. 16 | 17 | ## Ejemplo: 18 | 19 | Crea un programa que pida al usuario una contraseña, de forma repetitiva mientras que no introduzca "asdasd". Cuando finalmente escriba la contraseña correcta, se le dirá "Bienvenido" y terminará el programa. 20 | 21 | #include 22 | using namespace std; 23 | 24 | int main(int argc, char *argv[]) { 25 | string secreto, clave; 26 | secreto = "asdasd"; 27 | do 28 | { 29 | cout << "Dime la clave:"; 30 | getline(cin,clave); 31 | if (clave!=secreto) cout << "Clave incorrecta!!!" << endl; 32 | } while(clave!=secreto); 33 | cout << "Bienvenido!!!" << endl; 34 | cout << "Programa terminado"; 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /curso/u20/img/repetir.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/curso/u20/img/repetir.png -------------------------------------------------------------------------------- /curso/u21/README.md: -------------------------------------------------------------------------------- 1 | # Estructuras repetitivas: for 2 | 3 | ![for](img/para.png) 4 | 5 | La instrucción `for` ejecuta una secuencia de instrucciones un número determinado de veces. 6 | 7 | for( = ; ; 8 | { 9 | 10 | } 11 | 12 | 13 | * Al ingresar al bloque, la variable `` recibe el valor `` (1ª parte de la instrucción) y se ejecuta la secuencia de instrucciones que forma el cuerpo del ciclo. 14 | * Luego se incrementa/decrementa la variable como hayamos indicado (3ª parte de la instrucción) y se evalúa la condición (2ª parte de la instrucción). 15 | * Si la condición es verdadera se realiza otra iteración al bucle. 16 | * Si la condición es falsa se termina el bucle. 17 | 18 | ## Ejemplo 19 | 20 | Escribir en pantalla del 1 al 10. 21 | 22 | 23 | #include 24 | using namespace std; 25 | 26 | int main(int argc, char *argv[]) { 27 | int var; 28 | for(var=1;var<=10;var++) 29 | { 30 | cout << var << " "; 31 | } 32 | return 0; 33 | } 34 | 35 | 36 | Escribir en pantalla de 10 al 1. 37 | 38 | #include 39 | using namespace std; 40 | 41 | int main(int argc, char *argv[]) { 42 | int var; 43 | for(var=10;var>=1;var--) 44 | { 45 | cout << var << " "; 46 | } 47 | return 0; 48 | } 49 | 50 | 51 | Escribir los número pares desde el 2 al 10. 52 | 53 | 54 | #include 55 | using namespace std; 56 | 57 | int main(int argc, char *argv[]) { 58 | int var; 59 | for(var=2;var<=10;var=var+2) 60 | { 61 | cout << var << " "; 62 | } 63 | return 0; -------------------------------------------------------------------------------- /curso/u21/img/para.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/curso/u21/img/para.png -------------------------------------------------------------------------------- /curso/u22/README.md: -------------------------------------------------------------------------------- 1 | # Uso específico de variables: contadores, acumuladores e indicadores 2 | 3 | ## Contadores 4 | 5 | Un contador es una variable entera que la utilizamos para contar cuando ocurre un suceso. Un contador: 6 | 7 | * Se **declara**: 8 | 9 | int cont; 10 | 11 | * Se **inicializa** a un valor inicial (Por defecto una variable entera tiene el valor 0, pero no está mal inicializarla de todas formas). 12 | 13 | cont = 0; 14 | 15 | * Se **incrementa**, cuando ocurre el suceso que estamos contado se le suma 1. 16 | 17 | cont = cont + 1; 18 | 19 | De otra forma: 20 | 21 | cont++; 22 | 23 | ### Ejemplo 24 | 25 | Introducir 5 número y contar los números pares. 26 | 27 | 28 | #include 29 | using namespace std; 30 | 31 | int main(int argc, char *argv[]) { 32 | int var,cont,num; 33 | cont=0; 34 | for(var=1;var<=5;var++) 35 | { 36 | cout << "Dime un número:"; 37 | cin >> num; 38 | if(num % 2 == 0) 39 | cont=cont+1; 40 | } 41 | cout << "Has introducido " << cont << " números pares."; 42 | return 0; 43 | } 44 | 45 | ## Acumuladores 46 | 47 | Un acumulador es una variable numérica que permite ir acumulando operaciones. Me permite ir haciendo operaciones parciales. Un acumulador: 48 | 49 | * Se **declara** como una variable entera. 50 | * Se **inicializa** a un valor inicial según la operación que se va a acumular: a 0 si es una suma o a 1 si es un producto. 51 | * Se **acumula** un valor intermedio. 52 | 53 | acum = acum + num; 54 | 55 | ### Ejemplo 56 | 57 | Introducir 5 número y sumar los números pares. 58 | 59 | #include 60 | using namespace std; 61 | 62 | int main(int argc, char *argv[]) { 63 | int var,suma,num; 64 | suma=0; 65 | for(var=1;var<=5;var++) 66 | { 67 | cout << "Dime un número:"; 68 | cin >> num; 69 | if(num % 2 == 0) 70 | suma=suma+num; 71 | } 72 | cout << "La suma de los números pares es " << suma; 73 | return 0; 74 | } 75 | 76 | ## Indicadores 77 | 78 | Un indicador es una variable lógico, que usamos para recordar o indicar algún suceso. Un indicador: 79 | 80 | * Se **declara** como una variable lógica: 81 | 82 | bool indicador; 83 | 84 | * Se **inicializa** a un valor lógico que indica que el suceso no ha ocurrido. 85 | 86 | indicador = false; 87 | 88 | * Cuando ocurre el suceso que queremos recordar cambiamos su valor. 89 | 90 | indicador = true; 91 | 92 | ### Ejemplo 93 | 94 | Introducir 5 número e indicar si se ha introducido algún número par. 95 | 96 | #include 97 | using namespace std; 98 | 99 | int main(int argc, char *argv[]) { 100 | int var,num; 101 | bool indicador; 102 | indicador = false; 103 | for(var=1;var<=5;var++) 104 | { 105 | cout << "Dime un número:"; 106 | cin >> num; 107 | if(num % 2 == 0) 108 | indicador = true; 109 | } 110 | if(indicador) 111 | cout << "Has introducido algún número par"; 112 | else 113 | cout << "No has introducido algún número par"; 114 | return 0; 115 | } 116 | -------------------------------------------------------------------------------- /curso/u23/README.md: -------------------------------------------------------------------------------- 1 | # Ejercicios estructuras repetitivas 2 | 3 | ### Ejercicio 1 4 | 5 | Crea una aplicación que pida un número y calcule su factorial (El factorial de un número es el producto de todos los enteros entre 1 y el propio número y se representa por el número seguido de un signo de exclamación. Por ejemplo 5! = 1x2x3x4x5=120), 6 | 7 | ### Ejercicio 2 8 | 9 | Crea una aplicación que permita adivinar un número. La aplicación genera un número aleatorio del 1 al 100. A continuación va pidiendo números y va respondiendo si el número a adivinar es mayor o menor que el introducido,a demás de los intentos que te quedan (tienes 10 intentos para acertarlo). El programa termina cuando se acierta el número (además te dice en cuantos intentos lo has acertado), si se llega al limite de intentos te muestra el número que había generado. 10 | 11 | ### Ejercicio 3 12 | 13 | Algoritmo que pida números hasta que se introduzca un cero. Debe imprimir la suma y la media de todos los números introducidos. 14 | 15 | ### Ejercicio 4 16 | 17 | Realizar un algoritmo que pida números (se pedirá por teclado la cantidad de números a introducir). El programa debe informar de cuantos números introducidos son mayores que 0, menores que 0 e iguales a 0. 18 | 19 | ### Ejercicio 5 20 | 21 | Algoritmo que pida caracteres e imprima 'VOCAL' si son vocales y 'NO VOCAL' en caso contrario, el programa termina cuando se introduce un espacio. 22 | 23 | ### Ejercicio 6 24 | 25 | Escribir un programa que imprima todos los números pares entre dos números que se le pidan al usuario. 26 | 27 | ### Ejercicio 7 28 | 29 | Realizar una algoritmo que muestre la tabla de multiplicar de un número introducido por teclado. 30 | 31 | ### Ejercicio 8 32 | 33 | Escribe un programa que pida el limite inferior y superior de un intervalo. Si el límite inferior es mayor que el superior lo tiene que volver a pedir. 34 | A continuación se van introduciendo números hasta que introduzcamos el 0. Cuando termine el programa dará las siguientes informaciones: 35 | 36 | * La suma de los números que están dentro del intervalo (intervalo abierto). 37 | * Cuantos números están fuera del intervalo. 38 | * He informa si hemos introducido algún número igual a los límites del intervalo. 39 | 40 | ### Ejercicio 9 41 | 42 | Escribe un programa que dados dos números, uno real (base) y un entero positivo (exponente), saque por pantalla el resultado de la potencia. No se puede utilizar el operador de potencia. 43 | 44 | ### Ejercicio 10 45 | 46 | Algoritmo que muestre la tabla de multiplicar de los números 1,2,3,4 y 5. 47 | 48 | ### Ejercicio 11 49 | 50 | Escribe un programa que diga si un número introducido por teclado es o no primo. Un número primo es aquel que sólo es divisible entre él mismo y la unidad. Nota: Es suficiente probar hasta la raíz cuadrada del número para ver si es divisible por algún otro número. 51 | 52 | ### Ejercicio 12 53 | 54 | Realizar un algoritmo para determinar cuánto ahorrará una persona en un año, si al final de cada mes deposita cantidades variables de dinero; además, se quiere saber cuánto lleva ahorrado cada mes. 55 | 56 | ### Ejercicio 13 57 | 58 | Una empresa tiene el registro de las horas que trabaja diariamente un empleado durante la semana (seis días) y requiere determinar el total de éstas, así como el sueldo que recibirá por las horas trabajadas. 59 | 60 | ### Ejercicio 14 61 | 62 | Una persona se encuentra en el kilómetro 70 de una carretera, otra se encuentra en el km 150, los coches tienen sentido opuesto y tienen la misma velocidad. Realizar un programa para determinar en qué kilómetro de esa carretera se encontrarán. 63 | 64 | ### Ejercicio 15 65 | 66 | Una persona adquirió un producto para pagar en 20 meses. El primer mes pagó 10 €, el segundo 20 €, el tercero 40 € y así sucesivamente. Realizar un algoritmo para determinar cuánto debe pagar mensualmente y el total de 67 | lo que pagó después de los 20 meses. 68 | 69 | ### Ejercicio 16 70 | 71 | Una empresa les paga a sus empleados con base en las horas trabajadas en la semana. Realice un algoritmo para determinar el sueldo semanal de N trabajadores y, además, calcule cuánto pagó la empresa por los N empleados. 72 | 73 | ### Ejercicio 17 74 | 75 | Una empresa les paga a sus empleados con base en las horas trabajadas en la semana. Para esto, se registran los días que trabajó y las horas de cada día. Realice un algoritmo para determinar el sueldo semanal de N trabajadores y además calcule cuánto pagó la empresa por los N empleados. 76 | 77 | ### Ejercicio 18 78 | 79 | Hacer un programa que muestre un cronometro, indicando las horas, minutos y segundos. 80 | 81 | 82 | ### Ejercicio 19 83 | 84 | Realizar un ejemplo de menú, donde podemos escoger las distintas opciones hasta que seleccionamos la opción de "Salir". 85 | 86 | ### Ejercicio 20 87 | 88 | Mostrar en pantalla los N primero número primos. Se pide por teclado la cantidad de números primos que queremos mostrar. 89 | 90 | 91 | # Ejercicios resueltos 92 | 93 | [Ejercicios estructuras repetitivas](../../ejercicios/repetitivas) -------------------------------------------------------------------------------- /curso/u24/README.md: -------------------------------------------------------------------------------- 1 | # Cadenas de caracteres con la clase string 2 | 3 | En el apartado **Introducción a las cadenas de caracteres** estuvimos estudiando varios aspectos de las cadenas en c++ usando la clase `string`: 4 | 5 | * Declaración de las cadenas de caracteres. 6 | * Indexación de los carácteres. 7 | * Concatenación de cadenas con el operador `+`. 8 | * Algunos métodos de la clase string 9 | 10 | Vamos a profundizar en el uso de algunos métodos de clase de `string`. 11 | 12 | ## Principales métodos de la clase string 13 | 14 | Vamos a ver los ejemplos a partir de esta cadena: 15 | 16 | string cadena="informática"; 17 | 18 | * `clear()`: Borra todos los caracteres de una cadena. Ejemplo: 19 | 20 | cadena.clear(); 21 | cout << cadena; //No muestra nada, la cadena está vacía 22 | 23 | * `length()` o `size()`: Devuelve la cantidad de caracteres que tiene una cadena. Ejemplo: 24 | 25 | cout << "La cadena " << cadena << " tiene " << cadena.length() << " caracteres."; 26 | La salida sería: 27 | 28 | La cadena informática tiene 11 caracteres. 29 | 30 | * `front()` y `back()`: Devuelve el primer carácter y el último de una cadena. Ejemplo: 31 | 32 | cout << "Primer carácter: " << cadena.front() << endl; //Igual que cadena[0] 33 | cout << "Último carácter: " << cadena.back() << endl; // Igual que cadena[[cadena.length() - 1]] 34 | 35 | La salida sería: 36 | 37 | Primer carácter: i 38 | Último carácter: a 39 | 40 | * `append()`: Nos permite añadir otra cadena al final de la primera. Ejemplo: 41 | 42 | cadena.append(" moderna"); //Es lo mismo que cadena += " moderna"; 43 | cout << cadena; 44 | 45 | La salida sería: 46 | 47 | informática moderna 48 | 49 | Para añadir una variable de tipo carácter tengo que indicar el número de carácteres: 50 | 51 | char car='0'; 52 | cadena.append(1,car); 53 | cout << cadena; 54 | 55 | La salida sería: 56 | 57 | informática moderna0 58 | 59 | * `find()`: Busca la aparición de una subcadena dentro de una cadena. Devuelve la posición de la subcadena encontrada. Si no la encuentra devuelve -1. Ejemplo: 60 | 61 | if(cadena.find("i")!=-1) 62 | cout << "Posición del primer carácter i: " << cadena.find("i") << endl; 63 | cout << "Posición del segundo carácter i: " << cadena.find("i",1) << endl; 64 | 65 | La salida sería: 66 | 67 | Posición del primer carácter i: 0 68 | Posición del segundo carácter i: 8 69 | 70 | * `substr()`: Devuelve una subcadena de una cadena. Si utilizo `substr(a,b)` obtiene una sebcadena desde el índice `a` que tiene `b` caracteres, si utilizo `substr(a)` obtengo una subcadena desde el índice `a` hasta el final. y Ejemplo: 71 | 72 | string subcad; 73 | subcad=cadena.substr(2,3); 74 | cout << subcad << endl; 75 | subcad=cadena.substr(5); 76 | cout << subcad << endl; 77 | 78 | La salida sería: 79 | 80 | for 81 | mática 82 | 83 | * `replace()`: Reemplaza parte de una cadena por otra. Se utiliza como `replace(a, b, str)` que remplaza `b` caracteres desde el índice `a` por la cadena `str`. Ejemplo: 84 | 85 | cadena.replace(6,5,"ación"); 86 | cout << cadena << endl; 87 | 88 | La salida sería: 89 | 90 | información 91 | 92 | ## Ejemplo completo 93 | 94 | #include 95 | using namespace std; 96 | 97 | int main(int argc, char *argv[]) { 98 | string cadena="informática"; 99 | 100 | //Borramos los caracteres de la cadena 101 | cadena.clear(); 102 | cout << cadena; //No muestra nada 103 | //Volvemos a inicializar con un valor 104 | cadena="informática"; 105 | 106 | //Longitud de la cadena 107 | cout << "La cadena " << cadena << " tiene " << cadena.length() << " caracteres." << endl; 108 | 109 | //Primer y último carácter 110 | cout << "Primer carácter: " << cadena.front() << endl; //Igual que cadena[0] 111 | cout << "Último carácter: " << cadena.back() << endl; // Igual que cadena[[cadena. length() - 1]] 112 | 113 | //Añadir cadenas 114 | cadena.append(" moderna"); //Es lo mismo que cadena += " moderna"; 115 | cout << cadena << endl; 116 | 117 | //Añadimos un carácter 118 | char car='0'; 119 | cadena.append(1,car); 120 | cout << cadena << endl; 121 | 122 | //Volvemos a inicializar con un valor 123 | cadena="informática"; 124 | 125 | //Buscar caracteres 126 | if(cadena.find("i")!=-1) 127 | cout << "Posición del primer carácter i: " << cadena.find("i") << endl; 128 | cout << "Posición del segundo carácter i: " << cadena.find("i",1) << endl; 129 | 130 | //Extraer subcadenas 131 | string subcad; 132 | subcad=cadena.substr(2,3); 133 | cout << subcad << endl; 134 | subcad=cadena.substr(5); 135 | cout << subcad << endl; 136 | 137 | // Reemplazar parte de la cadena 138 | cadena.replace(6,5,"ación"); 139 | cout << cadena << endl; 140 | 141 | return 0; 142 | } 143 | -------------------------------------------------------------------------------- /curso/u25/README.md: -------------------------------------------------------------------------------- 1 | # Ejercicios cadena de caracteres 2 | 3 | ### Ejercicio 1 4 | 5 | Escribir por pantalla cada carácter de una cadena introducida por teclado. 6 | 7 | ### Ejercicio 2 8 | 9 | Realizar un programa que comprueba si una cadena leída por teclado comienza por una subcadena introducida por teclado. 10 | 11 | ### Ejercicio 3 12 | 13 | Pide una cadena y un carácter por teclado (valida que sea un carácter) y muestra cuantas veces aparece el carácter en la cadena. 14 | 15 | ### Ejercicio 4 16 | 17 | Suponiendo que hemos introducido una cadena por teclado que representa una frase (palabras separadas por espacios), realiza un programa que cuente cuantas palabras tiene. 18 | 19 | ### Ejercicio 5 20 | 21 | Si tenemos una cadena con un nombre y apellidos, realizar un programa que muestre las iniciales en mayúsculas. 22 | 23 | ### Ejercicio 6 24 | 25 | Realizar un programa que dada una cadena de caracteres por caracteres, genere otra cadena resultado de invertir la primera. 26 | 27 | ### Ejercicio 7 28 | 29 | Pide una cadena y dos caracteres por teclado (valida que sea un carácter), sustituye la aparición del primer carácter en la cadena por el segundo carácter. 30 | 31 | ### Ejercicio 8 32 | 33 | Realizar un programa que lea una cadena por teclado y convierta las mayúsculas a minúsculas y viceversa. 34 | 35 | ### Ejercicio 9 36 | 37 | Realizar un programa que compruebe si una cadena **contiene** una subcadena. Las dos cadenas se introducen por teclado. 38 | 39 | ### Ejercicio 10 40 | 41 | Introducir una cadena de caracteres e indicar si es un palíndromo. Una palabra palíndroma es aquella que se lee igual adelante que atrás. 42 | 43 | # Ejercicios resueltos 44 | 45 | [Ejercicios cadenas de caracteres](../../ejercicios/cadenas) -------------------------------------------------------------------------------- /curso/u26/README.md: -------------------------------------------------------------------------------- 1 | # Introducción a los arrays 2 | 3 | ## Estructura de datos 4 | 5 | Hasta ahora, para hacer referencia a un dato utilizábamos una variable. El problema se plantea cuando tenemos gran cantidad de datos que guardan entre sí una relación. No podemos utilizar una variable para cada dato. 6 | 7 | Para resolver estas dificultades se agrupan los datos en un mismo conjunto, estos conjuntos reciben el nombre de **estructura de datos**. 8 | 9 | ## Arrays 10 | 11 | Un array es una estructura de datos con elementos homogéneos, del mismo tipo, numérico o alfanumérico, reconocidos por un nombre en común. Para referirnos a cada elemento del array usaremos un índice (empezamos a contar por 0). 12 | 13 | ## Declaración de arrays 14 | 15 | Para declarar un array debemos indicar el número de elementos que va a tener el array. 16 | 17 | [N1][N2]...[Nn] 18 | 19 | Esta instrucción define un array con el nombre indicado en y `n` dimensiones. Los `n` parámetros indican la cantidad de dimensiones y el valor máximo de cada una de ellas. La cantidad de dimensiones puede ser una o más, y la máxima cantidad de elementos debe ser una expresión numérica positiva. 20 | 21 | Por ejemplo definimos un array de una dimensión (también llamado **vector**) de 10 elementos enteros. 22 | 23 | int vector[10]; 24 | 25 | Otro ejemplo, definir una array de dos dimensiones (también llamado **matriz** o **tabla**) de 3 filas y cuatro columnas de cadenas. 26 | 27 | string tabla[3][4]; 28 | 29 | Para acceder a un elemento de un array se utiliza un índice. El primer elemento está en la posición 0. 30 | 31 | Para asignar un valor a un elemento del vector: 32 | 33 | vector[0]=10; 34 | 35 | Para mostrar el primer elemento del vector: 36 | 37 | cout << vector[0]; 38 | 39 | Otro ejemplo asignamos y mostramos el segundo elemento de la segunda fila de la tabla: 40 | 41 | tabla[1][1] = "Hola"; 42 | cout << tabla[1][1]; 43 | 44 | ## Características de los arrays 45 | 46 | * Un array es una estructura estática. Si cre un array de enteros con 10 elementos, se reservarán en memoria el espacio para guardar los 10 enteros, y durante la ejecución del programa ese tamaño no podrá cambiar. 47 | * Al acceder o al cambiar el valor de un elemento de un array no se comprueba que estemos accediendo o modificando a un elemento del array. Es decir si tenemos un array llamado `vector` de 10 enteros, esta instrucción no producirá error: 48 | 49 | vector[10] = 3; 50 | 51 | La última posición del vector es la 9, sin embargo estamos modificando la posición 10, es decir estamos modificando una posición de memoria que no corresponde al vector. 52 | 53 | Del mismo modo puedo mostrar valores que están guardados en memoria y no corresponden al vector: 54 | 55 | cout << vector[15]; 56 | -------------------------------------------------------------------------------- /curso/u27/README.md: -------------------------------------------------------------------------------- 1 | # Arrays unidimensionales: Vectores 2 | 3 | Un **vector** es una array unidimensional. Para declarar un vector de 10 enteros: 4 | 5 | int vector[10]; 6 | 7 | Podemos inicializar el vector a declararlo: 8 | 9 | int vector[10]={1,2,3,4,5,6,7,8,9,10}; 10 | 11 | Para acceder a cada uno de los elementos del vector utilizamos un índice. el primer elemento se accede con el índice 0. Podemos trabajar individualmente con cada uno de los elementos: 12 | 13 | vector[0]=10; 14 | cout << vector[0]; 15 | 16 | **CUIDADO:** El acceso a un elemento que no existe **no** producirá un error, por ejemplo: 17 | 18 | vector[10]=10; 19 | 20 | ## Recorrido de un vector 21 | 22 | Vamos a inicializar todos los elementos de un vector. Para ello vamos a **recorrer** el vector e inicializar cada elemento con un valor ,por ejemplo lo vamos a inicializar a 0. Para recorrer un vector utilizamos un bucle `for`: 23 | 24 | for(i=0;i<10;i++) 25 | array[i]=0; 26 | 27 | Podríamos recorrer el vector para mostrar el valor de los elementos: 28 | 29 | for(i=0;i<10;i++) 30 | cout << array[i]; 31 | 32 | ### Ejemplo 33 | 34 | Inicializar un vector de 5 cadenas a partir de los datos pedidos por teclado y posterior mostrarlos en pantalla y mostrar su longitud. 35 | 36 | #include 37 | using namespace std; 38 | 39 | int main(int argc, char *argv[]) { 40 | string vector[5]; 41 | int i; 42 | 43 | for(i=0;i<5;i++) 44 | { 45 | cout << "Dime la cadena número "<< i+1<< ":"; 46 | cin >> vector[i]; 47 | } 48 | cout << "Las cadenas y sus longitudes" << endl; 49 | for(i=0;i<5;i++) 50 | { 51 | cout << vector[i] << ": " << vector[i].size() << endl; 52 | } 53 | return 0; 54 | } 55 | 56 | -------------------------------------------------------------------------------- /curso/u28/README.md: -------------------------------------------------------------------------------- 1 | # Cadenas de caracteres estilo C 2 | 3 | La cadena de caracteres de estilo C se originó en el lenguaje C y continúa siendo compatible con C++. 4 | 5 | En C las cadenas de caracteres son en realidad un vector (array) de elementos del tipo carácter. La característica principal de este vector es que usamos un carácter especial llamado nulo (`\0`) para indicar el final de la cadena. 6 | 7 | La siguiente declaración e inicialización crean una cadena que consiste en la palabra "Hola". 8 | 9 | char cadena[6] = {'H', 'o', 'l', 'a', '\0'}; 10 | 11 | Otra forma de inicializarlo sería: 12 | 13 | char cadena[]="Hola"; 14 | 15 | En ambas declaraciones, la índice 4 será igual a `\0`: 16 | 17 | cout << cadena[4]; 18 | 19 | ## Librería cstring 20 | 21 | En la librería `cstring` tenemos definidas varias funciones para trabajar con las cadenas de caracteres de estilo C: 22 | 23 | * `strcpy(cad1, cad2)`: Copia la cadena cad2 en la cadena cad1. 24 | * `strcat(cad1, cad2)`: Concatena la cadena cad2 con la cadena cad1. 25 | * `strlen(cad1)`: Devuelve el tamaño de la cadena cad1; 26 | * `strcmp(cad1, cad2)`: compara cadenas. Devuelve 0 si cad1 y cad2 son iguales; un número menor que 0 si `cad1cad2`. 27 | 28 | Veamos un ejemplo: 29 | 30 | #include 31 | #include 32 | 33 | using namespace std; 34 | 35 | int main () { 36 | 37 | char str1[10] = "Hola"; 38 | char str2[10] = "Mundo"; 39 | char str3[10]; 40 | int len; 41 | 42 | // Copia str1 en str3 43 | strcpy( str3, str1); 44 | cout << "strcpy( str3, str1) : " << str3 << endl; 45 | 46 | // Concatena str1 y str2 47 | strcat( str1, str2); 48 | cout << "strcat( str1, str2): " << str1 << endl; 49 | 50 | // Longitud de str1 después de concatenar 51 | len = strlen(str1); 52 | cout << "strlen(str1) : " << len << endl; 53 | 54 | return 0; 55 | } -------------------------------------------------------------------------------- /curso/u29/README.md: -------------------------------------------------------------------------------- 1 | # Arrays multidimensionales: Tablas 2 | 3 | Una **tabla** en un array bidimensional. La primera dimensión indica el número de filas y el segundo el número de columnas. 4 | 5 | int tabla[3][4]; 6 | 7 | Hemos definido una tabla de enteras con 3 filas y 4 columnas, por tanto tenemos 12 elementos. 8 | 9 | Para acceder a cada uno de lo elemento tenemos que indicar la fila y la columna en la que se encuentra, siempre empezando por el 0. Por ejemplo para inicializar el elemento que esta en la primera fila y la segunda columna sería: 10 | 11 | tabla[0][1] = 10; 12 | 13 | El acceso a un elemento que no existe no producirá un error. 14 | 15 | ## Recorrido de una tabla 16 | 17 | Para recorrer todos los elementos de una tabla necesitamos utilizar dos bucles anidados. Normalmente el exterior nos va a permitir recorrer las filas y el interior las columnas. Por ejemplo para inicializar todos los elementos a 0, quedaría: 18 | 19 | for(filas=0;filas<3;filas++) 20 | { 21 | for(columnas=0;columnas<4;columnas++) 22 | { 23 | tabla[filas][columnas]=0; 24 | } 25 | } 26 | 27 | De forma similar podríamos recorrer la tabla para mostrar los elementos: 28 | 29 | for(filas=0;filas<3;filas++) 30 | { 31 | for(columnas=0;columnas<4;columnas++) 32 | { 33 | cout << tabla[filas][columnas]; 34 | } 35 | } 36 | 37 | ### Ejemplo 38 | 39 | Inicializar una tabla con los números del 1 al 5, sus cuadrados y sus cubos. Por lo tanto tenemos que definir una tabla con 5 filas y 3 columnas. Muestra los datos: 40 | 41 | #include 42 | #include 43 | using namespace std; 44 | 45 | int main(int argc, char *argv[]) { 46 | int tabla[5][3]; 47 | int filas,columnas; 48 | for(filas=0;filas<5;filas++) 49 | { 50 | tabla[filas][0]=filas+1; 51 | tabla[filas][1]=pow(filas+1,2); 52 | tabla[filas][2]=pow(filas+1,3); 53 | } 54 | 55 | for(filas=0;filas<5;filas++) 56 | { 57 | for(columnas=0;columnas<3;columnas++) 58 | { 59 | cout << tabla[filas][columnas] << " "; 60 | } 61 | cout << endl; 62 | } 63 | return 0; 64 | } 65 | 66 | ## Arrays multidimensionales 67 | 68 | Los arrays pueden tener las dimensiones que deseemos, por ejemplo podemos tener una array de tres dimensiones: 69 | 70 | int tabla[4][4][4]; 71 | 72 | Y podríamos inicializar el primer elemento como: 73 | 74 | tabla[0][0][0]=10; 75 | 76 | Necesitaríamos tres bucles para recorrer un array de tres dimensiones: 77 | 78 | for(i=0;i<4;i++) 79 | { 80 | for(j=0;j<4;j++) 81 | { 82 | for(k=0;k<4;k++) 83 | { 84 | tabla[i][j][k]=0; 85 | } 86 | } 87 | } 88 | 89 | -------------------------------------------------------------------------------- /curso/u30/README.md: -------------------------------------------------------------------------------- 1 | # Ejercicios de arrays 2 | 3 | ### Ejercicio 1 4 | 5 | Realizar un programa que defina un vector llamado "vector_numeros" de 10 enteros, a continuación lo inicialice con valores aleatorios (del 1 al 10) y posteriormente muestre en pantalla cada elemento del vector junto con su cuadrado y su cubo. 6 | 7 | ### Ejercicio 2 8 | 9 | Crear un vector de 5 elementos de cadenas de caracteres, inicializa el vector con datos leídos por el teclado. Copia los elementos del vector en otro vector pero en orden inverso, y muéstralo por la pantalla. 10 | 11 | ### Ejercicio 3 12 | 13 | Se quiere realizar un programa que lea por teclado las 5 notas obtenidas por un alumno (comprendidas entre 0 y 10). A continuación debe mostrar todas las notas, la nota media, la nota más alta que ha sacado y la menor. 14 | 15 | ### Ejercicio 4 16 | 17 | Programa que declare un vector de diez elementos enteros y pida números 18 | para rellenarlo hasta que se llene el vector o se introduzca un número 19 | negativo. Entonces se debe imprimir el vector (sólo los elementos introducidos). 20 | 21 | ### Ejercicio 5 22 | 23 | Hacer un programa que inicialice un vector de números con valores aleatorios, y posterior ordene los elementos de menor a mayor. 24 | 25 | ### Ejercicio 6 26 | 27 | Crea un programa que pida un número al usuario un número de mes (por ejemplo, el 4) y diga cuántos días tiene (por ejemplo, 30) y el nombre del mes. Debes usar un vector. Para simplificarlo vamos a suponer que febrero tiene 28 días. 28 | 29 | ### Ejercicio 7 30 | 31 | Programa que declare tres vectores 'vector1', 'vector2' y 'vector3' de cinco enteros cada uno, pida valores para 'vector1' y 'vector2' y calcule vector3=vector1+vector2. 32 | 33 | ### Ejercicio 8 34 | 35 | Queremos guardar los nombres y la edades de los alumnos de un curso. Realiza un programa que introduzca el nombre y la edad de cada alumno. El proceso de lectura de datos terminará cuando se introduzca como nombre un asterisco (`*`) Al finalizar se mostrará los siguientes datos: 36 | 37 | * Todos lo alumnos mayores de edad. 38 | * Los alumnos mayores (los que tienen más edad) 39 | 40 | ### Ejercicio 9 41 | 42 | Queremos guardar la temperatura mínima y máxima de 5 días. realiza un programa que de la siguiente información: 43 | 44 | * La temperatura media de cada día 45 | * Los días con menos temperatura 46 | * Se lee una temperatura por teclado y se muestran los días cuya temperatura máxima coincide con ella. si no existe ningún día se muestra un mensaje de información. 47 | 48 | ### Ejercicio 10 49 | 50 | Diseñar el algoritmo correspondiente a un programa, que: 51 | 52 | * Crea una tabla bidimensional de longitud 5x5 y nombre 'matriz'. 53 | * Carga la tabla con valores numéricos enteros. 54 | * Suma todos los elementos de cada fila y todos los elementos de cada columna visualizando los resultados en pantalla. 55 | 56 | ### Ejercicio 11 57 | 58 | Diseñar el algoritmo correspondiente a un programa, que: 59 | 60 | * Crea una tabla bidimensional de longitud 5x5 y nombre 'diagonal'. 61 | * Carga la tabla de forma que los componentes pertenecientes a la diagonal de la matriz tomen el valor 1 y el resto el valor 0. 62 | * Muestra el contenido de la tabla en pantalla. 63 | 64 | ### Ejercicio 12 65 | 66 | Diseñar el algoritmo correspondiente a un programa, que: 67 | * Crea una tabla bidimensional de longitud 5x15 y nombre 'marco'. 68 | * Carga la tabla con dos únicos valores 0 y 1, donde el valor uno ocupará las posiciones o elementos que delimitan la tabla, es decir, las más externas, mientras que el resto de los elementos contendrán el valor 0. 69 | 70 | 111111111111111 71 | 100000000000001 72 | 100000000000001 73 | 100000000000001 74 | 111111111111111 75 | 76 | * Visualiza el contenido de la matriz en pantalla. 77 | 78 | ### Ejercicio 13 79 | 80 | De una empresa de transporte se quiere guardar el nombre de los conductores que tiene, y los kilómetros que conducen cada día de la semana. 81 | 82 | Para guardar esta información se van a utilizar dos arreglos: 83 | 84 | * Nombre: Vector para guardar los nombres de los conductores. 85 | * kms: Tabla para guardar los kilómetros que realizan cada día de la semana. 86 | 87 | Se quiere generar un nuevo vector ("total_kms") con los kilómetros totales que realza cada conductor. 88 | 89 | Al finalizar se muestra la lista con los nombres de conductores y los kilómetros que ha realizado. 90 | 91 | 92 | ### Ejercicio 14 93 | 94 | Crear un programa que lea los precios de 5 artículos y las cantidades vendidas por una empresa en sus 4 sucursales. Informar: 95 | 96 | * Las cantidades totales de cada articulo. 97 | * La cantidad de artículos en la sucursal 2. 98 | * La cantidad del articulo 3 en la sucursal 1. 99 | * La recaudación total de cada sucursal. 100 | * La recaudación total de la empresa. 101 | * La sucursal de mayor recaudación. 102 | 103 | ### Ejercicio 15 104 | 105 | Crear un programa de ordenador para gestionar los resultados de la quiniela de fútbol. Para ello vamos a utilizar dos tablas: 106 | 107 | * Equipos: Que es una tabla de cadenas donde guardamos en cada columna el nombre de los equipos de cada partido. En la quiniela se 108 | indican 15 partidos. 109 | * Resultados: Es una tabla de enteros donde se indica el resultado. También tiene dos columnas, en la primera se guarda el número de goles del equipo que está guardado en la primera columna 110 | de la tabla anterior, y en la segunda los goles del otro equipo. 111 | 112 | El programa ira pidiendo los nombres de los equipos de cada partido y el resultado del partido, a continuación se imprimirá la quiniela de esa jornada. 113 | 114 | ¿Qué modificación habría que hacer en las tablas para guardar todos los resultados de todas las jornadas de la temporada? 115 | 116 | # Ejercicios resueltos 117 | 118 | [Ejercicios de arrays](../../ejercicios/arrays) 119 | -------------------------------------------------------------------------------- /curso/u31/README.md: -------------------------------------------------------------------------------- 1 | # Introducción a los punteros (I) 2 | 3 | Hemos estudiado que las variables nos permiten guardar valores de distintos tipos en la memoria RAM del ordenador. Cada posición de memoria donde guardamos un dato tiene una dirección de memoria que nos permite localizar ea posición. 4 | 5 | Es decir al trabajar con variables tenemos que tener en cuenta 5 elementos: 6 | 7 | * Nombre 8 | * Tipo de datos 9 | * Tamaño 10 | * Valor 11 | * Dirección de memoria 12 | 13 | Veamos un ejemplo: 14 | 15 | ![variable](img/variable.png) 16 | 17 | Si, por ejemplo definimos dos enteros: 18 | 19 | int m=121, n=1523; 20 | 21 | Tendremos 4 posiciones de memoria (el tipo entero se guarda en dos posiciones) donde se guarda el valor de las dos variables, cada posición tiene una dirección de memoria consecutiva: 22 | 23 | ![variable](img/enteros.png) 24 | 25 | ## Los operadores & y * 26 | 27 | ![variable](img/operadores.png) 28 | 29 | Tenemos dos operadores para trabajar sobre las variables: 30 | 31 | * `&`: Nos devuelve **la dirección de memoria** de una variable. 32 | * `*`: Nos devuelve **el contenido** de una determinada dirección de memoria. 33 | 34 | El operador `&` se ejecuta sobre una variable, el operador `*` se ejecuta sobre una dirección de memoria (por eso en la imagen vemos `*&`). 35 | 36 | Veamos un ejemplo: 37 | 38 | 39 | using namespace std; 40 | 41 | int main(int argc, char *argv[]) { 42 | int edad=10; 43 | 44 | cout << &edad << endl; //Mostramos la dirección de memoria donde se guarda la variable 45 | cout << *&edad << endl; //Mostramos el contenido de la variable guardada en esa dirección 46 | *&edad = 12; //Podemos cambiar el contenido de la variable de esa dirección. 47 | cout << edad << endl; //Comprobamos que la variable ha cambiado 48 | return 0; 49 | } 50 | 51 | 52 | **Nota: Las imágenes de esta unidad se han obtenido de: https://www.slideshare.net/CesarOsorio2/punteros-y-funciones** -------------------------------------------------------------------------------- /curso/u31/img/enteros.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/curso/u31/img/enteros.png -------------------------------------------------------------------------------- /curso/u31/img/operadores.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/curso/u31/img/operadores.png -------------------------------------------------------------------------------- /curso/u31/img/variable.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/curso/u31/img/variable.png -------------------------------------------------------------------------------- /curso/u32/README.md: -------------------------------------------------------------------------------- 1 | # Introducción a los punteros (II) 2 | 3 | ## ¿Qué son los punteros? 4 | 5 | En el apartado anterior hemos aprendido los operadores `&` y `*` que nos permiten trabajar con las variables.El operador `*` ("contenido de una dirección de memoria) tiene que trabajar sobre posiciones de memoria, pero ¿podemos guardar la dirección de memoria de una variable en otra variable? 6 | 7 | Un **puntero** es una variable especial en la que podemos guardar la dirección de memoria de otra variable. Se dice, entonces, que el puntero "apunta" a la variable y podemos acceder al contenido de esa variable (acceder y modificar) utilizando el puntero. 8 | 9 | ![puntero](img/puntero.png) 10 | 11 | ## Definición de puntero 12 | 13 | Para definir un puntero hay que indicar el tipo de datos de la variable a la que va a apuntar y utilizar el `*` en su definición. Para crear un puntero que apunte a una variable entera: 14 | 15 | int *ptr; 16 | 17 | Cuando en un puntero guardamos la dirección de memoria de una variable, se dice que el puntero "apunta" a esa variable. Desde ese momento podemos acceder o cambiar el contenido de la variable trabajando con el puntero. Veamos un ejemplo: 18 | 19 | #include 20 | using namespace std; 21 | 22 | int main(int argc, char *argv[]) { 23 | int edad=10; 24 | int *ptr; //Definimos un puntero a entero 25 | 26 | ptr = &edad; //Guardamos la dirección de memoria de la variable edad en el puntero 27 | 28 | cout << *ptr << endl; //Mostramos el contenido de la variable apuntada por el puntero 29 | *ptr = 12; //Podemos cambiar el contenido de la variable apuntada por el puntero. 30 | cout << edad << endl; //Comprobamos que la variable ha cambiado 31 | return 0; 32 | } 33 | 34 | Los punteros son una herramienta muy potente en c++ y nos aporta mucha flexibilidad a la hora de trabajar con variables. en este curso hemos hecho una introducción a los punteros, pero se puede profundizar mucho más en ellos. De las distintas funcionalidades que nos ofrecen los punteros, en este curso lo vamos a utilizar en las próximas unidades para trabajar con parámetros de entrada y salida en las funciones. 35 | 36 | **Nota: Las imágenes de esta unidad se han obtenido de: https://www.slideshare.net/CesarOsorio2/punteros-y-funciones** -------------------------------------------------------------------------------- /curso/u32/img/puntero.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/curso/u32/img/puntero.png -------------------------------------------------------------------------------- /curso/u33/README.md: -------------------------------------------------------------------------------- 1 | # Introducción a las referencias en C++ 2 | 3 | ## ¿Qué son los referencias? 4 | 5 | La referencia en C++ es una característica específica de este lenguaje y que tiene un comportamiento muy particular; lo que se logra con esto es darle un alias a una variable que ya se encuentra en existencia para, de esta forma, lograr realizar cambios sobre dicha variable por medio de ese alias. En términos más sencillos, solo es darle otro nombre a la misma variable. 6 | 7 | Las referencias no funcionan como los punteros pero nos puedes servir para lo mismo: modificar o acceder al valor de una variable, utilizando otra variable. Veamos un ejemplo: 8 | 9 | #include 10 | using namespace std; 11 | 12 | int main(int argc, char *argv[]) { 13 | int edad = 10; 14 | int &ref_edad=edad; 15 | ref_edad=15; 16 | cout << edad; 17 | 18 | return 0; 19 | } 20 | 21 | 22 | Como comentamos en la unidad anterior, las referencias la vamos a utilizar en este curso para trabajar con parámetros de entrada y salida cuando estudiamos las funciones. -------------------------------------------------------------------------------- /curso/u34/README.md: -------------------------------------------------------------------------------- 1 | # Tipos de datos complejos: estructuras 2 | 3 | El lenguaje C++ nos permite declarar nuevos tipos de datos. Las estructuras nos permiten declarar nuevos tipos de datos complejos. 4 | 5 | Una estructura es un conjunto de una o más variables, de distinto tipo, agrupadas bajo un mismo nombre para que su manejo sea más sencillo. 6 | 7 | Para definir una estructura usamos la siguiente sintaxis (hay que hacerlo antes del programa principal): 8 | 9 | struct tipo_estructura 10 | { 11 | tipo_variable nombre_variable1; 12 | tipo_variable nombre_variable2; 13 | tipo_variable nombre_variable3; 14 | ... 15 | }; 16 | 17 | Por ejemplo si queremos definir un nuevo tipo de datos para guardar los datos de un libro lo haríamos de la siguiente manera: 18 | 19 | struct libro 20 | { 21 | int id; 22 | string titulo; 23 | string autor; 24 | }; 25 | 26 | Posteriormente en el programa principal podemos crear nuevas variables del tipo `libro`: 27 | 28 | struct libro mi_libro; 29 | struct libro libreria[100]; 30 | 31 | Podemos inicializar la variable de tipo estructura a la hora de inicializarla: 32 | 33 | struct libro mi_libro2 = {1,"El Señor de los anillos","JR Tolkien"}; 34 | 35 | Para acceder a las variables que forman parte de una estructura usamos el operador `.`: 36 | 37 | mi_libro.id = 10; 38 | cout << mi_libro2.autor; 39 | 40 | Veamos un ejemplo: 41 | 42 | #include 43 | using namespace std; 44 | 45 | struct libro 46 | { 47 | int id; 48 | string titulo; 49 | string autor; 50 | }; 51 | 52 | int main(int argc, char *argv[]) { 53 | 54 | struct libro mi_libro; 55 | cout << "Introduce el identificador:"; 56 | cin >> mi_libro.id; 57 | cin.ignore(); 58 | cout << "Introduce el título:"; 59 | getline(cin,mi_libro.titulo); 60 | cout << "Introduce el autor:"; 61 | getline(cin,mi_libro.autor); 62 | 63 | 64 | cout << "Identificador: "<< mi_libro.id < 73 | using namespace std; 74 | # define ALUMNOS 20 75 | struct alumno 76 | { 77 | string nombre; 78 | int edad; 79 | }; 80 | 81 | int main(int argc, char *argv[]) { 82 | int i; 83 | struct alumno clase[ALUMNOS]; 84 | 85 | for(i=0;i> clase[i].edad; 91 | cin.ignore(); 92 | } 93 | cout << "ALUMNOS" << endl; 94 | for(i=0;inum2) 39 | return num1; 40 | else 41 | return num2; 42 | } 43 | 44 | Hemos definido una función que va a devolver una variable entera. Para devolver valores usamos la instrucción `return`. Esta instrucción devuelve el valor indicado y termina la ejecución de la función. 45 | 46 | Para utilizar dicha función en el programa principal, primero debemos definir **el prototipo de la función** antes del programa principal para que la podamos utilizar, el programa quedaría: 47 | 48 | #include 49 | using namespace std; 50 | 51 | int CalcularMaximo(int num1,int num2); 52 | 53 | int main(int argc, char *argv[]) { 54 | int numero1,numero2,num_maximo; 55 | cout << "Dime el número1:"; 56 | cin >> numero1; 57 | cout << "Dime el número2:"; 58 | cin >> numero2; 59 | num_maximo = CalcularMaximo(numero1,numero2); 60 | cout << "El máximo es " << num_maximo; 61 | return 0; 62 | } 63 | 64 | int CalcularMaximo(int num1,int num2) 65 | { 66 | if(num1>num2) 67 | return num1; 68 | else 69 | return num2; 70 | } 71 | 72 | ## Ejemplo de procedimiento 73 | 74 | Vamos a escribir un procedimiento que recibe una cadena de caracteres y lo muestra en pantalla subrayado. No devuelve ningún valor. 75 | 76 | #include 77 | using namespace std; 78 | void Subrayar(string cad); 79 | 80 | int main(int argc, char *argv[]) { 81 | string nombre; 82 | cout << "Dame un nombre:"; 83 | getline(cin,nombre); 84 | Subrayar(nombre); 85 | return 0; 86 | } 87 | 88 | void Subrayar(string cad) 89 | { 90 | int i; 91 | cout << cad << endl; 92 | for (i=0;i 6 | using namespace std; 7 | 8 | int CalcularMaximo(int num1,int num2); 9 | 10 | int main(int argc, char *argv[]) { 11 | int numero1,numero2,num_maximo; 12 | cout << "Dime el número1:"; 13 | cin >> numero1; 14 | cout << "Dime el número2:"; 15 | cin >> numero2; 16 | num_maximo = CalcularMaximo(numero1,numero2); 17 | cout << "El máximo es " << num_maximo; 18 | return 0; 19 | } 20 | 21 | int CalcularMaximo(int num1,int num2) 22 | { 23 | if(num1>num2) 24 | return num1; 25 | else 26 | return num2; 27 | } 28 | 29 | ## Devolución de resultados 30 | 31 | Cuando la función finaliza hemos dicho que se devuelve un valor (Recuerda que los procedimientos no devuelven valor). Para devolver un valor usamos la instrucción `return` seguida del valor a devolver. Una función puede tener varias instrucciones `return`, cuando se ejecuta una se devuelve el valor y se termina la ejecución de la función. 32 | 33 | ## Llamada a la función 34 | 35 | Para llamar a una función se debe utilizar su nombre y entre paréntesis los parámetros reales que se mandan. La llamada a una función se puede considerar una expresión cuyo valor y tipo es el retornado por la función. Evidentemente si estamos llamando un procedimiento, la llamada no tendrá ningún tipo. 36 | 37 | Ejemplos de llamadas: 38 | 39 | num1 = CalcularMaximo(5,6); 40 | cout << CalcularMaximo(1,2); 41 | ... 42 | 43 | ## Ámbito de variables 44 | 45 | Las variables definidas en la función no existen en otras funciones o el programa principal. Igualmente las variables del programa principal no existen en la función. 46 | 47 | Si tuvieramos alguna variables definida en la función no existiría en el programa principalmente. Igualmente la variable `numero1`` definida en el programa principal no existe en la función. 48 | 49 | 50 | ## Parámetros formales y reales 51 | 52 | * **Parámetros formales**: Son las variables que recibe la función, se crean al definir la función. Su contenido lo recibe al realizar la llamada a la función de los parámetro reales. Los parámetros formales son variables locales dentro de la función. 53 | 54 | * **Parámetros reales**: Son la expresiones que se utilizan en la llamada de la función, sus valores se copiarán en los parámetros formales. 55 | 56 | ## Paso de parámetros 57 | 58 | * **Paso por valor**: El valor de los parámetros reales se copian en los parámetros formales, por lo tanto una modificación de algún parámetro formal no modifica el parámetro real. 59 | 60 | * **Paso por puntero**: Mandaremos a la función un puntero (parámetro formal) al parámetro real y de esta manera la podremos modificar. Esto implica que si modificamos el parámetro formal se modificará el parámetro real. 61 | 62 | * **Paso por referencia**: La referencia en C++ es una característica específica de este lenguaje. Nos permite darle un alias a una variable que ya se encuentra en existencia para, de esta forma, lograr realizar cambios sobre dicha variable por medio de ese alias. En términos más sencillos, solo es darle otro nombre a la misma variable. Esto también nos permite que el cambio del parámetro formal modifica el parámetro real. 63 | 64 | **Nota: En los ejercicios propuestos en este curso utilizaremos este último método para pasar parámetros de entrada y salida a las funciones**. 65 | 66 | 67 | ## Ejemplos 68 | 69 | Comprobamos que los parámetros pasados **por valor** no modifican los parámetros reales. 70 | 71 | #include 72 | using namespace std; 73 | void PasoPorValor(int num); 74 | 75 | int main(int argc, char *argv[]) { 76 | int numero1=5; 77 | PasoPorValor(numero1); 78 | cout << numero1 << endl; 79 | return 0; 80 | } 81 | 82 | void PasoPorValor(int num) 83 | { 84 | num = num + 1; 85 | cout << num << endl; 86 | } 87 | 88 | El resultado será 6 y 5. Hemos incrementado el valor del parámetro formal, pero no se ha modificado el real. 89 | 90 | Veamos ahora el mismo programa pero pasando el parámetro por **punteros**: 91 | 92 | #include 93 | using namespace std; 94 | void PasoPorReferencia(int *num); 95 | 96 | int main(int argc, char *argv[]) { 97 | int numero1=5; 98 | PasoPorReferencia(&numero1); 99 | cout << numero1 << endl; 100 | return 0; 101 | } 102 | 103 | void PasoPorReferencia(int *num) 104 | { 105 | *num = *num + 1; 106 | cout << *num << endl; 107 | } 108 | 109 | 110 | El resultado será 6 y 6. Hemos modificado el parámetro formal y se modificado el real. 111 | 112 | Si realizamos este ejercicio con **referencias en C++**: 113 | 114 | #include 115 | using namespace std; 116 | void PasoPorReferencia(int &num); 117 | 118 | int main(int argc, char *argv[]) { 119 | int numero1=5; 120 | PasoPorReferencia(numero1); 121 | cout << numero1 << endl; 122 | return 0; 123 | } 124 | 125 | void PasoPorReferencia(int &num) 126 | { 127 | num = num + 1; 128 | cout << num << endl; 129 | } 130 | -------------------------------------------------------------------------------- /curso/u37/README.md: -------------------------------------------------------------------------------- 1 | # Funciones recursivas 2 | 3 | Una función recursiva es aquella que al ejecutarse hace llamadas a ella misma. Por lo tanto tenemos que tener "un caso base" que hace terminar el bucle de llamadas. Veamos un ejemplo: 4 | 5 | #include 6 | using namespace std; 7 | int CalcularFactorial(int num); 8 | 9 | int main(int argc, char *argv[]) { 10 | cout << "El factorial de 6 es " << CalcularFactorial(6) << endl; 11 | return 0; 12 | } 13 | 14 | int CalcularFactorial(int num) 15 | { 16 | if (num==0 || num==1) 17 | { 18 | return 1; 19 | } 20 | return num * CalcularFactorial(num - 1); 21 | } 22 | -------------------------------------------------------------------------------- /curso/u38/README.md: -------------------------------------------------------------------------------- 1 | # Ejercicios de funciones 2 | 3 | ### Ejercicio 1 4 | 5 | Crea un procedimiento EscribirCentrado, que reciba como parámetro un texto y lo escriba centrado en pantalla (suponiendo una anchura de 80 columnas; pista: deberás escribir 40 - longitud/2 espacios antes del texto). Además subraya el mensaje utilizando el carácter `=`. 6 | 7 | ### Ejercicio 2 8 | 9 | Crea un programa que pida dos número enteros al usuario y diga si alguno de ellos es múltiplo del otro. Crea una función EsMultiplo que reciba los dos números, y devuelve si el primero es múltiplo del segundo. 10 | 11 | ### Ejercicio 3 12 | 13 | Crear una función que calcule la temperatura media de un día a partir de la temperatura máxima y mínima. Crear un programa principal, que utilizando la función anterior, vaya pidiendo la temperatura máxima y mínima de cada día y vaya mostrando la media. El programa pedirá el número de días que se van a introducir. 14 | 15 | ### Ejercicio 4 16 | 17 | Crea un función "ConvertirEspaciado", que reciba como parámetro un texto y devuelve una cadena con un espacio adicional tras cada letra. Por ejemplo, "Hola, tú" devolverá "H o l a , t ú ". Crea un programa principal donde se use dicha función. 18 | 19 | ### Ejercicio 5 20 | 21 | Crea una función "calcularMaxMin" que recibe una arreglo con valores numérico y devuelve el valor máximo y el mínimo. Crea un programa que pida números por teclado y muestre el máximo y el mínimo, utilizando la función anterior. 22 | 23 | ### Ejercicio 6 24 | 25 | Diseñar una función que calcule el área y el perímetro de una circunferencia. Utiliza dicha función en un programa principal que lea el radio de una circunferencia y muestre su área y perímetro. 26 | 27 | ### Ejercicio 7 28 | 29 | Crear una subrutina llamada "Login", que recibe un nombre de usuario y una contraseña y te devuelve Verdadero si el nombre de usuario es "usuario1" y la contraseña es "asdasd". Además recibe el número de intentos que se ha intentado hacer login y si no se ha podido hacer login incremente este valor. 30 | 31 | Crear un programa principal donde se pida un nombre de usuario y una contraseña y se intente hacer login, solamente tenemos tres oportunidades para intentarlo. 32 | 33 | ### Ejercicio 8 34 | 35 | Crear una función recursiva que permita calcular el factorial de un número. Realiza un programa principal donde se lea un entero y se muestre el resultado del factorial. 36 | 37 | ### Ejercicio 9 38 | 39 | Crear una función que calcule el MCD de dos número por el método de Euclides. El método de Euclides es el siguiente: 40 | 41 | * Se divide el número mayor entre el menor. 42 | * Si la división es exacta, el divisor es el MCD. 43 | * Si la división no es exacta, dividimos el divisor entre el resto obtenido y se continúa de esta forma hasta obtener una división exacta, siendo el último divisor el MCD. 44 | 45 | Crea un programa principal que lea dos números enteros y muestre el MCD. 46 | 47 | ### Ejercicio 10 48 | 49 | Escribir dos funciones que permitan calcular: 50 | 51 | * La cantidad de segundos en un tiempo dado en horas, minutos y segundos. 52 | * La cantidad de horas, minutos y segundos de un tiempo dado en segundos. 53 | 54 | Escribe un programa principal con un menú donde se pueda elegir la opción de convertir a segundos, convertir a horas,minutos y segundos o salir del programa. 55 | 56 | ### Ejercicio 11 57 | 58 | El día juliano correspondiente a una fecha es un número entero que indica los días que han transcurrido desde el 1 de enero del año indicado. Queremos crear un programa principal que al introducir una fecha nos diga el día juliano que corresponde. Para ello podemos hacer las siguientes subrutinas: 59 | 60 | * `LeerFecha`: Nos permite leer por teclado una fecha (día, mes y año). 61 | * `DiasDelMes`: Recibe un mes y un año y nos dice los días de ese mes en ese año. 62 | * `EsBisiesto`: Recibe un año y nos dice si es bisiesto. 63 | * `Calcular_Dia_Juliano`: recibe una fecha y nos devuelve el día juliano. 64 | 65 | 66 | ### Ejercicio 12 67 | 68 | Vamos a mejorar el ejercicio anterior haciendo una función para validar la fecha. De tal forma que al leer una fecha se asegura que es válida. 69 | 70 | ### Ejercicio 13 71 | 72 | Queremos crear un programa que trabaje con fracciones a/b. Para representar una fracción vamos a utilizar dos enteros: `numerador` y `denominador`. 73 | 74 | Vamos a crear las siguientes funciones para trabajar con funciones: 75 | 76 | * `Leer_fracción`: La tarea de esta función es leer por teclado el numerador y el denominador. Cuando leas una fracción debes simplificarla. 77 | * `Escribir_fracción`: Esta función escribe en pantalla la fracción. Si el dominador es 1, se muestra sólo el numerador. 78 | * `Calcular_mcd`: Esta función recibe dos número y devuelve el máximo común divisor. 79 | * `Simplificar_fracción`: Esta función simplifica la fracción, para ello hay que dividir numerador y dominador por el MCD del numerador y denominador. 80 | * `Sumar_fracciones`: Función que recibe dos funciones n1/d1 y n2/d2, y calcula la suma de las dos fracciones. La suma de dos fracciones es otra fracción cuyo `numerador=n1*d2+d1*n2` y `denominador=d1*d2`. Se debe simplificar la fracción resultado. 81 | * `Restar_fracciones`: Función que resta dos fracciones: `numerador=n1*d2-d1*n2` y `denominador=d1*d2`. Se debe simplificar la fracción resultado. 82 | * `Multiplicar_fracciones`: Función que recibe dos fracciones y calcula el producto, para ello `numerador=n1*n2` y `denominador=d1*d2`. Se debe simplificar la fracción resultado. 83 | * `Dividir_fracciones`: Función que recibe dos fracciones y calcula el cociente, para ello `numerador=n1*d2` y `denominador=d1*n2`. Se debe simplificar la fracción resultado. 84 | 85 | Crear un programa que utilizando las funciones anteriores muestre el siguiente menú: 86 | 87 | 1. Sumar dos fracciones: En esta opción se piden dos fracciones y se muestra el resultado. 88 | 2. Restar dos fracciones: En esta opción se piden dos fracciones y se muestra la resta. 89 | 3. Multiplicar dos fracciones: En esta opción se piden dos fracciones y se muestra la producto. 90 | 4. Dividir dos fracciones: En esta opción se piden dos fracciones y se muestra la cociente. 91 | 5. Salir 92 | 93 | ### Ejercicio 14 94 | 95 | Vamos a crear un programa para trabajar con una pila. Una pila es una estructura de datos que nos permite guardar un conjunto de variables. La característica fundamental es que el último elemento que se añade al conjunto es el primero que se puede sacar. 96 | 97 | Para representar una pila vamos a utilizar un arreglo (vector) de cadena de caracteres con tamaño 10, por lo tanto la pila no podrá tener más de 10 elementos. 98 | 99 | Vamos a crear varias funciones para trabajar con la pila: 100 | 101 | * `IncializarPila`: Como tenemos un arreglo de 10 elementos de cadenas tenemos que inicializarlo e introducir un carácter (por ejemplo un `*` que indique que ese elemento del arreglo no corresponde con un dato de la pila. Esta función inicializa el vector con ese carácter. 102 | * `LongitudPila`: Función que recibe una pila y devuelve el número de elementos que tiene. 103 | * `EstaVaciaPila`: Función que recibe una pila y que devuelve si la pila está vacía, no tiene elementos. 104 | * `EstaLlenaPila`: Función que recibe una pila y que devuelve si la pila está llena. 105 | * `AddPila`: función que recibe una cadena de caracteres y una pila, y añade la cadena a la pila, si no está llena. si esta llena muestra un mensaje de error. 106 | * `SacarDeLaPila`: Función que recibe una pila y devuelve el último elemento añadido y lo borra de la pila. Si la pila está vacía muestra un mensaje de error. 107 | * `EscribirPila`: Función que recibe una pila y muestra en pantalla los elementos de la pila. 108 | 109 | Realiza un programa principal que nos permita usar las funciones anterior, que nos muestre un menú, con las siguientes opciones: 110 | 111 | 1. Añadir elemento a la pila 112 | 2. Sacar elemento de la pila 113 | 3. Longitud de la pila 114 | 4. Mostrar pila 115 | 5. Salir 116 | 117 | ### Ejercicio 15 118 | 119 | Vamos a realizar un programa similar al anterior para trabajar con una cola. Una cola es una estructura de datos que nos permite guardar un conjunto de variables. La característica fundamental es que el primer elemento que se añade al conjunto es el primero que se puede sacar. 120 | 121 | En realizada nos sirven todas las funciones del ejercicio anterior menos la función `SacarDeLaCola` que es la que tienes que modificar. 122 | 123 | # Ejercicios resueltos 124 | 125 | [Ejercicios de funciones](../../ejercicios/funciones) -------------------------------------------------------------------------------- /curso/u39/README.md: -------------------------------------------------------------------------------- 1 | # Más Ejercicios 2 | 3 | 4 | ### Ejercicio 1 5 | 6 | Realice un programa que pregunte aleatóriamente una multiplicación. El programa debe indicar si la respuesta ha sido correcta o no (en caso que la respuesta sea incorrecta el programa debe indicar cuál es la correcta). El programa preguntará 10 multiplicaciones, y al finalizar mostrará el número de aciertos. 7 | 8 | ### Ejercicio 2 9 | 10 | El DNI (Documento Nacional de Identidad) en España está formada por 8 números y una letra. La letra nos sirve para verificar que el número es correcto, por lo tanto la letra se calcula a partir del número. Busca información de cómo se realiza el calculo y crea una función `CalcularLetra` que recibe un número y devuelva la letra que le corresponde. 11 | 12 | La función anterior la podemos utiliza para crear una nueva función `ValidarDNI` que recibe un DNI (cadena de caracteres con 8 números y una letra) que valida el DNI, es decir comprueba si la letra del DNI ces igual a la letra calculada a partir del número. 13 | 14 | Realiza un programa principal que lea un DNI y valide que es correcto (se debe comprobar también que tiene 9 caracteres). 15 | 16 | ### Ejercicio 3 17 | 18 | Realizar una aplicación que recoja por teclado la cantidad total a pagar y la cantidad que se ha entregado. La aplicación debe calcular el cambio correspondiente con el menor número de monedas y/o billetes posibles. 19 | 20 | 21 | ### Ejercicio 4 22 | 23 | Realizar un algoritmo que permita descomponer un número en sus factores primos. 24 | 25 | ### Ejercicio 5 26 | 27 | Vamos a realizar dos funciones: una que nos permita convertir un número entero a binario, y otra que nos permita convertir un numero binario a decimal. 28 | 29 | * `ConvertirABinario`: Función que recibe un número entero y devuelve una cadena con la representación del número en binario. 30 | * `ConvertirADecimal`: Función que recibe una cadena con la representación binaria de un número y devuelve el número en decimal. 31 | 32 | Crea un programa principal que permita convertir de decimal a binario y de binario a decimal. 33 | 34 | ### Ejercicio 6 35 | 36 | Crear un programa que convierta un número entero (mayor que 1 y menor o igual que 1000) a número romano. 37 | 38 | ### Ejercicio 7 39 | 40 | Diseñar un programa que permita adivinar al ordenador un determinado número entero y positivo para lo cual se deben leer los límites en los que está comprendido dicho número. El programa deberá ir mostrando números que recibirán las siguientes respuestas: 41 | 1. 'S', si es correcto. 42 | 2. 'A', si es más alto que el número a adivinar. 43 | 3. 'B', si es más bajo. 44 | Al finalizar el programa, se deberá escribir el número de intentos realizados para acertar el número. 45 | 46 | 47 | ### Ejercicio 8 48 | Realizar un programa que pida un mes y un año (superior a 1900) y muestre el calendario del mes de esta manera: 49 | 50 | L M M J V S D 51 | ========================== 52 | 1 2 3 4 5 6 53 | 7 8 9 10 11 12 13 54 | 14 15 16 17 18 19 20 55 | 21 22 23 24 25 26 27 56 | 28 29 30 31 57 | 58 | Para ello es necesario averiguar que día de la semana (Lunes, Martes, ...) corresponde con un fecha determinada. Hay muchas maneras de calcularlo: nosotros vamos a contar los días que han trascurridos desde el año 1900 (podemos hacer uso de funciones que hemos utilizado en ejercicios anteriores), y una vez calculado le hacemos el módulo 7 y el número obtenido será el da de la semana (0: domingo, 1: lunes, ...) (NOTA: ten en cuanta que queremos realizar un calendario que empiece en lunes, no en domingo). 59 | 60 | ### Ejercicio 9 61 | 62 | Vamos a programar el juego "Mastermind", para ello el programa debe "eligir" un número de cuatro cifras (sin cifras repetidas), que será el código que el jugador debe adivinar en la menor cantidad de intentos posibles. Cada intento consiste en una propuesta de un código posible que escribe el jugador, y una respuesta del programa. Las respuestas le darán pistas al jugador para que pueda deducir el código. 63 | 64 | * Número de "MUERTOS": Es la cantidad de dígitos que están en el número secreto y en la misma posición, 65 | * Número de "HERIDOS:" Es la cantidad de dígitos que están en el número secreto pero no en la misma posición. 66 | 67 | Por ejemplo, si el código que eligió el programa es el 2607, y el jugador propone el 1406, el programa le debe responder un MUERTO (el 0, que está en el código original en el mismo lugar, el tercero), y un HERIDO (el 6, que también está en el código original, pero en la segunda posición, no en el cuarto como fue propuesto). 68 | 69 | ### Ejercicio 10 70 | 71 | Escribe un programa para jugar al ahorcado. 72 | 73 | * Un jugador introduce una palabra secreta y otro jugador tratará de adivinarla. 74 | * Aparecerá la palabra oculta (se mostrará un conjunto de asteriscos con la longitud de la palabra que hay que adivinar). 75 | * El programa te va pidiendo letras. 76 | * Si la letra está en la palabra, se mostrar la palabra mostrando las letras acertadas y los asteriscos en las letras que faltan por averiguar. 77 | * Cada vez que se introduce una letra se muestra las letras que has introducido anteriormente. 78 | * Si la letra no se encuentra en la palabra se suma un fallo. Según el número de fallos se mostrará el dibujo del ahorcado cada vez ms completo. 79 | * Si introduces todas las letras de la palabra has ganada y te mostrará el número de intentos que has necesitado. 80 | * Si produces 6 fallos, habrás perdido y se mostrará el dibujo del ahorcado completo. 81 | 82 | # Ejercicios resueltos 83 | 84 | [Más ejercicios](../../ejercicios/mas_ejercicios) 85 | -------------------------------------------------------------------------------- /curso/u40/README.md: -------------------------------------------------------------------------------- 1 | # Introducción a la programación orientada a objetos 2 | 3 | La Programación Orientado a Objetos (POO) se basa en la agrupación de objetos de distintas clases que interactúan entre sí y que, en conjunto, consiguen que un programa cumpla su propósito. 4 | 5 | 6 | ## Definición de clase, objeto, atributos y métodos 7 | 8 | * Llamamos **clase** a la representación abstracta de un concepto. Por ejemplo, "perro", "número entero" o "servidor web". 9 | * Las clases se componen de **miembros**. 10 | * Los miembros de una clase pueden ser de dos tipos: **atributos** y **funciones asociadas** o **métodos**. 11 | * Los miembros de una clase pueden ser públicos o privados. 12 | * Un **objeto** es cada una de las instancias de una clase. Es decir las variables de este tipo de datos que es la clase llamamos **objeto**. 13 | * Los **atributos** definen las características propias del objeto y modifican su estado. Son datos asociados a las clases y a los objetos creados a partir de ellas. 14 | * Un **atributo de objeto** se define dentro de un método y pertenece a un objeto determinado de la clase instanciada. 15 | * Los **métodos** son bloques de código (o funciones) de una clase que se utilizan para definir el comportamiento de los objetos. 16 | 17 | Para definir una clase usamos la siguiente sintaxis: 18 | 19 | class NOMBRE_CLASE 20 | { 21 | 22 | public: 23 | 24 | }; 25 | 26 | Se puede usar la etiqueta `private:` para indicar los miembros privados, por defecto las declaraciones de una clase son privadas. En esta unidad vamos a trabajar con miembros públicos, en la siguiente unidad introduciremos los miembros privados. 27 | 28 | Para declarar los método o funciones asociadas lo podemos hacer dentro de la declaración de la clase o declarando sólo el prototipo de la función e implementando la función fuera de la declaración de la clase. Está última alternativa es la que vamos a usar, y para ello es necesario cualificar el nombre de la misma con el nombre de la clase utilizando la sintaxis: `::`. 29 | 30 | Para declarar un objeto usamos la siguiente forma de declaración: 31 | 32 | ,... 33 | 34 | Por último para acceder a los miembros de un objeto una vez declarado vamos a usar el operador `.`. 35 | 36 | objeto1.atributo1 37 | objeto1.funcion1(...) 38 | 39 | Veamos un ejemplo donde vamos a crear una clase para guardar la información de un *Punto*. Tendrá dos atributos para guardar el valor de la coordenada x e y. Además tendrá un método para mostrar la información del punto: 40 | 41 | #include 42 | using namespace std; 43 | 44 | class Punto 45 | { 46 | //Atributos 47 | public: 48 | float x; 49 | float y; 50 | 51 | //Métodos 52 | void mostrar(); 53 | 54 | }; 55 | 56 | void Punto::mostrar() 57 | { 58 | cout << x << "-" << y; 59 | } 60 | 61 | int main(int argc, char *argv[]) { 62 | 63 | Punto punto1; 64 | punto1.x=4; 65 | punto1.y=8; 66 | cout << punto1.x << endl; 67 | punto1.mostrar(); 68 | 69 | return 0; 70 | } 71 | 72 | Hemos creado un objeto `punto1` de la clase `Punto`: 73 | 74 | Punto punto1; 75 | 76 | Como podemos ver al ser los miembros (atributos y métodos) públicos podemos modificarlos y usarlos desde el programa principal: 77 | 78 | punto1.x=4; 79 | punto1.y=8; 80 | ... 81 | punto1.mostrar(); 82 | 83 | Y podemos obtener los valores de los atributos: 84 | 85 | cout << punto1.x << endl; 86 | 87 | ## Constructores 88 | 89 | ¿Qué valores tienen los atributos al crear un objeto? C++ no permite inicializar los valores de los atributos de forma automática cuando declaramos un objeto, para ello vamos a usar unos métodos especiales que llamamos **constructores**.Los constructores son métodos que se deben llamar igual que la clase y sin tipo de valor de retorno. Además como una de las características de la Programación Orientada a Objetos es la sobrecarga de funciones, podemos tener varias funciones asociadas o métodos que se llamen igual pero que reciban diferentes cantidad de parámetros o de diferentes tipos. 90 | 91 | Veamos otro ejemplo donde hemos introducido dos constructores y otro método que nos devuelve la distancia a otro punto: 92 | 93 | #include 94 | #include 95 | using namespace std; 96 | 97 | class Punto 98 | { 99 | //Atributos 100 | public: 101 | float x; 102 | float y; 103 | 104 | //Métodos 105 | Punto(); 106 | Punto(float nx, float ny); 107 | void mostrar(); 108 | float distancia(Punto otro); 109 | }; 110 | 111 | Punto::Punto() 112 | { 113 | x=0; 114 | y=0; 115 | } 116 | Punto::Punto(float nx, float ny) 117 | { 118 | x=nx; 119 | y=ny; 120 | } 121 | void Punto::mostrar() 122 | { 123 | cout << x << "-" << y; 124 | } 125 | float Punto::distancia(Punto otro) 126 | { 127 | float dx, dy; 128 | dx = x - otro.x; 129 | dy = y - otro.y; 130 | return sqrt(dx*dx + dy*dy); 131 | } 132 | 133 | 134 | int main(int argc, char *argv[]) { 135 | 136 | Punto punto1; 137 | Punto punto2(4,5); 138 | punto1.mostrar(); 139 | cout << endl; 140 | punto2.mostrar(); 141 | cout << endl; 142 | cout << punto1.distancia(punto2); 143 | 144 | return 0; 145 | } 146 | 147 | Al declarar el objeto `punto1` se utiliza el primer constructor e inicializa los dos atributos a 0, sin embargo al crear el objeto `punto2` hemos usado el segundo constructor donde los atributos se inicializan con los valores de los parámetros que recibe. 148 | -------------------------------------------------------------------------------- /curso/u40/punto.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | class Punto 6 | { 7 | //Atributos 8 | public: 9 | float x; 10 | float y; 11 | 12 | //Métodos 13 | Punto(); 14 | Punto(float nx, float ny); 15 | void mostrar(); 16 | float distancia(Punto otro); 17 | }; 18 | 19 | Punto::Punto() 20 | { 21 | x=0; 22 | y=0; 23 | } 24 | Punto::Punto(float nx, float ny) 25 | { 26 | x=nx; 27 | y=ny; 28 | } 29 | void Punto::mostrar() 30 | { 31 | cout << x << "-" << y; 32 | } 33 | float Punto::distancia(Punto otro) 34 | { 35 | float dx, dy; 36 | dx = x - otro.x; 37 | dy = y - otro.y; 38 | return sqrt(dx*dx + dy*dy); 39 | } 40 | 41 | 42 | int main(int argc, char *argv[]) { 43 | 44 | Punto punto1; 45 | Punto punto2(4,5); 46 | punto1.mostrar(); 47 | cout << endl; 48 | punto2.mostrar(); 49 | cout << endl; 50 | cout << punto1.distancia(punto2); 51 | 52 | return 0; 53 | } 54 | -------------------------------------------------------------------------------- /curso/u41/README.md: -------------------------------------------------------------------------------- 1 | # Encapsulamiento en la programación orientada a objetos 2 | 3 | En la unidad anterior terminamos viendo que teníamos la posibilidad de cambiar los valores de los atributos de un objeto. En muchas ocasiones es necesario que esta modificación no se haga directamente, sino que tengamos utilizar un método para realizar la modificación y poder controlar esa operación. También puede ser deseable que la devolución del valor de los atributos se haga utilizando un método. La característica de no acceder o modificar los valores de los atributos directamente y utilizar métodos para ello lo llamamos **encapsulamiento**. 4 | 5 | ## Miembros privados 6 | 7 | Tanto los atributos como los métodos pueden ser públicos o privados. En el caso de los atributos para conseguir el encapsulamiento lo definimos como privados y nos se podrán acceder o modificar a sus valores directamente, tendremos que usar métodos para modificar sus valores o para obtener sus valores. De esta manera tendremos el control del valor que pueden tomar los atributos. 8 | 9 | Del mismo modo podemos tener métodos privados. Si un método es privado no se podrá usar directamente desde el objeto pero si podrá ser usado desde otro método de la clase. 10 | 11 | Veamos el ejemplo de la clase `Punto` con los atributos privados y métodos de lectura y escritura para cada atributo. Además vamos asegurarnos que nuestros puntos están en el primer cuadrante, es decir el valor de la x y de la y deben ser positivo: 12 | 13 | #include 14 | #include 15 | using namespace std; 16 | 17 | class Punto 18 | { 19 | //Atributos 20 | 21 | float x; 22 | float y; 23 | public: 24 | //Métodos 25 | Punto(); 26 | Punto(float nx, float ny); 27 | void mostrar(); 28 | float distancia(Punto otro); 29 | void set_x(float nx); 30 | float get_x(); 31 | void set_y(float nx); 32 | float get_y(); 33 | }; 34 | 35 | Punto::Punto() 36 | { 37 | x=0; 38 | y=0; 39 | } 40 | Punto::Punto(float nx, float ny) 41 | { 42 | x=nx; 43 | y=ny; 44 | } 45 | void Punto::mostrar() 46 | { 47 | cout << x << "-" << y; 48 | } 49 | float Punto::distancia(Punto otro) 50 | { 51 | float dx, dy; 52 | dx = x - otro.x; 53 | dy = y - otro.y; 54 | return sqrt(dx*dx + dy*dy); 55 | } 56 | 57 | 58 | void Punto::set_x(float nx) 59 | { 60 | if (nx>=0) 61 | x=nx; 62 | else 63 | x=0; 64 | } 65 | 66 | float Punto::get_x() 67 | { 68 | return x; 69 | } 70 | 71 | void Punto::set_y(float ny) 72 | { 73 | if (ny>=0) 74 | y=ny; 75 | else 76 | y=0; 77 | } 78 | 79 | float Punto::get_y() 80 | { 81 | return y; 82 | } 83 | 84 | int main(int argc, char *argv[]) { 85 | 86 | Punto punto1; 87 | Punto punto2(4,5); 88 | 89 | //Estas instrucciones darían un error de compilación 90 | //punto1.x=6; 91 | //cout << punto1.x; 92 | 93 | punto1.set_x(6); 94 | cout << punto1.get_x() << endl; 95 | 96 | punto1.mostrar(); 97 | cout << endl; 98 | punto2.mostrar(); 99 | cout << endl; 100 | cout << punto1.distancia(punto2); 101 | 102 | return 0; 103 | } 104 | 105 | 106 | -------------------------------------------------------------------------------- /curso/u42/README.md: -------------------------------------------------------------------------------- 1 | # Herencia y delegación 2 | 3 | ## Herencia 4 | 5 | La herencia es un mecanismo de la programación orientada a objetos que sirve para crear clases nuevas a partir de clases preexistentes. Se toman (heredan) atributos y métodos de las clases bases y se los modifica para modelar una nueva situación. 6 | La clase desde la que se hereda se llama **clase base** y la que se construye a partir de ella es una **clase derivada**. 7 | 8 | En C++ hay distintos tipos de herencia. En este curso vamos a ver un ejemplo de una **herencia simple** donde creamos una clase derivada a partir de una clase base. Otro tipo que no estudiaremos es la **herencia múltiple** donde se crea una clase derivada a partir de varias clases bases. 9 | 10 | ## Derivar clases 11 | 12 | La sintaxis para realizar una herencia simple sería: 13 | 14 | class :[public|private] 15 | { 16 | ... 17 | } 18 | 19 | Por ejemplo: 20 | 21 | class Punto3d: public Punto 22 | { 23 | ... 24 | } 25 | 26 | Vemos que la clase base la podemos definir con dos tipos de acceso: 27 | 28 | * `public`: los miembros heredados de la clase base conservan el tipo de acceso con que fueron declarados en ella. 29 | * `private`: todos los miembros heredados de la clase base pasan a ser miembros privados en la clase derivada. 30 | 31 | En esta introducción vamos a indicar el tipo de acceso `public`. 32 | 33 | Además vamos añadir un nuevo tipo de acceso a la declaración de los miembros en la clase base. Habíamos visto el tipo de acceso `public` (se pueden acceder desde el exterior) y el `private` (no se pueden acceder desde el exterior, usamos un método para ello). Ahora incluimos un nuevo tipo de acceso pensando en la herencia: 34 | 35 | * `protected`: Que nos permite que los datos no sean inaccesibles desde el exterior de las clases, pero a la vez, permite que sean accesibles desde las clases derivadas. 36 | 37 | ## Constructores en clases derivadas 38 | 39 | Cuando se crea un objeto de una clase derivada, primero se invoca al constructor de la clase o clases base y a continuación al constructor de la clase derivada. 40 | 41 | Cuando queramos inicializar las clases base usando parámetros desde el constructor de una clase derivada lo haremos de este modo: 42 | 43 | () : () 44 | { 45 | ... 46 | } 47 | Es decir, el constructor de la clase derivada recibe todos los parámetros y llama al constructor de la clase base envíando los parámetros adecuados para finalmente inicializar los atributos que le son propio. Por ejemplo: 48 | 49 | Punto3d::Punto3d(float nx,float ny, float nz):Punto(nx,ny) 50 | { 51 | z=nz; 52 | } 53 | 54 | Si nuestra clase base es la clase `Punto` estudiada en unidades anteriores, puedo crear una nueva clase de la siguiente manera: [Accede al código](punto3d.cpp) 55 | 56 | ## Delegación 57 | 58 | Llamamos delegación a la situación en la que una clase contiene (como atributos) una o más instancias de otra clase, a las que delegará parte de sus funcionalidades. 59 | A partir de la clase punto, podemos crear la clase circulo de esta forma: 60 | 61 | ``` 62 | class Circulo 63 | { 64 | public: 65 | Punto centro; 66 | float radio; 67 | 68 | //Métodos 69 | Circulo(Punto nc,float nr); 70 | void mostrar(); 71 | }; 72 | 73 | Circulo::Circulo(Punto nc,float nr) 74 | { 75 | centro = nc; 76 | radio = nr; 77 | } 78 | void Circulo::mostrar() 79 | { 80 | cout << "Centro:" << centro.get_x() << "-" << centro.get_y() << " - Radio:" << radio ; 81 | } 82 | ``` -------------------------------------------------------------------------------- /curso/u42/circulo.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | class Punto 6 | { 7 | //Atributos 8 | protected: 9 | float x; 10 | float y; 11 | public: 12 | //M�todos 13 | Punto(); 14 | Punto(float nx, float ny); 15 | void mostrar(); 16 | float distancia(Punto otro); 17 | void set_x(float nx); 18 | float get_x(); 19 | void set_y(float nx); 20 | float get_y(); 21 | }; 22 | 23 | Punto::Punto() 24 | { 25 | x=0; 26 | y=0; 27 | } 28 | Punto::Punto(float nx, float ny) 29 | { 30 | x=nx; 31 | y=ny; 32 | } 33 | void Punto::mostrar() 34 | { 35 | cout << x << "-" << y; 36 | } 37 | float Punto::distancia(Punto otro) 38 | { 39 | float dx, dy; 40 | dx = x - otro.x; 41 | dy = y - otro.y; 42 | return sqrt(dx*dx + dy*dy); 43 | } 44 | 45 | 46 | void Punto::set_x(float nx) 47 | { 48 | if (nx>=0) 49 | x=nx; 50 | else 51 | x=0; 52 | } 53 | 54 | float Punto::get_x() 55 | { 56 | return x; 57 | } 58 | 59 | void Punto::set_y(float ny) 60 | { 61 | if (ny>=0) 62 | y=ny; 63 | else 64 | y=0; 65 | } 66 | 67 | float Punto::get_y() 68 | { 69 | return y; 70 | } 71 | 72 | 73 | //Circulo 74 | 75 | 76 | class Circulo 77 | { 78 | public: 79 | Punto centro; 80 | float radio; 81 | 82 | //M�todos 83 | Circulo(Punto nc,float nr); 84 | void mostrar(); 85 | }; 86 | 87 | Circulo::Circulo(Punto nc,float nr) 88 | { 89 | centro = nc; 90 | radio = nr; 91 | } 92 | void Circulo::mostrar() 93 | { 94 | cout << "Centro:" << centro.get_x() << "-" << centro.get_y() << " - Radio:" << radio ; 95 | } 96 | 97 | int main(int argc, char *argv[]) { 98 | 99 | //Podemos crear objetos de la clase Punto 100 | 101 | Punto np(3,4); 102 | Circulo c1(np,6); 103 | c1.mostrar(); 104 | } 105 | -------------------------------------------------------------------------------- /curso/u42/punto3d.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/curso/u42/punto3d.cpp -------------------------------------------------------------------------------- /curso/u43/README.md: -------------------------------------------------------------------------------- 1 | # Ejercicios de programación orientada a objetos 2 | 3 | ## Ejercicio 1 4 | 5 | Vamos a crear una clase llamada `Persona`. Sus atributos son: **nombre**, **edad** y **DNI**. Construye los siguientes métodos para la clase: 6 | 7 | * El constructor por defecto. 8 | * Un constructor, que reciba los parámetros para inicializar los atributos. 9 | * Los métodos de acceso (set,get) para cada uno de los atributos. Hay que validar las entradas de datos. 10 | * `mostrar()`: Devuelve los datos de la persona. 11 | * `esMayorDeEdad()`: Devuelve un valor lógico indicando si es mayor de edad. 12 | 13 | ## Ejercicio 2 14 | 15 | Crea una clase llamada `Cuenta` que tendrá los siguientes atributos: titular (que es una persona) y cantidad (puede tener decimales). El titular será obligatorio y la cantidad es opcional. Construye los siguientes métodos para la clase: 16 | 17 | * Un constructor, que reciba los parámetros para inicializar los atributos. 18 | * Los métodos de acceso (set,get) para cada uno de los atributos. El atributo `cantidad` no se puede modificar directamente, sólo ingresando o retirando dinero. 19 | * `mostrar()`: Devuelve los datos de la cuenta. 20 | * `ingresar(cantidad)`: se ingresa una cantidad a la cuenta, si la cantidad introducida es negativa, no se hará nada. 21 | * `retirar(cantidad)`: se retira una cantidad a la cuenta. La cuenta puede estar en números rojos. 22 | 23 | 24 | ## Ejercicio 3 25 | 26 | Vamos a definir ahora una "Cuenta Joven", para ello vamos a crear una nueva clase `CuantaJoven` que deriva de la anterior. Cuando se crea esta nueva clase, además del titular y la cantidad se debe guardar una bonificación que estará expresada en tanto por ciento.Construye los siguientes métodos para la clase: 27 | 28 | * Un constructor. 29 | * Los métodos de acceso (set,get) para el nuevo atributo. 30 | * En esta ocasión los titulares de este tipo de cuenta tienen que ser mayor de edad., por lo tanto hay que crear un método `esTitularValido()` que devuelve verdadero si el titular es mayor de edad pero menor de 25 años y falso en caso contrario. 31 | * Además la retirada de dinero sólo se podrá hacer si el titular es válido. 32 | * El método `mostrar()` debe devolver el mensaje de "Cuenta Joven" y la bonificación de la cuenta. 33 | 34 | Piensa los métodos heredados de la clase madre que hay que reescribir. 35 | 36 | # Ejercicios resueltos 37 | 38 | [Ejercicios de Programación orientada a objetos](../../ejercicios/objetos) -------------------------------------------------------------------------------- /curso1.md: -------------------------------------------------------------------------------- 1 | # Curso 1: Curso de C++: Introducción a C++ 2 | 3 | * [Presentación del curso](curso/pdf/presentacion1.pdf) 4 | 5 | ## Introducción a la programación 6 | 7 | 1. [Análisis de problemas y diseño de algoritmos](curso/u01) 8 | 2. [Introducción a los lenguajes de programación](curso/u02) 9 | 3. [Introducción a C++](curso/u03) 10 | 11 | ## Introducción a C++ 12 | 13 | 4. [Instalación del IDE Zinjai](curso/u04) 14 | 5. [Estructura del programa](curso/u05) 15 | 6. [Compilación y ejecución de programas](curso/u06) 16 | 17 | ## Tipos de datos básicos 18 | 19 | 7. [Datos y tipos de datos](curso/u07) 20 | 8. [Literales y constantes](curso/u08) 21 | 9. [Variables. Operadores de asignación.](curso/u09) 22 | 10. [Tipos de datos numéricos. Operadores aritméticos](curso/u10) 23 | 11. [Introducción a las cadenas de caracteres](curso/u11) 24 | 12. [Entrada y salida estándar](curso/u12) 25 | 13. [Pasando de pseudocódigo a C++](curso/u13) 26 | 14. [Ejercicios estructura secuencial](curso/u14) 27 | -------------------------------------------------------------------------------- /curso2.md: -------------------------------------------------------------------------------- 1 | # Curso 2: Curso de C++: Estructuras de control y tipos de datos 2 | 3 | * [Presentación del curso](curso/pdf/presentacion2.pdf) 4 | 5 | ## Estructuras alternativas 6 | 7 | 1. [Tipo de datos booleano. Operadores relacionales y lógicos](curso/u15) 8 | 2. [Estructuras alternativas: if](curso/u16) 9 | 3. [Estructuras alternativas: switch](curso/u17) 10 | 4. [Ejercicios estructuras alternativas](curso/u18) 11 | 12 | ## Estructuras repetitivas 13 | 14 | 5. [Estructuras repetitivas: while](curso/u19) 15 | 6. [Estructuras repetitivas: do-while](curso/u20) 16 | 7. [Estructuras repetitivas: for](curso/u21) 17 | 8. [Uso específico de variables: contadores, acumuladores e indicadores](curso/u22) 18 | 9. [Ejercicios estructuras repetitivas](curso/u23) 19 | 20 | ## Cadenas de caracteres 21 | 22 | 10. [Cadenas de caracteres con la clase string](curso/u24) 23 | 11. [Ejercicios cadenas de caracteres](curso/u25) 24 | 25 | ## Tipos de datos complejos: Arrays 26 | 27 | 12. [Introducción a los arrays](curso/u26) 28 | 13. [Arrays unidimensionales: Vectores](curso/u27) 29 | 14. [Cadenas de caracteres estilo C](curso/u28) 30 | 15. [Arrays multidimensionales: Tablas](curso/u29) 31 | 16. [Ejercicios de Arrays](curso/u30) 32 | 33 | -------------------------------------------------------------------------------- /curso3.md: -------------------------------------------------------------------------------- 1 | # Curso 3: Curso de C++: Programación estructurada y orientación a objetos 2 | 3 | * [Presentación del curso](curso/pdf/presentacion3.pdf) 4 | 5 | ## Punteros y estructuras 6 | 7 | 1. [Introducción a los punteros (I)](curso/u31) 8 | 2. [Introducción a los punteros (II)](curso/u32) 9 | 3. [Introducción a las referencias en C++](curso/u33) 10 | 4. [Tipos de datos complejos: estructuras](curso/u34) 11 | 12 | ## Programación estructurada 13 | 14 | 5. [Programación estructurada](curso/u35) 15 | 6. [Funciones y procedimientos](curso/u36) 16 | 7. [Funciones recursivas](curso/u37) 17 | 8. [Ejercicios con funciones](curso/u38) 18 | 9. [Más ejercicios](curso/u39) 19 | 20 | ## Programación orientada a objetos 21 | 22 | 10. [Introducción a la programación orientada a objetos](curso/u40) 23 | 11. [Encapsulamiento en la programación orientada a objetos](curso/u41) 24 | 12. [Herencia y delegación](curso/u42) 25 | 13. [Ejercicios de programación orientada a objetos](curso/u43) 26 | 27 | 28 | 29 | -------------------------------------------------------------------------------- /ejercicios/alternativas/ejercicio1.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/alternativas/ejercicio1.cpp -------------------------------------------------------------------------------- /ejercicios/alternativas/ejercicio10.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/alternativas/ejercicio10.cpp -------------------------------------------------------------------------------- /ejercicios/alternativas/ejercicio11.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/alternativas/ejercicio11.cpp -------------------------------------------------------------------------------- /ejercicios/alternativas/ejercicio12.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/alternativas/ejercicio12.cpp -------------------------------------------------------------------------------- /ejercicios/alternativas/ejercicio13.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/alternativas/ejercicio13.cpp -------------------------------------------------------------------------------- /ejercicios/alternativas/ejercicio14.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/alternativas/ejercicio14.cpp -------------------------------------------------------------------------------- /ejercicios/alternativas/ejercicio15.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/alternativas/ejercicio15.cpp -------------------------------------------------------------------------------- /ejercicios/alternativas/ejercicio16.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/alternativas/ejercicio16.cpp -------------------------------------------------------------------------------- /ejercicios/alternativas/ejercicio17.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/alternativas/ejercicio17.cpp -------------------------------------------------------------------------------- /ejercicios/alternativas/ejercicio18.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/alternativas/ejercicio18.cpp -------------------------------------------------------------------------------- /ejercicios/alternativas/ejercicio19.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/alternativas/ejercicio19.cpp -------------------------------------------------------------------------------- /ejercicios/alternativas/ejercicio2.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/alternativas/ejercicio2.cpp -------------------------------------------------------------------------------- /ejercicios/alternativas/ejercicio20.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/alternativas/ejercicio20.cpp -------------------------------------------------------------------------------- /ejercicios/alternativas/ejercicio3.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/alternativas/ejercicio3.cpp -------------------------------------------------------------------------------- /ejercicios/alternativas/ejercicio4.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/alternativas/ejercicio4.cpp -------------------------------------------------------------------------------- /ejercicios/alternativas/ejercicio5.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/alternativas/ejercicio5.cpp -------------------------------------------------------------------------------- /ejercicios/alternativas/ejercicio6.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/alternativas/ejercicio6.cpp -------------------------------------------------------------------------------- /ejercicios/alternativas/ejercicio7.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/alternativas/ejercicio7.cpp -------------------------------------------------------------------------------- /ejercicios/alternativas/ejercicio8.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/alternativas/ejercicio8.cpp -------------------------------------------------------------------------------- /ejercicios/alternativas/ejercicio9.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/alternativas/ejercicio9.cpp -------------------------------------------------------------------------------- /ejercicios/arrays/ejercicio1.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/arrays/ejercicio1.cpp -------------------------------------------------------------------------------- /ejercicios/arrays/ejercicio10.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/arrays/ejercicio10.cpp -------------------------------------------------------------------------------- /ejercicios/arrays/ejercicio11.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/arrays/ejercicio11.cpp -------------------------------------------------------------------------------- /ejercicios/arrays/ejercicio12.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/arrays/ejercicio12.cpp -------------------------------------------------------------------------------- /ejercicios/arrays/ejercicio13.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/arrays/ejercicio13.cpp -------------------------------------------------------------------------------- /ejercicios/arrays/ejercicio14.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/arrays/ejercicio14.cpp -------------------------------------------------------------------------------- /ejercicios/arrays/ejercicio15.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/arrays/ejercicio15.cpp -------------------------------------------------------------------------------- /ejercicios/arrays/ejercicio2.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/arrays/ejercicio2.cpp -------------------------------------------------------------------------------- /ejercicios/arrays/ejercicio3.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/arrays/ejercicio3.cpp -------------------------------------------------------------------------------- /ejercicios/arrays/ejercicio4.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/arrays/ejercicio4.cpp -------------------------------------------------------------------------------- /ejercicios/arrays/ejercicio5.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/arrays/ejercicio5.cpp -------------------------------------------------------------------------------- /ejercicios/arrays/ejercicio6.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/arrays/ejercicio6.cpp -------------------------------------------------------------------------------- /ejercicios/arrays/ejercicio7.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/arrays/ejercicio7.cpp -------------------------------------------------------------------------------- /ejercicios/arrays/ejercicio8.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/arrays/ejercicio8.cpp -------------------------------------------------------------------------------- /ejercicios/arrays/ejercicio9.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/arrays/ejercicio9.cpp -------------------------------------------------------------------------------- /ejercicios/cadenas/ejercicio1.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/cadenas/ejercicio1.cpp -------------------------------------------------------------------------------- /ejercicios/cadenas/ejercicio10.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/cadenas/ejercicio10.cpp -------------------------------------------------------------------------------- /ejercicios/cadenas/ejercicio2.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/cadenas/ejercicio2.cpp -------------------------------------------------------------------------------- /ejercicios/cadenas/ejercicio3_con_find.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/cadenas/ejercicio3_con_find.cpp -------------------------------------------------------------------------------- /ejercicios/cadenas/ejercicio3_con_recorrido.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/cadenas/ejercicio3_con_recorrido.cpp -------------------------------------------------------------------------------- /ejercicios/cadenas/ejercicio4.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/cadenas/ejercicio4.cpp -------------------------------------------------------------------------------- /ejercicios/cadenas/ejercicio5.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/cadenas/ejercicio5.cpp -------------------------------------------------------------------------------- /ejercicios/cadenas/ejercicio6.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/cadenas/ejercicio6.cpp -------------------------------------------------------------------------------- /ejercicios/cadenas/ejercicio7.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/cadenas/ejercicio7.cpp -------------------------------------------------------------------------------- /ejercicios/cadenas/ejercicio8.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/cadenas/ejercicio8.cpp -------------------------------------------------------------------------------- /ejercicios/cadenas/ejercicio9.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/cadenas/ejercicio9.cpp -------------------------------------------------------------------------------- /ejercicios/funciones/ejercicio1.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/funciones/ejercicio1.cpp -------------------------------------------------------------------------------- /ejercicios/funciones/ejercicio10.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/funciones/ejercicio10.cpp -------------------------------------------------------------------------------- /ejercicios/funciones/ejercicio11.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/funciones/ejercicio11.cpp -------------------------------------------------------------------------------- /ejercicios/funciones/ejercicio12.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/funciones/ejercicio12.cpp -------------------------------------------------------------------------------- /ejercicios/funciones/ejercicio13.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/funciones/ejercicio13.cpp -------------------------------------------------------------------------------- /ejercicios/funciones/ejercicio14.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/funciones/ejercicio14.cpp -------------------------------------------------------------------------------- /ejercicios/funciones/ejercicio15.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/funciones/ejercicio15.cpp -------------------------------------------------------------------------------- /ejercicios/funciones/ejercicio2.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/funciones/ejercicio2.cpp -------------------------------------------------------------------------------- /ejercicios/funciones/ejercicio3.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/funciones/ejercicio3.cpp -------------------------------------------------------------------------------- /ejercicios/funciones/ejercicio4.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/funciones/ejercicio4.cpp -------------------------------------------------------------------------------- /ejercicios/funciones/ejercicio5.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/funciones/ejercicio5.cpp -------------------------------------------------------------------------------- /ejercicios/funciones/ejercicio6.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/funciones/ejercicio6.cpp -------------------------------------------------------------------------------- /ejercicios/funciones/ejercicio7.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/funciones/ejercicio7.cpp -------------------------------------------------------------------------------- /ejercicios/funciones/ejercicio8.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/funciones/ejercicio8.cpp -------------------------------------------------------------------------------- /ejercicios/funciones/ejercicio9.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/funciones/ejercicio9.cpp -------------------------------------------------------------------------------- /ejercicios/mas_ejercicios/ejercicio1.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/mas_ejercicios/ejercicio1.cpp -------------------------------------------------------------------------------- /ejercicios/mas_ejercicios/ejercicio10.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/mas_ejercicios/ejercicio10.cpp -------------------------------------------------------------------------------- /ejercicios/mas_ejercicios/ejercicio2.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/mas_ejercicios/ejercicio2.cpp -------------------------------------------------------------------------------- /ejercicios/mas_ejercicios/ejercicio3.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/mas_ejercicios/ejercicio3.cpp -------------------------------------------------------------------------------- /ejercicios/mas_ejercicios/ejercicio4.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/mas_ejercicios/ejercicio4.cpp -------------------------------------------------------------------------------- /ejercicios/mas_ejercicios/ejercicio5.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/mas_ejercicios/ejercicio5.cpp -------------------------------------------------------------------------------- /ejercicios/mas_ejercicios/ejercicio6.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/mas_ejercicios/ejercicio6.cpp -------------------------------------------------------------------------------- /ejercicios/mas_ejercicios/ejercicio7.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/mas_ejercicios/ejercicio7.cpp -------------------------------------------------------------------------------- /ejercicios/mas_ejercicios/ejercicio8.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/mas_ejercicios/ejercicio8.cpp -------------------------------------------------------------------------------- /ejercicios/mas_ejercicios/ejercicio9.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/ejercicios/mas_ejercicios/ejercicio9.cpp -------------------------------------------------------------------------------- /ejercicios/objetos/ejercicio1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | class Persona 5 | { 6 | private: 7 | string nombre; 8 | int edad; 9 | string dni; 10 | void validar_dni(); 11 | public: 12 | Persona(); 13 | Persona(string nnombre,int nedad,string ndni); 14 | string get_nombre(); 15 | int get_edad(); 16 | string get_dni(); 17 | void set_nombre(string nnombre); 18 | void set_edad(int nedad); 19 | void set_dni(string ndni); 20 | string mostrar(); 21 | bool esMayorDeEdad(); 22 | }; 23 | 24 | Persona::Persona() 25 | { 26 | nombre=""; 27 | edad=0; 28 | dni=""; 29 | } 30 | 31 | Persona::Persona(string nnombre,int nedad,string ndni) 32 | { 33 | nombre=nnombre; 34 | edad=nedad; 35 | dni=ndni; 36 | validar_dni(); 37 | } 38 | 39 | string Persona::get_nombre() 40 | { 41 | return nombre; 42 | } 43 | 44 | int Persona::get_edad() 45 | { 46 | return edad; 47 | } 48 | 49 | string Persona::get_dni() 50 | { 51 | return dni; 52 | } 53 | 54 | void Persona::set_nombre(string nnombre) 55 | { 56 | nombre=nnombre; 57 | } 58 | 59 | void Persona::set_edad(int nedad) 60 | { 61 | if(nedad<0) 62 | { 63 | cout << "Edad incorrecta." << endl; 64 | edad=0; 65 | } 66 | else 67 | { 68 | edad = nedad; 69 | } 70 | } 71 | 72 | void Persona::set_dni(string ndni) 73 | { 74 | dni=ndni; 75 | validar_dni(); 76 | } 77 | 78 | void Persona::validar_dni() 79 | { 80 | string letras; 81 | char letra; 82 | int num; 83 | letras="TRWAGMYFPDXBNJZSQVHLCKE"; 84 | if (dni.size()!=9) 85 | { 86 | cout << "DNI incorrecto." << endl; 87 | dni=""; 88 | } 89 | else 90 | { 91 | letra=dni[8]; 92 | num=stoi(dni.erase(8,1)); //stoi convierte un string a entero 93 | dni=dni+letra; //Vuelvo a poner la letra al DNI 94 | if (toupper(letra) != letras[num%23]) 95 | { 96 | cout << "DNI incorrecto." << endl; 97 | dni=""; 98 | } 99 | } 100 | } 101 | 102 | string Persona::mostrar() 103 | { 104 | return "Nombre:"+nombre+ " - Edad:"+ to_string(edad)+ " - DNI:" + dni; 105 | } 106 | 107 | bool Persona::esMayorDeEdad() 108 | { 109 | return(edad>18); 110 | } 111 | 112 | int main(int argc, char *argv[]) { 113 | Persona yo("Jose Domingo",40,"12345678Z"); 114 | //yo.set_dni("12345678W"); 115 | cout << yo.mostrar()< 2 | using namespace std; 3 | 4 | class Persona 5 | { 6 | private: 7 | string nombre; 8 | int edad; 9 | string dni; 10 | void validar_dni(); 11 | public: 12 | Persona(); 13 | Persona(string nnombre,int nedad,string ndni); 14 | string get_nombre(); 15 | int get_edad(); 16 | string get_dni(); 17 | void set_nombre(string nnombre); 18 | void set_edad(int nedad); 19 | void set_dni(string ndni); 20 | string mostrar(); 21 | bool esMayorDeEdad(); 22 | }; 23 | 24 | Persona::Persona() 25 | { 26 | nombre=""; 27 | edad=0; 28 | dni=""; 29 | } 30 | Persona::Persona(string nnombre,int nedad,string ndni) 31 | { 32 | nombre=nnombre; 33 | edad=nedad; 34 | dni=ndni; 35 | validar_dni(); 36 | } 37 | 38 | string Persona::get_nombre() 39 | { 40 | return nombre; 41 | } 42 | 43 | int Persona::get_edad() 44 | { 45 | return edad; 46 | } 47 | 48 | string Persona::get_dni() 49 | { 50 | return dni; 51 | } 52 | 53 | void Persona::set_nombre(string nnombre) 54 | { 55 | nombre=nnombre; 56 | } 57 | 58 | void Persona::set_edad(int nedad) 59 | { 60 | if(nedad<0) 61 | { 62 | cout << "Edad incorrecta." << endl; 63 | edad=0; 64 | } 65 | else 66 | { 67 | edad = nedad; 68 | } 69 | } 70 | 71 | void Persona::set_dni(string ndni) 72 | { 73 | dni=ndni; 74 | validar_dni(); 75 | } 76 | 77 | void Persona::validar_dni() 78 | { 79 | string letras; 80 | char letra; 81 | int num; 82 | letras="TRWAGMYFPDXBNJZSQVHLCKE"; 83 | if (dni.size()!=9) 84 | { 85 | cout << "DNI incorrecto." << endl; 86 | dni=""; 87 | } 88 | else 89 | { 90 | letra=dni[8]; 91 | num=stoi(dni.erase(8,1)); //stoi convierte un string a entero 92 | dni=dni+letra; //Vuelvo a poner la letra al DNI 93 | if (toupper(letra) != letras[num%23]) 94 | { 95 | cout << "DNI incorrecto." << endl; 96 | dni=""; 97 | } 98 | } 99 | } 100 | 101 | string Persona::mostrar() 102 | { 103 | return "Nombre:"+nombre+ " - Edad:"+ to_string(edad)+ " - DNI:" + dni; 104 | } 105 | 106 | bool Persona::esMayorDeEdad() 107 | { 108 | return(edad>18); 109 | } 110 | 111 | 112 | //// Ejercicio 2 113 | 114 | class Cuenta 115 | { 116 | protected: 117 | Persona titular; 118 | float cantidad; 119 | public: 120 | Cuenta(Persona nt,float nc); 121 | Persona get_titular(); 122 | float get_cantidad(); 123 | void set_titular(Persona nt); 124 | string mostrar(); 125 | void ingresar(float ncantidad); 126 | void retirar(float ncantidad); 127 | 128 | }; 129 | 130 | Cuenta::Cuenta(Persona nt,float nc) 131 | { 132 | titular=nt; 133 | cantidad=nc; 134 | } 135 | 136 | float Cuenta::get_cantidad() 137 | { 138 | return cantidad; 139 | } 140 | 141 | Persona Cuenta::get_titular() 142 | { 143 | return titular; 144 | } 145 | 146 | void Cuenta::set_titular(Persona nt) 147 | { 148 | titular=nt; 149 | } 150 | 151 | 152 | string Cuenta::mostrar() 153 | { 154 | return "Titular: " + titular.mostrar() + " - Cantidad: " + to_string(cantidad); 155 | } 156 | 157 | void Cuenta::ingresar(float ncantidad) 158 | { 159 | if (ncantidad>0) cantidad=cantidad+ncantidad; 160 | } 161 | 162 | void Cuenta::retirar(float ncantidad) 163 | { 164 | if (ncantidad>0) cantidad=cantidad-ncantidad; 165 | } 166 | 167 | int main(int argc, char *argv[]) { 168 | Persona yo("Jose Domingo",40,"12345678Z"); 169 | Cuenta micuenta(yo,1000); 170 | cout << micuenta.mostrar()<// Demostracion del uso de iteradores 2 | // probado en: Dev-C++ 4.9.9.2 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | using namespace std; 9 | 10 | int main(int argc, char *argv[]) 11 | { 12 | vector v; 13 | 14 | for (char x = 'A'; x <= 'Z'; x++) 15 | v.push_back(x); 16 | 17 | // obtenemos un iterator del tipo char 18 | vector::iterator it; 19 | 20 | // lectura y despliegue de datos 21 | cout << "\ndesplegando datos" << endl; 22 | for( it = v.begin(); it != v.end(); it++ ) 23 | cout << *it << endl; 24 | 25 | return EXIT_SUCCESS; 26 | } 27 | -------------------------------------------------------------------------------- /pildoras/STL/map.cpp: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | using namespace std; 9 | 10 | /*----------------------------------------*/ 11 | typedef pair venta_dia; 12 | 13 | int main() 14 | { 15 | cout << "\nUna simple prueba de map\n"; 16 | cout << "........................\n"; 17 | map semana; 18 | 19 | semana.insert( venta_dia("lunes", 300.65) ); 20 | semana.insert( venta_dia("martes", 456.12) ); 21 | semana.insert( venta_dia("miercoles", 234.56) ); 22 | double total = 0; 23 | 24 | map::iterator p = semana.begin(); 25 | while (p != semana.end() ) 26 | { 27 | cout << setw(10) << p->first << setw(12) << p->second << endl; 28 | total += p->second; 29 | p ++; 30 | } 31 | 32 | cout << "........................\n"; 33 | cout << setw(10) << "total:" << setw(12) << total << endl; 34 | 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /pildoras/STL/ordenar.cpp: -------------------------------------------------------------------------------- 1 | 2 | #include 3 | #include 4 | 5 | using namespace std; 6 | 7 | void show(int a[]) 8 | { 9 | for(int i = 0; i < 10; ++i) 10 | cout << a[i] << " "; 11 | } 12 | 13 | int main() 14 | { 15 | int a[10]= {1, 5, 8, 9, 6, 7, 3, 4, 2, 0}; 16 | cout << "\n The array before sorting is : "; 17 | show(a); 18 | 19 | sort(a, a+10); 20 | 21 | cout << "\n\n The array after sorting is : "; 22 | show(a); 23 | 24 | return 0; 25 | 26 | } 27 | -------------------------------------------------------------------------------- /pildoras/STL/verctor.cpp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/josedom24/curso_cplusplus/f3b7fade9b2e661cc98b4bfc7ccf0bb4239373f6/pildoras/STL/verctor.cpp -------------------------------------------------------------------------------- /recursos.md: -------------------------------------------------------------------------------- 1 | # Recursos, enlaces interessante 2 | 3 | * http://c.conclase.net/curso/index.php 4 | * http://www.cplusplus.com/ 5 | * https://www.tutorialspoint.com/cplusplus/index.htm 6 | * http://www4.tecnun.es/asignaturas/Informat1/AyudaInf/aprendainf/cpp/basico/cppbasico.pdf 7 | * http://www4.tecnun.es/asignaturas/Informat1/AyudaInf/aprendainf/cpp/avanzado/cppavan.pdf 8 | * https://www.uv.es/sto/cursos/c++/curso95.pdf 9 | 10 | #### 2019 11 | 12 | * https://www.geeksforgeeks.org/char-vs-stdstring-vs-char-c/ 13 | * https://www.programiz.com/cpp-programming 14 | * [String](https://www.geeksforgeeks.org/c-string-class-and-its-applications/) 15 | * [arrays](http://www.cplusplus.com/doc/tutorial/arrays/) 16 | --------------------------------------------------------------------------------