fix(guide): simplify directory structure

guide/spanish/cplusplus/C- STL sets/index.md

@@ -0,0 +1,23 @@
+InlocaleTitle: undefined
+tReproducción de conjuntos en la librería STL de C ++. Los conjuntos son un tipo de contenedores asociativos en los que cada elemento debe ser único. El valor del elemento no se puede modificar una vez que se agrega al conjunto, aunque es posible eliminar y agregar el valor modificado de ese elemento. Se implementan utilizando el árbol rojo-negro.
+
+Beneficios de usar conjuntos
+
+1.  Almacena solo valores únicos.
+2.  El valor del elemento se identifica. El valor de un elemento es también la clave utilizada para identificarlo.
+3.  Proporciona una búsqueda rápida (O (log n)) usando las teclas, es decir, el elemento en sí.
+4.  Hay muchas funciones incorporadas en los conjuntos de definición de clase que facilitan la programación.
+
+Ejemplo: '' 'c ++
+
+# incluir
+
+utilizando namespace std; int main () { conjunto s;
+
+inserto (2); // inserta el elemento 2 en el conjunto s inserto (3); inserto (5); inserto (2); // insertando el mismo elemento 2 inserto (6); para (auto i: s) cout << i << ""; cout << s.size () << endl; // da el tamaño del conjunto
+
+s.erase (5); // borrando el elemento 5 del set s devuelve 0; } '' ' Creando un objeto establecido '' 'c ++ conjunto s; '' '
+
+Inserción '' 'c ++ s.insert (valor _a_ ser\_insertado); '' '
+
+Accediendo a los elementos establecidos. '' 'c ++ conjunto :: iterador it; para (it = s.begin (); it! = s.end (); ++ it) cout << \* it; '' '

guide/spanish/cplusplus/arrays/index.md

@@ -0,0 +1,42 @@
+---
+title: C++ Arrays
+localeTitle: Arrays C ++
+---
+## ¿Qué son las matrices?
+
+Una matriz es una serie de elementos del mismo tipo de datos que se almacenan en ubicaciones de memoria contiguas y pueden referenciarse individualmente.
+
+Por ejemplo, una matriz que contiene 5 valores enteros llamados números se declara así:
+
+```C++
+int numbers [5]; 
+```
+
+Inicialización:
+
+```C++
+//Initialization with entries: 
+ int numbers [5] = {1, 2, 3, 4, 5}; 
+ 
+ //Initialization with no values: 
+ int numbers [5] = {}; 
+ 
+ //Initialization with declaration: 
+ int numbers [] = {1, 2, 3, 4, 5}; 
+ //Note that here the number of values defines the size of the array. 
+ //In the examples above, the size was fixed beforehand 
+```
+
+**Tenga** en **cuenta** que las matrices en C ++ no son permutables en tamaño, lo que significa que una vez que haya declarado una matriz con tamaño 5, no se puede ampliar o reducir. En caso de que realmente necesite una matriz más grande con las mismas entradas, tendría que copiar todas las entradas a una nueva matriz de mayor tamaño.
+
+### Acceso:
+
+Se puede acceder a los elementos de una matriz a través de la referencia de su posición en la matriz. (Comience contando desde 0).  
+Ejemplo:
+
+```C++
+x = numbers[0]; // = 1. [0] == first position 
+ numbers[2] = 55; // Sets the third position (3) to the new number 55 
+ //numbers[] is now: {1, 2, 55, 4, 5} 
+
+```

guide/spanish/cplusplus/casting/index.md

@@ -0,0 +1,88 @@
+---
+title: Casting
+localeTitle: Fundición
+---
+## Fundición
+
+Un cast es un operador especial que obliga a un tipo de datos a convertirse en otro
+
+La conversión en C ++ difiere un poco de la de C. C ++ hace uso de distintas funciones de conversión.
+
+### static\_cast
+
+La conversión estática se utiliza para las conversiones implícitas entre primitivas y sobrecargas de tipos.
+
+### const\_cast
+
+Se puede usar Const cast para lanzar la constancia. Esto es útil cuando hay un deseo de mutar un valor constante. Esto debería usarse con moderación, en cambio, uno debería considerar hacer parámetros / funciones no constantes en los casos en que se utiliza una conversión constante.
+
+Const cast también puede resultar en un comportamiento indefinido. La única aplicación de const cast debería ser eliminar la constancia de un valor que se pasó a una función y se marcó const. Si el valor es realmente constante, es decir, se marca const en el momento de la compilación y se le asigna un valor, la conversión constante y la mutación de la variable darán como resultado un comportamiento indefinido.
+```
+const int y = 10;             // y is set to 10. 
+ const_cast<int &>(y) = 20;    // undefined behaviour. 
+```
+
+### dynamic\_cast
+
+La conversión dinámica se utiliza para convertir un objeto dentro de su jerarquía de clases (de padre a padre, de padre y de hermanos). El reparto dinámico solo puede ser llamado en clases polimórficas. Por lo tanto, la clase original en este caso, `MyClass` debe tener un miembro virtual, que está presente en la forma del destructor virtual.
+
+Si el reparto dinámico falla, devolverá un `nullptr` . La conversión dinámica puede ser útil para determinar los tipos de objetos en tiempo de ejecución. Sin embargo, debe tenerse en cuenta que la conversión dinámica no es gratuita y, en algunos casos, otras técnicas pueden resultar más eficientes en la determinación del tipo de clase en el tiempo de ejecución.
+
+### reinterpretar\_cast
+
+Reinterpretar el reparto es quizás el más peligroso de todos los repartos de C ++, pero cuando se usa correctamente puede ser ideal. Reinterpretar cast no incurre en ningún costo de rendimiento, ya que no realiza ninguna conversión. Simplemente le indica al compilador que trate el objeto fundido como si fuera el tipo solicitado. Esto también puede generar problemas de alineación, por lo que debe usarse con moderación y solo cuando se conocen y se tienen en cuenta los efectos secundarios.
+
+#### Una nota sobre moldes de estilo C
+
+C ++ admite el uso de moldes de estilo C, aunque no se recomiendan. El uso de la conversión de estilo C le indicará al compilador que realice primero una conversión estática _, si la conversión estática_ falla, se usa reinterpret\_cast en su lugar. Por esta razón, los modelos de estilo C pueden producir resultados impredecibles y generar problemas inesperados.
+
+## Ejemplos
+
+```cpp
+#include <iostream> 
+ 
+ class MyClass { 
+ public: 
+    virtual ~MyClass() = default; 
+ 
+    void greet() { 
+        std::cout << "Hello World!" << std::endl; 
+    } 
+ }; 
+ 
+ class MyClassChild : public MyClass { 
+ }; 
+ 
+ void reinterpretCastTest(void *objectPtr) { 
+    // Let's assume we know objectPtr is of type MyClass * 
+    auto myClassObj = reinterpret_cast<MyClassChild *>(objectPtr); 
+    myClassObj->greet(); 
+ } 
+ 
+ void constCastTest(const MyClassChild &myClassChild) { 
+    auto nonConst = const_cast<MyClassChild &>(myClassChild); 
+    nonConst.greet(); 
+ } 
+ 
+ void dynamicCastTest(MyClass *myClass) { 
+    auto *child = dynamic_cast<MyClassChild *>(myClass); 
+    child->greet(); 
+ } 
+ 
+ void staticCastTest(float floatVal) { 
+    // Convert the float into an int. 
+    auto intVal = static_cast<int>(floatVal); 
+    std::cout << intVal << std::endl; 
+ } 
+ 
+ int main() { 
+    MyClassChild myClass; 
+    reinterpretCastTest(&myClass); 
+    constCastTest(myClass); 
+    dynamicCastTest(&myClass); 
+    staticCastTest(10.5); 
+ 
+    return 0; 
+ } 
+
+```

guide/spanish/cplusplus/clean-code-guidelines/index.md

@@ -0,0 +1,109 @@
+---
+title: Clean Code Guidelines
+localeTitle: Pautas de código limpio
+---
+# Pautas de código limpio
+
+Al codificar, el estilo de codificación que sigues puede ser realmente importante. Especialmente cuando está trabajando con un equipo o planea compartir su código. La mayoría de estas pautas son estándar y se pueden aplicar a la mayoría de los lenguajes de programación, sin embargo, aquí tiene aplicaciones y Fragmentos con código c ++, para que pueda familiarizarse con él más fácilmente. Recuerde que estas son solo recomendaciones para lograr claridad, lo que puede ser una preferencia personal, así que tome estos consejos en cuenta pero no los lleves a la carta. A veces, romper algunas de estas reglas puede llevar a un código más limpio.
+
+## Use buenos nombres de variables y haga comentarios
+
+Asegúrese de crear buenos nombres de variables, por ejemplo, si está creando un juego, evite usar la variable "a" use algo como "p1" en referencia al jugador 1. La [notación húngara](https://en.wikipedia.org/wiki/Hungarian_notation) se suele difundir y puede darle algunas pautas para declarar variables
+
+Además, POR FAVOR, use comentarios, ni siquiera estoy bromeando, solo trate de leer algunos proyectos antiguos que hizo sin comentarios ... ahora imagine que es otra persona que ni siquiera lo codificó.
+
+## Variables globales
+
+Las variables globales pueden ser fáciles de usar, y con poco código puede parecer una gran solución. Pero, cuando el código se hace más y más grande, se vuelve más difícil saber cuándo se están utilizando.
+
+En lugar de usar variables globales, puede usar variables declaradas en funciones que pueden ayudarlo a saber qué valores se están pasando. y la identificación de errores más rápido.
+
+```cpp
+#include <iostream> 
+ using namespace std; 
+ 
+ // Global variables are declared outside functions 
+ int cucumber; // global variable "cucumber" 
+```
+
+## Usando goto, continuar, etc.
+
+Esta es una discusión habitual entre los programadores, al igual que las variables globales, estos tipos de declaraciones generalmente se consideran una mala práctica. Son considerados malos porque llevan al ["código spaguetti"](https://en.wikipedia.org/wiki/Spaghetti_code) . Cuando programamos queremos un Flujo lineal: cuando se usan esas declaraciones, el flujo se modifica y conduce a un flujo "retorcido y enredado".
+
+Goto se utilizó en el pasado, mientras que mientras, para las funciones, sin embargo, con la introducción de la programación estructurada se creó. En general, evite usar goto a menos que esté seguro de que hará que su código sea más limpio y fácil de leer. Un ejemplo podría estar usándolo en bucles anidados.
+
+El uso de break y continue es prácticamente el mismo. Utilícelos en los conmutadores e intente realizar funciones con un único propósito para que solo tenga un punto de salida.
+
+![img](https://imgs.xkcd.com/comics/goto.png)
+
+## Evite cambiar la variable de control dentro de un bucle for
+
+Por lo general, hay trabajos alrededor de esto que parecen más claros y menos confusos, por ejemplo. mientras bucles. Hacer:
+
+```cpp
+int i=1; 
+ while (i <= 5) 
+ { 
+    if (i == 2) 
+        i = 4; 
+ 
+    ++i; 
+ } 
+```
+
+En lugar de:
+
+```cpp
+for (int i = 1; i <= 5; i++) 
+ { 
+    if (i == 2) 
+    { 
+       i = 4; 
+    } 
+    // Do work 
+ } 
+```
+
+## Declarar constantes y tipos en la parte superior.
+
+Por lo general, se declaran después de las bibliotecas, lo que las hace estar más juntas y más fáciles de leer. Para las variables locales sucede lo mismo, declararlas en la parte superior (Otras personas prefieren que las declaren lo más tarde posible para ahorrar memoria, consulte: [cplusplus.com](http://www.cplusplus.com/forum/general/33612/)
+
+## Usa solo una función de retorno al final.
+
+Como dijimos antes, tendemos a hacer solo una entrada y salida para que el flujo sea más claro.
+
+## Usa llaves cuando escribas una sola línea
+
+Hacerlo sistemáticamente lo ayudará a hacerlo más rápido y, en caso de que desee cambiar el código en el futuro, podrá hacerlo sin preocupaciones.
+
+En lugar de:
+
+```cpp
+for (int i = 1; i <= 5; i++) 
+    //CODE 
+```
+
+Hacer:
+
+```cpp
+for (int i = 1; i <= 5; i++) 
+ { 
+    //CODE 
+ } 
+```
+
+## Otras recomendaciones
+
+*   #### Úselo para cuando sepa la cantidad de iteraciones, mientras que haga y cuando no lo haga.
+    
+*   #### Use const, pase por valor / referencia cuando sea apropiado. Esto ayudará a salvar la memoria.
+    
+*   \#### Escriba const en mayúsculas, tipos de datos que comienzan con T y variables en minúsculas.
+    
+
+```cpp
+const int MAX= 100;             //Constant 
+ typedef int TVector[MAX];       //Data type 
+ TVector vector;                 //Vector 
+
+```

guide/spanish/cplusplus/compilers/index.md

@@ -0,0 +1,55 @@
+---
+title: C++ Compilers
+localeTitle: Compiladores C ++
+---
+# Introducción a los compiladores de C ++
+
+Para comenzar con C ++, necesitará aprender un poco sobre los compiladores y cómo se ejecuta C ++ en su computadora.
+
+Cuando todo está dicho y hecho, las computadoras solo entienden un idioma, el lenguaje de máquina. El lenguaje de máquina está compuesto enteramente de bits binarios, o 0s y 1s. Si bien sería posible programar en binario, sería increíblemente tedioso y lento. Entonces, los humanos desarrollamos lenguajes de programación para facilitar el desarrollo de software. El lenguaje ensamblador es un 1 a 1 directo con maquina. idioma. Los lenguajes como C, C ++ y COBOL son un poco más altos y deben compilarse. Va aún más alto. Idiomas como JavaScript y Python tienen componentes que se traducen a C ++ u otros lenguajes de bajo nivel antes de ser compilados, efectivamente haciéndolos lenguajes "superiores" que C o C ++. Debido a que la arquitectura de la computadora está formada por interruptores y cables electrónicos que solo pueden funcionar con 1s y 0s binarios, necesita un compilador para traducir su código de C ++ de alto nivel al lenguaje de máquina que la CPU pueda entender.
+
+Los compiladores son programas de utilidad que toman su código y lo transforman en archivos de código de máquina ejecutables. Cuando ejecutas un compilador en su código, primero, el preprocesador lee el código fuente (el archivo C ++ que acaba de escribir). El preprocesador busca cualquier Directivas de preprocesador (líneas de código que comienzan con un #). Directivas de preprocesador causan la preprocesador para cambiar su código de alguna manera (por lo general agregando alguna biblioteca u otro archivo C ++). A continuación, el compilador trabaja a través del código preprocesado línea a línea traduciendo Cada línea en la instrucción apropiada del lenguaje de máquina. Esto también descubrirá cualquier error de sintaxis presente en su código fuente y arrojará un error a la línea de comandos. Finalmente, si no hay errores presentes, el compilador crea un objeto Archivo con el binario del lenguaje de máquina necesario para ejecutar en su máquina. Mientras que el archivo objeto que el compilador acaba de crear es probable que haga algo en su computadora, aún no es un ejecutable funcional de su programa C ++. Hay una final Paso importante para alcanzar un programa ejecutable.
+
+C ++ contiene una vasta biblioteca para ayudar a realizar tareas difíciles como la E / S y la manipulación de hardware. Puedes incluir estos bibliotecas con directivas de preprocesador, pero el preprocesador no las agrega automáticamente a su código. Para que tengas un programa ejecutable final, otra utilidad conocida como el enlazador debe combinar sus archivos de objetos con las funciones de la biblioteca necesario para ejecutar el código. Piensa que tiene todos los bloques necesarios. para construir una casa. El compilador hizo todos los bloques, pero el enlazador es el que los une a todos para crear finalmente una casa. Una vez hecho esto, ahora tiene un archivo ejecutable en funcionamiento!
+
+## Cómo compilar un archivo
+
+Digamos que tienes un archivo C ++ llamado `helloWorld.cpp` ...
+
+### Si estás en Windows -
+
+#### Usando y IDE como CodeBlocks
+
+Es tan simple como hacer clic en los botones de compilación y ejecución, crearán un archivo en la carpeta del proyecto. ![img](https://i.imgur.com/FwZuFGy.png)
+
+#### Usando el símbolo del sistema
+
+1.  Abra un símbolo del sistema del desarrollador: para este paso, deberá tener Microsoft Visual Studio o algún otro IDE que le permite compilar su programa desde la línea de comandos. También puede buscar en línea los compiladores de C ++.
+    
+2.  Navegue directamente al código fuente
+    
+3.  Ejecute el compilador en su código fuente (asumiendo que está usando el compilador de Microsoft Visual Studio) `cl /EHsc helloWorld.cpp`
+    
+
+Esto ahora creará un archivo de objeto y lo vinculará automáticamente por usted. Si miras en esa misma carpeta, verás una El archivo ejecutable hellWorld.exe (tenga en cuenta la extensión exe) ahora está presente.
+
+4.  Escriba `helloWorld` en el indicador para ejecutar el ejecutable
+
+Alternativamente, muchos IDE permiten la construcción y visualización rápida de su programa. Esto puede ser más fácil ya que su versión de Windows no puede venir preempaquetado con una utilidad de compilación.
+
+### Si estás en Linux o OSX -
+
+1.  Abre una ventana de terminal y navega al directorio de código fuente
+2.  Ejecuta el compilador en tu código fuente `g++ helloWorld.cpp -o helloWorld`
+
+Esto creará un archivo de objeto y lo vinculará automáticamente por usted. Busque en la carpeta y verá un helloWorld.exe archivo ejecutable (note la extensión exe).
+
+3.  Escriba `./helloWorld` en la ventana del terminal para ejecutar el archivo ejecutable
+
+g ++ es el compilador estándar de Linux y es una gran utilidad. Viene empaquetado con el sistema operativo.
+
+NOTA: Para compilar y ejecutar su código directamente, ejecute `g++ -o helloWorld helloWorld.cpp; ./helloWorld` así que cuando necesite compilar y ejecutar su código varias veces, flecha arriba entrar
+
+* * *
+
+Hay una serie de diferentes tipos de compiladores. Los dos enumerados son los dos que generalmente se empaquetan con Windows o Linux / OSX.

guide/spanish/cplusplus/conditional-operator/index.md

@@ -0,0 +1,44 @@
+---
+title: Conditional Operator
+localeTitle: Operador condicional
+---
+## Operador condicional
+
+El operador condicional es un operador ternario, es decir, necesita 3 operandos. Devuelve uno de los dos valores dependiendo del resultado de una expresión El operador condicional se utiliza para reemplazar una simple instrucción if-else.
+
+Sintaxis:
+
+```cpp
+  (condition)?(expression-1):(expression-2); 
+```
+
+Aquí, la expresión-1 se evalúa cuando la condición es verdadera y la expresión-2 se evalúa cuando la condición es falsa. Una declaración similar if-else sería:
+
+```cpp
+if(condition) 
+  { 
+    expression-1; 
+  } 
+ else 
+  { 
+    expression-2; 
+  } 
+```
+
+Por lo tanto, el operador condicional es muy útil cuando se necesita escribir una declaración simple de if-else. También se puede utilizar en #define. preprocesador cuando se utiliza una condición similar en varios lugares.
+
+Por ejemplo, para encontrar un máximo de dos operadores condicionales numéricos se puede utilizar de la siguiente manera:
+
+```cpp
+#define big(a,b) (a>=b)?a:b 
+ 
+ int maximum,x=5,y=6; // variable to store maximum of two numbers 
+ maximum=(x>y)?x:y; // directly using conditional operator 
+ maximum=big(x,y); // using the #define preprocessor defined above as big 
+```
+
+**Buena suerte a todos ustedes**
+
+**¡Feliz codificación! :)**
+
+**No dude en preguntar cualquier duda en la página de GitHub de [FreeCodeCamp](https://forum.freecodecamp.org/) o en [el foro de FreeCodeCamp.](https://forum.freecodecamp.org/)**

guide/spanish/cplusplus/do-while-loop/index.md

@@ -0,0 +1,43 @@
+---
+title: do while loop
+localeTitle: hacer mientras bucle
+---
+## Hacer mientras bucle
+
+El `do while loop` es casi el mismo que el bucle while. El `do while loop` tiene la siguiente forma:
+
+```cpp
+do 
+ { 
+  // do something; 
+ } while(expression); 
+```
+
+Nota: recuerde utilizar un punto y coma ';' Al final de la condición.
+
+## Detalles sobre el bucle do-while
+
+El bucle do-while se utiliza siempre que esté seguro de que un proceso particular (dentro del bucle) debe realizarse al menos una vez. Tiene muchas ventajas, como no inicializar la variable de comprobación (por ejemplo, char addmore = 'Y'), etc. El punto y coma al final de while es obligatorio.
+
+Haz algo primero y luego prueba si tenemos que continuar. El resultado es que el bloque do se ejecuta al menos una vez. (Porque la prueba de expresión viene después). Echa un vistazo a un ejemplo:
+
+```cpp
+#include <iostream> 
+    using namespace std; 
+ 
+    int main() 
+    { 
+        int counter, howmuch; 
+ 
+        cin >> howmuch; 
+        counter = 0; 
+        do 
+        { 
+            counter++; 
+            cout << counter << '\n'; 
+        } 
+        while ( counter < howmuch); 
+        return 0; 
+    } 
+
+```

guide/spanish/cplusplus/dynamic-memory-allocation/index.md

@@ -0,0 +1,40 @@
+---
+title: Dynamic Memory Allocation
+localeTitle: Asignación de memoria dinámica
+---
+## Asignación de memoria dinámica en C ++
+
+### ¿Qué es la asignación de memoria dinámica en C ++?
+
+*   **La asignación de memoria** en C ++ se refiere a la memoria asignada a las variables que utiliza en todo su programa.
+*   **La asignación dinámica de memoria** es la memoria que se asigna a las variables en el tiempo de ejecución y la cantidad de memoria requerida también se decide en el tiempo de ejecución.
+*   Esta memoria proviene del **montón** , mientras que _las_ variables _no estáticas_ y _las_ variables _locales_ obtienen memoria de la **pila** .
+*   En C ++, el programador puede realizar asignaciones de memoria manualmente y se llama como **_asignación de memoria dinámica_** .
+*   En C fue posible realizar una asignación de memoria dinámica, mediante el uso de las funciones _calloc_ y _malloc_ para asignar memoria y el uso de _la_ función _libre_ para desasignar la memoria dinámica.
+*   En C ++, además de lo anterior, hay dos funciones, _nueva_ y _eliminar_ para realizar la asignación y desasignación de memoria dinámica.
+
+### NUEVO operador
+
+*   `new` operador puede otorgar la memoria del programador desde el montón (si está disponible). Si la memoria que solicita el programador está disponible, el `new` operador inicializa la memoria y luego devuelve la dirección (referencia) de la memoria asignada.
+*   **Sintaxis**  
+    `pointer-variable-type` = **nuevo** `data-type;`  
+    Ejemplo 1: `int *ptr` = **new** `int;`  
+    Ejemplo 2: `int *ptr2` = **new** `int[10];`  
+    Aquí, `pointer-variable-type` es un **puntero** de `data type` de `data type` . El `data-type` puede ser int, char, etc. o el tipo de datos definido por el usuario.
+
+### Borrar operador
+
+*   Es responsabilidad del programador desasignar la memoria asignada dinámicamente, de lo contrario, la memoria no estaría disponible para ser reasignada hasta el final del programa.
+    
+*   Para desasignar la memoria, el operador de `delete` está disponible y puede ser utilizado por el programador.
+    
+*   **Sintaxis**  
+    **eliminar** `pointer-type-variable;`  
+    Por ejemplo, para liberar la memoria asignada en el ejemplo 1 anterior, escribimos:  
+    `delete ptr;`  
+    Del mismo modo, por ejemplo 2, la memoria puede ser liberada por:  
+    `delete ptr2` ;
+    
+    ### Pérdidas de memoria
+    
+    Las fugas se producen cuando no puede desasignar la memoria dinámica que asignó a través del `New` operador al final de su programa. Si no lo desasigna con el operador Eliminar, su computadora seguirá creando nueva memoria en el montón cada vez que se ejecute el programa. Esto hace que su computadora se ralentice porque la memoria no se elimina y su memoria disponible disminuye.

guide/spanish/cplusplus/erase-remove/index.md

@@ -0,0 +1,88 @@
+---
+title: Erase–remove idiom
+localeTitle: Borrar - eliminar idioma
+---
+## Desciframiento
+
+Cómo eliminar elementos del contenedor es una pregunta común de la entrevista de C ++, por lo que puede ganar algunos puntos de brownie, si lee esta página detenidamente. El lenguaje de borrar / eliminar es una técnica de C ++ para eliminar elementos que cumplen un cierto criterio de un contenedor. Sin embargo, es posible eliminar elementos con el bucle tradicional escrito a mano, pero el lenguaje de borrado-eliminar tiene varias ventajas.
+
+### Comparación
+
+```cpp
+// Using a hand-written loop 
+ std::vector<int> v = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; 
+ for (auto iter = v.cbegin(); iter < v.cend(); /*iter++*/) 
+ { 
+    if (is_odd(*iter)) 
+    { 
+        iter = v.erase(iter); 
+    } 
+    else 
+    { 
+        ++iter; 
+    } 
+ } 
+ 
+ // Using the erase–remove idiom 
+ std::vector<int> v = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; 
+ v.erase(std::remove_if(v.begin(), v.end(), is_odd), v.end()); 
+```
+
+Como puede ver, el código con bucle escrito a mano requiere un poco más de escritura, pero también tiene un problema de rendimiento. Cada llamada de `erase` debe avanzar todos los elementos después del borrado, para evitar "huecos" en la colección. Al llamar a `erase` varias veces en el mismo contenedor se generan muchos gastos generales al mover los elementos.
+
+Por otro lado, el código con el lenguaje borrado-eliminar no solo es más expresivo, sino que también es más eficiente. Primero, use `remove_if/remove` para mover todos los elementos que no se ajustan al criterio de eliminación al frente del rango, manteniendo el orden relativo de los elementos. Entonces, después de llamar a `remove_if/remove` , una sola llamada de `erase` elimina todos los elementos restantes al final del rango.
+
+### Ejemplo
+
+```cpp
+#include <vector> // the general-purpose vector container 
+ #include <iostream> // cout 
+ #include <algorithm> // remove and remove_if 
+ 
+ bool is_odd(int i) 
+ { 
+    return (i % 2) != 0; 
+ } 
+ 
+ void print(const std::vector<int> &vec) 
+ { 
+    for (const auto& i : vec) 
+        std::cout << i << ' '; 
+    std::cout << std::endl; 
+ } 
+ 
+ int main() 
+ { 
+    // initializes a vector that holds the numbers from 1-10. 
+    std::vector<int> v = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; 
+    print(v); 
+ 
+    // removes all elements with the value 5 
+    v.erase(std::remove(v.begin(), v.end(), 5), v.end()); 
+    print(v); 
+ 
+    // removes all odd numbers 
+    v.erase(std::remove_if(v.begin(), v.end(), is_odd), v.end()); 
+    print(v); 
+ 
+    // removes multiples of 4 using lambda 
+    v.erase(std::remove_if(v.begin(), v.end(), [](int n) { return (n % 4) == 0; }), v.end()); 
+    print(v); 
+ 
+    return 0; 
+ } 
+ 
+ /* 
+ Output: 
+ 1 2 3 4 5 6 7 8 9 10 
+ 1 2 3 4 6 7 8 9 10 
+ 2 4 6 8 10 
+ 2 6 10 
+ */ 
+```
+
+### Fuentes
+
+"Borrar: eliminar idioma" Wikipedia: The Free Encyclopedia. Wikimedia Foundation, Inc. [en.wikipedia.org/wiki/Erase-remove\_idiom](https://en.wikipedia.org/wiki/Erase%E2%80%93remove_idiom)
+
+Meyers, Scott (2001). STL efectivo: 50 maneras específicas de mejorar su uso de la biblioteca de plantillas estándar. Addison-Wesley.

guide/spanish/cplusplus/error handling/index.md

@@ -0,0 +1,49 @@
+---
+title: Error Handling
+localeTitle: Manejo de errores
+---
+# Manejo de excepciones C ++
+
+Una excepción es un problema que surge durante la ejecución de un programa. Las excepciones proporcionan una forma de transferir el control de una parte de un programa a otra. El control de excepciones de C ++ se basa en tres palabras clave: #try, #catch y #throw.
+
+*   # throw: un programa lanza una excepción cuando aparece un problema. Esto se hace usando una palabra clave throw.
+    
+*   # captura: un programa detecta una excepción con un controlador de excepciones en el lugar de un programa en el que desea manejar el problema. La palabra clave catch indica la captura de una excepción.
+    
+*   #try: un bloque try identifica un bloque de código para el cual se activarán excepciones particulares. Es seguido por uno o más bloques de captura.
+    
+
+```CPP
+#include <iostream> 
+ using namespace std; 
+ 
+ int main() 
+ { 
+   int x = -1; 
+ 
+   // Some code 
+   cout << "Before try \n"; 
+   try { 
+      cout << "Inside try \n"; 
+      if (x < 0) 
+      { 
+         throw x; 
+         cout << "After throw (Never executed) \n"; 
+      } 
+   } 
+   catch (int x ) { 
+      cout << "Exception Caught \n"; 
+   } 
+ 
+   cout << "After catch (Will be executed) \n"; 
+   return 0; 
+ } 
+```
+
+# Antes de continuar ...
+
+## Una revisión
+
+*   Agrupación de tipos de error.
+*   Separación del código de manejo de errores del código normal.
+*   Las funciones / métodos pueden manejar cualquier excepción que elijan.

guide/spanish/cplusplus/for-loop/index.md

@@ -0,0 +1,91 @@
+---
+title: For Loop
+localeTitle: En bucle
+---
+Un For Loop es una declaración repetitiva que se usa para verificar alguna condición y luego, según la condición, un bloque de código se ejecuta repetidamente hasta que se cumple la condición especificada.
+
+El bucle for se distingue de otras declaraciones de bucle a través de un contador de bucle explícito o variable de bucle que permite al cuerpo del bucle conocer la secuencia exacta de cada iteración.
+
+Por lo tanto, un bucle for es una estructura de control de repetición que le permite escribir de manera eficiente un bucle que necesita ejecutarse un número específico de veces.
+
+## Sintaxis
+```
+for ( init; condition; increment ) { 
+   statement(s); 
+ } 
+```
+
+Se permite colocar el incremento en el bucle for como en un bucle while. Significar una sintaxis como esta también puede funcionar.
+```
+for ( init; condition;) { 
+   statement(s); 
+   increment; 
+ } 
+```
+
+### en eso
+
+Este paso le permite declarar e inicializar cualquier variable de control de bucle. Este paso se realiza primero y solo una vez.
+
+### condición
+
+A continuación se evalúa la condición. Si se mantiene verdadero, se ejecuta el cuerpo del bucle. Si es falso, el cuerpo del bucle no se ejecuta y el flujo de control salta a la siguiente iteración (repetición de un proceso).
+
+### actualizar
+
+La instrucción de actualización se usa para alterar la variable del bucle mediante operaciones simples como la suma, resta, multiplicación o división. La instrucción de actualización se ejecuta después de la ejecución del cuerpo del bucle.
+
+## IMPLEMENTACIÓN:
+
+```C++
+#include <iostream> 
+ using namespace std; // Here we use the scope resolution operator to define the scope of the standar functions as std:: 
+ 
+ int main () { 
+   // for loop execution 
+   for( int a = 10; a < 20; a = a + 1 ) { // The loop will run till the value of a is less than 20 
+      cout << "value of a: " << a << endl; 
+   } 
+ 
+   return 0; 
+ }``` 
+ 
+ Output: 
+ value of a: 10 
+ value of a: 11 
+ value of a: 12 
+ value of a: 13 
+ value of a: 14 
+ value of a: 15 
+ value of a: 16 
+ value of a: 17 
+ value of a: 18 
+ value of a: 19 
+ 
+ ##Single lined loop 
+ The body of the for loop need not be enclosed in braces if the loop iterates over only one satatement. 
+ ##Example 
+```
+
+c ++ #incluir utilizando namespace std;
+
+int main () { // Línea única para bucle para (int a = 10; a <20; a = a + 1) cout << "valor de a:" << a << endl;
+
+devuelve 0; } \`\` \`
+
+Esto generaría la misma salida que el programa anterior. es decir Salida: valor de a: 10 valor de a: 11 valor de a: 12 valor de a: 13 valor de a: 14 valor de a: 15 valor de a: 16 valor de a: 17 valor de a: 18 valor de a: 19
+```
+## Explanation 
+ Here's the initialization condition is first set to a=10. The loop first checks for this condition. It then checks for the condition expression ie a<20 which holds true as 10<20(for the first case). Now the body of the loop is executed and we get the output "Value of a: 10". Then the update expression is executed which adds the number 1 to 'a' and the value of 'a' gets updated to 11 and the same steps are followed (as above) until the value of v reaches less than 20 ie 19. 
+ 
+ # Range-based for-loop 
+ C++ also has what we call range-based for loops which iterates through all the elements of a container(eg array). 
+ 
+ ## Syntax 
+```
+
+para (elemento: contenedor) declaración (es); }
+
+int \[5\] array = {1, 2, 3, 4, 5} para (int i: array) cout << i << endl; }
+
+Salida: 1 2 3 4 5 \`\` \`

guide/spanish/cplusplus/functions/index.md

@@ -0,0 +1,59 @@
+---
+title: Functions in C++
+localeTitle: Funciones en C ++
+---
+## Definición:
+
+Una función es un grupo de sentencias que juntas realizan una tarea. Cada programa C ++ tiene al menos una función, que es main ().
+
+Una declaración de función le dice al compilador sobre el nombre de una función, el tipo de retorno y los parámetros. Una definición de función proporciona el cuerpo real de la función.
+
+## La forma general de una definición de función de C ++:
+
+```cpp
+return_type function_name( parameter list ) 
+ { 
+   body of the function 
+ } 
+```
+
+### Tipo de devolución:
+
+Una función puede devolver un valor. El _tipo de_ retorno _es el tipo de datos del valor que devuelve la función. Algunas funciones realizan las operaciones deseadas sin devolver un valor. En este caso, el_ tipo de _retorno_ es la palabra clave void.
+
+### Nombre de la función:
+
+Este es el nombre real de la función. El nombre de la función y la lista de parámetros constituyen la firma de la función.
+
+### Parámetros:
+
+Un parámetro es como un marcador de posición. Cuando se invoca una función, se pasa un valor al parámetro. Este valor se conoce como parámetro o argumento real. La lista de parámetros se refiere al tipo, orden y número de los parámetros de una función. Los parámetros son opcionales; es decir, una función puede no contener parámetros.
+
+### Cuerpo de la función:
+
+El cuerpo de la función contiene una colección de sentencias que definen lo que hace la función.
+
+## Ejemplo:
+
+```cpp
+int max(int num1, int num2) 
+ { 
+   // local variable declaration 
+   int result; 
+ 
+   if (num1 > num2) 
+      result = num1; 
+   else 
+      result = num2; 
+ 
+   return result; 
+ } 
+```
+
+## ¿Por qué son importantes las funciones?
+
+Las funciones admiten la modularidad (dividir el trabajo en piezas más pequeñas llamadas módulos), que es una característica esencial de la POO que separa principalmente a C ++ de C. Tener funciones específicas para realizar tareas específicas elimina la confusión y acorta la duración de la función principal. La función también realiza reutilización de código. Por lo tanto, la próxima vez que tenga que calcular el máximo de dos números diferentes una y otra vez en el mismo programa, no necesita copiar y pegar su código. Solo tienes que llamar a la función y se hace el resto del trabajo.
+
+## Más información
+
+*   [TutorialsPoint](https://www.tutorialspoint.com/cplusplus/cpp_functions.htm)

guide/spanish/cplusplus/goto/index.md

@@ -0,0 +1,27 @@
+---
+title: goto as a powerful utility
+localeTitle: Goto como una poderosa utilidad
+---
+# Introducción al uso de goto y etiquetas.
+
+goto es una de las piezas de lógica más poderosas pero altamente subestimadas en c ++. Se puede lograr una gran cantidad de optimización utilizando goto, siempre que se use correctamente. Hace lo que se llama como. Va a la aparición mencionada de la siguiente etiqueta, donde sea que esté.
+
+# Terminología
+```
+goto - The keyword used to go to the particular label. 
+ label - this can be named anything. 
+```
+
+# sintaxis
+
+Goto;
+
+(sin el <>);
+
+// Esto lleva el exe a la siguiente aparición de la etiqueta.
+
+goto es algo que trasciende todos los bucles. Para ser más claro en este punto, aquí hay un ejemplo.
+
+https://code.sololearn.com/cI4qqQA8W2q3
+
+Sin embargo, se debe tener cuidado de usar goto con mucho cuidado, especialmente en los primeros días de la codificación, ya que puede conducir a problemas locos, si no se entiende lo suficientemente bien.

guide/spanish/cplusplus/if-else-statement/index.md

@@ -0,0 +1,192 @@
+---
+title: If-Else Statement
+localeTitle: Declaración If-Else
+---
+## ¿Qué hace una declaración If-Else?
+
+*   La instrucción If-Else es una extensión de la instrucción simple If.
+*   En la declaración simple If, ​​si el valor de la expresión de prueba es falso, omitimos el código de bloqueo y continuamos con nuestra siguiente declaración.
+*   Pero muchas veces, queremos ejecutar ciertos pasos si el valor de la expresión de prueba es falso.
+*   En tales casos, usamos la sentencia if-else.
+
+### Forma general de la declaración de If-Else
+
+```cpp
+if (test expression) 
+ { 
+  //statements that run if the test expression is true 
+ } 
+ else 
+ { 
+  //statements that run if the test expression is false 
+ } 
+```
+
+### Ejemplo de declaración If-Else
+
+Si la expresión de prueba es verdadera:
+
+```cpp
+int a=10; 
+ if (a < 20) // This expression is true, so... 
+ { 
+  //...the code in this block gets executed, and... 
+ } 
+ else 
+ { 
+  //...the code in this block gets skipped. 
+ } 
+ //program continues 
+```
+
+Si la expresión de prueba es falsa:
+
+```cpp
+int a=10; 
+ if (a>20) // This expression is false, so this time... 
+ { 
+  //...this code gets skipped... 
+ } 
+ else 
+ { 
+  //...and this code executes instead. 
+ } 
+ //program continues 
+```
+
+### Ejemplo en C ++:
+
+```cpp
+//Program to check whether number entered by user is positive or negative 
+ #include <iostream> 
+ using namespace std; 
+ int main() 
+ { 
+  int no; 
+  cout << "Enter a number: " << endl; 
+ 
+  cin >> no; 
+ 
+  // condition to check if number is positive or negative 
+  if (no >= 0) // positive 
+  { 
+    // block if value is true 
+    cout << "You entered a positive number: " << no << endl; 
+  } 
+  else         // negative 
+  { 
+    // block if value is false 
+    cout << "You entered a negative number: " << no << endl; 
+  } 
+ 
+  // program continues 
+  cout << "This step is always printed" << endl; 
+  return 0; 
+ } 
+```
+
+#### Salida
+
+*   Cuando se ingresa un número positivo:
+```
+Enter a number: 
+ 4 
+ You entered a positive number: 4 
+ This step is always printed 
+```
+
+*   Cuando se ingresa un número negativo:
+```
+Enter a number: 
+ -200 
+ You entered a negative number: -200 
+ This step is always printed 
+```
+
+[Prueba el código tu mismo](https://repl.it/MzBq)
+
+# **No dude en preguntar cualquier duda en la página de GitHub de [FreeCodeCamp](https://forum.freecodecamp.org/) o en [el foro de FreeCodeCamp.](https://forum.freecodecamp.org/)**
+
+[Prueba el código tu mismo](https://repl.it/MzBq)
+
+### Uso de if ... else if ... else ladder
+
+Si tenemos que tomar decisiones basadas en más de una condición utilizando, en caso contrario. Usamos otra cosa si la condición es la siguiente:
+
+```cpp
+#include<iostream> 
+ int main() 
+ { 
+    int score; 
+    std::cout<<"Enter your score: \n"; 
+    std::cin>>score; 
+    if(score>=90) 
+        std::cout<<"Top performance."; 
+    else if(score<90 && score>=70) 
+        std::cout<<"Good performance"; 
+    else if(score<70 && score>=45) 
+        std::cout<<"Average performance"; 
+    else if(score<45 && score>=30) 
+        std::cout<<"You can improve it."; 
+   return 0; 
+ } 
+```
+
+#### Salida
+```
+Enter your score: 
+ 85 
+ Good performance 
+```
+
+### Otro ejemplo de si ... else if ... else ladder
+
+Supongamos que el usuario ingresa dos números y los vamos a mostrar si alguno de los números es mayor que el otro. Y si ninguno es mayor que el otro, imprimimos la declaración "Ambos son iguales".
+
+En este scinerio necesitaremos una sentencia de escalera si ... o si ... y si no. El programa se verá así:
+```
+#include<iostream> 
+ using namespace std; 
+ int main() 
+ { 
+    int number1,number2; 
+    cout << "Enter first number: \n"; 
+    cin >> number1; 
+    cout << "Enter second number: \n"; 
+    cin >> number2; 
+ 
+    if(number1 > number2)     // Checks if the first number is greater than the second number 
+    { 
+        cout << "Number 1 is greater."; 
+    } 
+    else if(number2 > number1)    // Checks if the second number is greater than the first number 
+    { 
+        cout << "Number 2 is greater."; 
+    } 
+    else    // If both of the above cases return false, then both numbers are equal 
+    { 
+        cout << "Both the numbers are equal."; 
+    } 
+ 
+    return 0; 
+ } 
+```
+
+#### Salida
+```
+Enter first number: 
+ 85 
+ Enter second number: 
+ 86 
+ Number 2 is greater. 
+```
+
+*   Tenga en cuenta que el programa solo verificará la condición 'else if' cuando la condición inicial 'if' no se cumpla. Y si no se cumple ninguna de estas condiciones, se ejecuta el último bloque 'else' que imprime la declaración: "Ambos números son iguales".
+    
+*   El tamaño de la escalera if ... else if ... else puede variar según el problema que el programa esté tratando de resolver y la cantidad de condiciones que deben verificarse.
+    
+
+**Buena suerte a todos ustedes**
+
+**¡Feliz codificación! :)**
+

guide/spanish/cplusplus/index.md

@@ -0,0 +1,103 @@
+---
+title: C++
+localeTitle: C ++
+---
+# Hola Mundo! - Tu primer programa de C ++
+
+## ¿Qué es C ++?
+
+*   C ++ es un lenguaje de programación de propósito general que se ha utilizado desde la década de 1990.
+    
+*   Fue diseñado por Bjarne Stroustrup con el nombre "C con clases".
+    
+*   Es una versión de C que incluye elementos orientados a objetos, incluidas clases y funciones.
+    
+*   Es considerado uno de los lenguajes de programación más grandes, como se puede ver en la siguiente imagen: ![Img](http://static1.businessinsider.com/image/59deb30392406c21008b6148-1200/for-bonus-points-heres-the-chart-showing-these-languages-relative-popularity.jpg) _fuente: Github_
+    
+
+### Tu primer programa en C ++
+
+```cpp
+#include <iostream> 
+ using namespace std; 
+ int main() 
+ { 
+    cout << "Hello World" << endl; 
+    return 0; 
+ } 
+```
+
+#### La salida de este programa será simplemente:
+```
+Hello World! 
+```
+
+Ahora, vamos a desglosar el código:
+
+#### Lineas 1 y 2
+
+```cpp
+#include <iostream> 
+ using namespace std; 
+```
+
+*   La primera línea le dice a la computadora que use el archivo de cabecera "iostream" para este programa específico. Un archivo de encabezado es un archivo separado con código C ++ escrito previamente. Hay muchos otros archivos de encabezado que se requieren para que un programa específico se ejecute correctamente. Algunos de ellos son: matemática, vector y cadena. Los archivos de encabezado generalmente están representados por una extensión ".h" (no es necesario agregar .h cuando se incluyen archivos de biblioteca estándar de C ++)
+*   `iostream` significa flujo de entrada-salida. El archivo "iostream" contiene código para permitir que la computadora ingrese datos y genere una salida, utilizando el lenguaje C ++.
+*   La segunda línea le dice a la computadora que use el espacio de nombres estándar que incluye características de C ++ estándar. Podría escribir este programa sin esta línea, pero tendría que usar `std::cout` lugar de `cout` y `std::endl` lugar de `endl` en la línea 4. Hace que el código sea más legible y que nuestras vidas como programadores sean más fáciles.
+
+#### Línea 3 y 4
+
+```cpp
+int main() 
+ { 
+```
+
+*   C ++ inicia la ejecución de un programa desde la función `int main()` . Durante la ejecución, la computadora comienza a ejecutar el código desde cada línea desde `{` (corchete de apertura) hasta `}` (corchete de cierre) **NOTA: Cada función comienza con una llave de apertura "{" y termina con una llave de cierre "}".**
+*   La línea 4 indica el inicio de la función main ().
+
+#### Líneas 5, 6 y 7
+
+```cpp
+    cout << "Hello World" << endl; 
+    return 0; 
+ } 
+```
+
+*   La palabra `cout` en C ++ se usa para dar salida.
+*   Le sigue `<<` , el _operador de inserción_ .
+*   Lo que está en las comillas dobles `""` se imprime. Ciertos caracteres especiales tienen una sintaxis diferente para las declaraciones impresas
+*   Ahora para imprimir cualquier otro tipo de datos, tiene que agregar `<<` .
+
+**_Desafío: intente cambiar Hello World a cualquier otra oración o palabra (s). ¿Cuál será la salida?_**
+
+*   `endl` es una palabra reservada cuando se usa el lenguaje C ++ para **finalizar esta línea y pasar a la siguiente línea durante la salida** . - _cout significa "salida de consola"_
+*   Finalmente, termina el comando con un punto y coma `;` .
+
+**NOTA: Todos los comandos, excepto la definición de la función principal y la directiva #include, deben finalizar con un punto y coma. Sin un ";" , puede encontrar un error.**
+
+*   `return 0;` termina de forma segura la función actual, es decir, 'main ()' en este caso y dado que ninguna función sigue después de que 'main ()' se termina el programa.
+*   No olvide decirle a la computadora que este es el final de la función main (). Para hacer esto, agregue la llave de cierre "}". Encontrará un error antes de la ejecución del programa si no incluye el **}** .
+
+### El código debe verse algo como esto:
+
+![Img](https://i.imgur.com/d1liGwI.png)
+
+Los programadores utilizan un programa Hello World (como este) como un ritual en el uso de un nuevo lenguaje de programación. Es un símbolo de buena suerte.  
+_Ha terminado de codificar su primer programa de C ++ y ha comprendido la mayor parte del código que ha escrito / escrito. ¡FELICIDADES!_
+
+**Buena suerte a todos y feliz codificación! :)**
+
+**¡Feliz codificación! :)**
+
+**No dude en hacer cualquier pregunta en la página de GitHub de [FreeCodeCamp](https://forum.freecodecamp.org/) o en [el Foro de FreeCodeCamp.](https://forum.freecodecamp.org/)**
+
+[Inténtalo tú mismo ! :)](https://repl.it/L4k3)
+
+**Es posible que necesite algún software para escribir y ejecutar código C ++. Recomiendo usar CodeBlocks. Hay un enlace de descarga a continuación:**
+
+Enlace de descarga: [descarga aquí](http://www.codeblocks.org/downloads/26)
+
+*   Haga clic en el enlace con el compilador GNU / GCC para Windows. Esto no requerirá una instalación adicional
+
+Otras alternativas podrían ser visual studio, usando un compilador o un IDE en línea como Cloud9 o repl.it
+

guide/spanish/cplusplus/inline-function/index.md

@@ -0,0 +1,80 @@
+---
+title: Inline Function
+localeTitle: Función en línea
+---
+# Función en línea
+
+## Introducción
+
+La función en línea es una función especial definida en C ++ y se expande en línea cuando se llama.
+
+Ahora, ¿qué significa eso exactamente?
+
+Cada vez que se llama a una función, se necesita mucho tiempo adicional para realizar una serie de actividades, como saltar a la función, guardar registros, empujar los argumentos en la pila y volver a la función de llamada. Así que lleva mucho tiempo. Pero una función en línea es una función en la que se ha solicitado al compilador que realice una expansión en línea. Cuando la función solicita al compilador que inserte el cuerpo completo de la función en cada lugar al que se llama la función, en lugar de generar código para llamar a la función en el lugar en el que se define.
+
+Sin embargo, no podemos garantizar que todas las funciones declaradas en línea estén en línea. Porque cuando declaramos una función como en `inline` , es una solicitud, no un comando. El compilador puede ignorar la solicitud de inscripción en las siguientes situaciones: 1) Si la función contiene bucle por ejemplo `for` bucle, `while` bucle, `do-while` bucle etc. 2) Si la función contiene un `switch` o `goto` . 3) Si la función no devuelve nada, incluso si se menciona el tipo de retorno (que no sea `void` por supuesto). 4) Si la función contiene una variable estática. 5) Si la función contiene una llamada recursiva.
+
+\`\` \`c ++
+
+## sintaxis: -
+
+nombre de _función de tipo de_ retorno en línea (lista de argumentos) {
+
+// cuerpo de la función
+
+}
+```
+## When to use Inline function 
+ 
+ * When the function performs small tasks and is called very often. 
+ * When performance is important. 
+ * Instead of a macro. 
+```
+
+c ++
+
+# incluir
+
+utilizando namespace std;
+
+clase MathOperation {
+
+público:
+```
+inline int add(int x, int y){ 
+ 
+  return(x+y); 
+ } 
+ 
+ inline float div(int n1, float n2){ 
+ 
+  return(n1/n2); 
+ } 
+```
+
+};
+
+int main () {
+
+MathOperation obj;
+
+cout << "La adición es:" << obj.add (34,12) << <"\\ n"; cout << "La división es:" << obj.div (12,3.4) << "\\ n";
+
+devuelve 0;
+
+} \`\` \`
+
+## Ventajas de la función Inline
+
+*   Guarda la sobrecarga de devolución de llamada de una función.
+*   Aumenta la localidad de referencia mediante el uso de la memoria caché de instrucciones.
+*   Acelera tu programa al evitar los gastos generales de llamadas a funciones.
+*   Guarda la sobrecarga de las operaciones de empuje / pop de las variables en la pila, cuando ocurren llamadas a funciones.
+*   Es posible poner una definición de función en un archivo de encabezado, es decir, se puede incluir en varias unidades de compilación, sin que el vinculador se queje.
+
+## Desventajas de la función en línea
+
+*   Cuando se usa en un encabezado, hace que su archivo de encabezado sea más grande con información que a los usuarios no les importa.
+*   Aumenta el tamaño del ejecutable debido a la expansión del código.
+*   El inline de C ++ se resuelve en tiempo de compilación. Lo que significa que si cambia el código de la función en línea, necesitarías recompilar todo el código usándolo para asegurarte de que se actualizará.
+*   Como se mencionó anteriormente, aumenta el tamaño del archivo ejecutable, lo que puede causar problemas en la memoria. Más errores en el número de páginas, lo que reduce el rendimiento del programa.

guide/spanish/cplusplus/inline-functions/index.md

@@ -0,0 +1,119 @@
+---
+title: Inline Functions in C++
+localeTitle: Funciones en línea en C ++
+---
+## Funciones en línea en C ++
+
+Cuando el programa ejecuta la instrucción de llamada de función, la CPU almacena la dirección de memoria de la instrucción que sigue a la llamada de función, copia los argumentos de la función en la pila y finalmente transfiere el control a la función especificada. La CPU luego ejecuta el código de función, almacena el valor de retorno de la función en una ubicación / registro de memoria predefinidos y devuelve el control a la función de llamada. Esto puede convertirse en una sobrecarga si el tiempo de ejecución de la función es menor que el tiempo de conmutación de la función de la persona que llama a la función llamada (persona llamada). Para las funciones que son grandes y / o realizan tareas complejas, la sobrecarga de la llamada a la función suele ser insignificante en comparación con la cantidad de tiempo que la función tarda en ejecutarse. Sin embargo, para funciones pequeñas y de uso común, el tiempo necesario para realizar la llamada a la función es a menudo mucho más que el tiempo necesario para ejecutar realmente el código de la función. Esta sobrecarga se produce para funciones pequeñas porque el tiempo de ejecución de una función pequeña es menor que el tiempo de conmutación.
+
+C ++ proporciona funciones en línea para reducir la sobrecarga de llamadas a funciones. La función en línea es una función que se expande en línea cuando se llama. Cuando la función en línea se llama, el código completo de la función en línea se inserta o se sustituye en el punto de la llamada de la función en línea. Esta sustitución es realizada por el compilador de C ++ en tiempo de compilación. La función en línea puede aumentar la eficiencia si es pequeña. La sintaxis para definir la función en línea es:
+
+```cpp
+inline return-type function-name(parameters) 
+ { 
+    // function code 
+ } 
+```
+
+Recuerde, la inclusión es solo una solicitud al compilador, no un comando. El compilador puede ignorar la solicitud de inscripción. El compilador no puede realizar inlining en tales circunstancias como:
+
+*   Si una función contiene un bucle. (para, mientras, do-while)
+*   Si una función contiene variables estáticas.
+*   Si una función es recursiva.
+*   Si el tipo de retorno de una función es distinto de vacío, la declaración de retorno no existe en el cuerpo de la función.
+*   Si una función contiene switch o goto.
+
+### Las funciones en línea proporcionan las siguientes ventajas:
+
+*   La sobrecarga de llamada de función no se produce.
+*   También ahorra la sobrecarga de las variables push / pop en la pila cuando se llama a la función.
+*   También ahorra gastos generales de una llamada de retorno de una función.
+*   Cuando integra una función, puede habilitar al compilador para que realice una optimización específica del contexto en el cuerpo de la función. Tales optimizaciones no son posibles para llamadas de función normales. Se pueden obtener otras optimizaciones considerando los flujos de contexto de llamada y el contexto de llamada.
+*   La función en línea puede ser útil (si es pequeña) para sistemas integrados porque en línea puede producir menos código que la función de preámbulo de llamada y retorno.
+
+### Desventajas de la función en línea:
+
+*   Las variables agregadas de la función en línea consumen registros adicionales, después de la función de alineación si el número de variables que van a usar el registro aumenta, lo que puede generar una sobrecarga en la utilización de recursos de la variable de registro. Esto significa que cuando el cuerpo de la función en línea se sustituye en el punto de llamada de la función, también se inserta el número total de variables utilizadas por la función. Por lo tanto, el número de registros que se van a utilizar para las variables también aumentará. Por lo tanto, si después de la función los números de variables en línea aumentan drásticamente, entonces seguramente causaría una sobrecarga en la utilización del registro.
+    
+*   Si usa demasiadas funciones en línea, el tamaño del archivo ejecutable binario será grande, debido a la duplicación del mismo código.
+    
+*   Demasiado inline también puede reducir la tasa de aciertos de la memoria caché de instrucciones, lo que reduce la velocidad de búsqueda de la memoria caché a la de la memoria primaria.
+    
+*   La función en línea puede aumentar la sobrecarga del tiempo de compilación si alguien cambia el código dentro de la función en línea, entonces toda la ubicación de la llamada debe volver a compilarse porque el compilador deberá reemplazar todo el código una vez más para reflejar los cambios; de lo contrario, continuará con la funcionalidad anterior.
+    
+*   Las funciones en línea pueden no ser útiles para muchos sistemas integrados. Porque en los sistemas integrados el tamaño del código es más importante que la velocidad.
+    
+*   Las funciones en línea pueden provocar una paliza porque la incorporación puede aumentar el tamaño del archivo ejecutable binario. Golpear en la memoria hace que el rendimiento de la computadora se degrade.
+    
+
+El siguiente programa demuestra este concepto:
+
+```cpp
+#include <iostream> 
+ using namespace std; 
+ class operation 
+ { 
+    int a,b,add,sub,mul; 
+    float div; 
+ public: 
+    void get(); 
+    void sum(); 
+    void difference(); 
+    void product(); 
+    void division(); 
+ }; 
+ inline void operation :: get() 
+ { 
+    cout << "Enter first value:"; 
+    cin >> a; 
+    cout << "Enter second value:"; 
+    cin >> b; 
+ } 
+ 
+ inline void operation :: sum() 
+ { 
+    add = a+b; 
+    cout << "Addition of two numbers: " << a+b << "\n"; 
+ } 
+ 
+ inline void operation :: difference() 
+ { 
+    sub = ab; 
+    cout << "Difference of two numbers: " << ab << "\n"; 
+ } 
+ 
+ inline void operation :: product() 
+ { 
+    mul = a*b; 
+    cout << "Product of two numbers: " << a*b << "\n"; 
+ } 
+ 
+ inline void operation ::division() 
+ { 
+    div=a/b; 
+    cout<<"Division of two numbers: "<<a/b<<"\n" ; 
+ } 
+ 
+ int main() 
+ { 
+    cout << "Program using inline function\n"; 
+    operation s; 
+    s.get(); 
+    s.sum(); 
+    s.difference(); 
+    s.product(); 
+    s.division(); 
+    return 0; 
+ } 
+```
+
+Salida:
+```
+Enter first value: 45 
+ Enter second value: 15 
+ Addition of two numbers: 60 
+ Difference of two numbers: 30 
+ Product of two numbers: 675 
+ Division of two numbers: 3 
+
+```

guide/spanish/cplusplus/input-and-output/index.md

@@ -0,0 +1,136 @@
+---
+title: Input and Output
+localeTitle: Entrada y salida
+---
+## Entrada y salida con flujos
+
+Para imprimir cosas en la consola, o leerlas, utiliza `cout` y `cin` , que se denominan `streams` . Esta metáfora se usa porque usa flujos como si usara un sumidero, o un toque: puede vaciar los datos en un sumidero ( `cout` ), u obtener datos de un toque ( `cin` ).
+
+### Salida con cout
+
+El programa "Hello World" usa `cout` para imprimir "Hello World!" a la consola:
+
+```C++
+#include<iostream> 
+ using namespace std; 
+ 
+ int main() 
+ { 
+  cout << "Hello world!" << endl; 
+ } 
+```
+
+Las primeras dos líneas en la parte superior son necesarias para que uses `cout` y otras transmisiones. `#include<iostream>` hace que los objetos de la corriente sean imposibles de `using namespace std;` , y `using namespace std;` le permite escribir `cout` directamente en lugar de tener que escribir `std::cout` , es decir, tener que especificar que queremos usar `cout` desde el `std` nombres `std` .
+
+`cout` significa "Salida de consola" y es el llamado _flujo de salida_ que representa la consola. Cuando quiera imprimir algo en la consola, puede ponerlo en `cout` ; Imagínalo como un agujero que conduce a la terminal. Para colocar cosas en este orificio, una a la vez, use el operador `<<` , también conocido como el _operador de inserción_ 1 . El operador puede estar encadenado, es decir, puede poner varias cosas una tras otra. Lo siguiente imprimirá "El pastel es una mentira".
+
+`cout << "The cake " << "is " << "a " << "lie." << endl;`
+
+`endl` significa "End Line" y es otro elemento que proviene de `<iostream>` . Cuando coloque `endl` en `cout` , imprimirá un carácter de nueva línea ("\\ n") en la consola, y también _borrará_ `cout` , lo que significa que forzará a `cout` a imprimir todo lo que haya puesto en él _ahora_ . Si no pone `endl` en `cout` , `cout` puede conservar los datos que ha `endl` pero esperar más datos antes de imprimirlos todos. Esto se denomina _almacenamiento en búfer_ y es muy bueno para el rendimiento, pero si ya le ha dado todo lo que se supone que debe imprimir, desea que `cout` imprima de inmediato. Por lo tanto, es una buena práctica terminar con el `endl` en lugares donde tenga sentido.
+
+Casi todo se puede poner en una secuencia: cadenas, números, variables, expresiones, etc. Aquí se muestran algunos ejemplos de inserciones de secuencias válidas:
+
+```C++
+// Notice we can use the number 42 and not the string "42". 
+ cout << "The meaning of life is " << 42 << endl;` // Output: The meaning of life is 42 
+```
+
+```C++
+string name = "Tim"; 
+ cout << "Except for you, " << name << endl;`// Output: Except for you, Tim 
+```
+
+```C++
+string name = "Tim"; 
+ cout << name; 
+ cout << " is a great guy!" << endl;` 
+ // Output: Tim is a great guy! 
+```
+
+```C++
+int a = 3; 
+ cout << a*2 + 18/a << endl;`// Output: 12 
+```
+
+### Una nota sobre los espacios en blanco.
+
+C ++ siempre _te_ pone en control, y solo hace exactamente lo que le dices que haga. Esto a veces puede ser sorprendente, como en el siguiente ejemplo:
+
+```C++
+string name = "Sarah"; 
+ cout << "Good morning" << name << "how are you today? << endl; 
+```
+
+Podría esperar que se imprima "Buenos días, Sarah, ¿cómo estás hoy?", Pero en realidad, la salida sería "Buenos días, Sarah, ¿cómo estás hoy?". El motivo de este error es que no escribió espacios en las cadenas que rodean el `name` , por lo que, como no especificó ningún espacio, `cout` no imprimió ninguno. La versión correcta sería: `cout << "Good morning " << name << " how are you today? << endl;`
+
+Los saltos de línea no ocurren por sí mismos, tampoco. Podría pensar que esto imprimiría una receta en cuatro líneas:
+
+```C++
+cout << "To make bread, you need:"; 
+ cout << "* One egg"; 
+ cout << "* One water"; 
+ cout << "* Two wheat"; 
+```
+
+pero la salida es en realidad todo en una línea: "Para hacer pan, necesitas: \* Un huevo \* Un agua \* Dos trigo". Esto se debe a que no hay caracteres de nueva línea al final de las líneas, por lo que, naturalmente, C ++ asume que no queremos que se impriman caracteres de nueva línea.
+
+Podría arreglar esto agregando `endl` s después de cada línea, porque como se `endl` anteriormente, `endl` inserta un carácter de nueva línea en la secuencia de salida. Sin embargo, también obliga a vaciar el búfer, lo que nos hace perder un poco de rendimiento, ya que podríamos haber impreso todas las líneas de una sola vez. Por lo tanto, lo mejor sería agregar caracteres de nueva línea al final de las líneas, y solo usar `endl` al final:
+
+```C++
+cout << "To make bread, you need:\n"; 
+ cout << "* One egg\n"; 
+ cout << "* One water\n"; 
+ cout << "* Two wheat" << endl; 
+```
+
+Si solo imprime una receta pequeña, el tiempo que guarda es minúsculo y no vale la pena, pero si imprime millones de artículos, la diferencia podría ser muy notable.
+
+### Entrada con cin
+
+Para leer desde la consola, utiliza el _flujo de entrada_ `cin` de la misma manera que lo haría con `cout` , pero en lugar de poner las cosas en `cin` , las "saca". El siguiente programa lee dos números del usuario y los suma:
+
+```C++
+#include<iostream> 
+ using namespace std; 
+ 
+ int main() 
+ { 
+  int a, b; // Variables to hold the two numbers. 
+ 
+  cout << "Please enter the first number:" << endl; 
+  cin >> a; 
+  cout << "Please enter the second number:" << endl; 
+  cin >> b; 
+ 
+  cout << "The sum of your numbers is: " << a + b << endl; 
+ } 
+```
+
+`cin` significa "entrada de consola" y es un _flujo de entrada_ que representa la entrada desde la consola. En la expresión `cin >> a;` , los datos se leen desde `cin` y se guardan en la variable `a` , utilizando el operador `>>` , el _operador de extracción_ 2 . El operador de extracción lee exactamente la cantidad de datos necesarios para escribir en la variable que especificamos y omite los espacios en blanco, por lo que si el usuario escribe "6", se leerá como el valor `6` .
+
+Vale la pena señalar que `cin` detendrá todo el programa para esperar a que el usuario ingrese su valor. El programa no continuará hasta que el usuario haya presionado Intro, y hay algunos datos que se escribirán en la variable. Si el usuario solo presiona Intro sin escribir nada, `cin` seguirá esperando un valor.
+
+El operador de extracción `<<` se puede encadenar. Este es el mismo programa que la última vez, pero escrito de una manera más concisa:
+
+```C++
+#include<iostream> 
+ using namespace std; 
+ 
+ int main() 
+ { 
+  int a, b; // Variables to hold the two numbers. 
+ 
+  cout << "Please enter two numbers:" << endl; 
+  cin >> a >> b; 
+  cout << "The sum of your numbers is: " << a + b << endl; 
+ } 
+```
+
+Cuando está encadenado, el operador de extracción primero leerá los datos de `cin` para rellenar `a` , y luego leerá los datos para rellenar `b` .
+
+Las declaraciones estándar printf y scanf de C también se pueden usar con c ++ importando ' ' archivo de cabecera.
+
+## Fuentes
+
+1.  http://www.cplusplus.com/reference/ostream/ostream/operator%3C%3C/
+2.  http://www.cplusplus.com/reference/istream/istream/operator%3E%3E/

guide/spanish/cplusplus/lists/index.md

@@ -0,0 +1,13 @@
+---
+title: C++ Lists
+localeTitle: Listas de C ++
+---
+# ¿Qué es una lista de STL?
+
+Las listas en C ++ son una herramienta poderosa similar a su primo más conocido, C ++ Vectors. Mientras que los vectores son un contenedor secuencial. donde los elementos se indexan en una cadena continua, las listas también son un contenedor secuencial, pero se organizan de manera diferente. Los elementos de la lista apuntan a su siguiente elemento, por lo que todos los elementos están ordenados en secuencia, pero no utilizan la indexación. ¿Cómo? Tu puedes preguntar. Lo hacen no mediante la indexación sino mediante una herramienta especial llamada iteradores. Los iteradores son como punteros especiales. cuyo trabajo es mantener el orden de los elementos de la lista como el enlace entre dos vagones de tren. Aquí hay una buena visual de cómo se organizan las listas en comparación con los vectores y matrices. ![img](https://imgur.com/SiU8uTe.png)
+
+## Cómo declarar una lista
+
+Si desea declarar una lista de números, escriba:
+
+'' 'std :: list Números;'''

guide/spanish/cplusplus/loops/index.md

@@ -0,0 +1,84 @@
+---
+title: Loops
+localeTitle: Bucles
+---
+# Bucles
+
+## Introducción
+
+Ahora vamos a discutir algo conocido como bucle. Supongamos que desea imprimir los números pares del 1 al 1000 en la pantalla. De una sola mano Hacer esto es escribir las siguientes líneas.
+
+\`\` \`c ++ cout << 0 << endl; cout << 2 << endl; cout << 4 << endl; ... ... ... cout << 1000 << endl;
+```
+But the problem with this approach is that you have to write the same line again and again. And if suppose you have to print 
+ prime numbers from 1 to 1000 then this will be more hectic. 
+ Therefore, in order to solve such problems loops are introduced. 
+ 
+ There are different types of loop functions: 
+ ### While and do while loops 
+ 
+ While and do while loops allow you to make the loop until a condition finishes. 
+ The difference between While and Do while is that Do while always executes once. 
+ Here you can see an example: 
+```
+
+c ++ while (condición) { // Código que se ejecutará mientras la condición sea verdadera. } hacer { // Se ejecutará una vez y hasta que la condición sea falsa. } while (condición);
+```
+### For loops 
+ 
+ For loops are usually used when you know how many times the code will execute. 
+ The flow can be seen in this [graph](https://www.tutorialspoint.com/cplusplus/images/cpp_for_loop.jpg). 
+ 
+ They are declared this way: 
+```
+
+c ++ para (inicializar una variable; verificar una condición; incrementar la variable inicializada) { // Código a ejecutar }
+```
+Lets write a program which will print numbers from 0 to 1000 including 1000 on the screen using a for loop. 
+```
+
+c ++ para (int i = 0; i <= 1000; i ++) { cout << i << endl; }
+```
+When you execute this code in a c++ program numbers from 1 to 1000 will be printed. 
+ Now lets discuss how the for loop works. 
+ 
+ * You start a for loop by typing the keyword 'for'. It means you are starting a for loop 
+ ` for ` 
+ * Next you open and close a round bracket. In this brackets you write some conditions which will be discussed later 
+ ` for()` 
+ * Inside the brackets first you write the initial condition ie the value from where the loop will start. Like in the 
+  above program we write int i = 0 
+ ` for(int i = 0)` 
+ * Then you write the semicolon and then condition until when the loop will be executed. In the above code you define 
+   i < 1000. It means until value of i is less then 1000 execuete the loop. 
+   ` for(int i=0;i<=1000) ` 
+ * Then you define the incremented value that is how much i has to be incremented in each iteration. In the above code 
+   we write i++. It means value of i will be incremented by 1 every time. 
+    ` for(int i=0;i<=1000;i++) ` 
+ * If there is only one statement inside the loop then the curly bracket is optional but its better to write loop code 
+   within brackets so that you don't get confused. 
+    ``` c++ 
+    for(int i=0;i<=1000;i++) 
+        { 
+        } 
+     ``` 
+ * Then inside the loop you write what do you want to do. In the above program we output the value of i. 
+ 
+ So, in this way the for loop works 
+ 
+ If you want to print even numbers from 1 to 1000 then your program will look like this 
+```
+
+c ++ para (int i = 0; i <= 1000; i = i + 2) { cout << i << endl; }
+
+\`\` \`
+
+*   La diferencia entre el primer programa y el segundo es la parte de incremento. El resto del código es el mismo. Este programa imprimirá 0 y luego agregue 2 e imprima 2 en la consola y así sucesivamente hasta que el valor de i sea igual a 1000.
+    
+    Nuestro programa final para imprimir números pares de 0 a 1000 se verá así.
+    
+    \`\` \`c ++
+    
+    # incluir
+    
+    utilizando namespace std; int main () { para (int i = 0; i <= 1000; i = i + 2) { cout << i << endl; } devuelve 0; } \`\` \`

guide/spanish/cplusplus/map/index.md

@@ -0,0 +1,81 @@
+---
+title: Map
+localeTitle: Mapa
+---
+## Introducción del mapa
+
+`map` es un contenedor asociativo que almacena elementos en un par clave-valor. Al igual que en `Java` tenemos colección, array asociativo en PHP y así sucesivamente.
+
+## Beneficios de usar el mapa
+
+*   Almacena solo claves únicas y eso también en orden clasificado basado en sus criterios de clasificación asignados.
+*   Como las claves están ordenadas, la búsqueda de elementos en el mapa a través de la clave es muy rápida, es decir, toma tiempo logarítmico.
+*   En el `map` solo habrá un valor adjunto con cada tecla.
+*   `map` puede ser utilizado como matrices asociativas.
+*   Podría implementarse utilizando árboles binarios equilibrados.
+
+Aquí hay un ejemplo:
+
+```c++
+#include <iostream> 
+ #include <map> 
+ 
+ using namespace std; 
+ 
+ int main (){ 
+  map<char,int> first; 
+ 
+  //initializing 
+  first['a']=10; 
+  first['b']=20; 
+  first['c']=30; 
+  first['d']=40; 
+ 
+   map<char, int>::iterator it; 
+   for(it=first.begin(); it!=first.end(); ++it){ 
+      cout << it->first << " => " << it->second << '\n'; 
+   } 
+ 
+  return 0; 
+ } 
+```
+
+Salida:
+```
+a => 10 
+ b => 20 
+ c => 30 
+ d => 40 
+```
+
+## Creando objeto de mapa
+
+`map<string, int> myMap;`
+
+## Inserción
+
+Insertando datos con la función miembro insertada.
+
+```c++
+myMap.insert(make_pair("earth", 1)); 
+ myMap.insert(make_pair("moon", 2)); 
+```
+
+También podemos insertar datos en std :: map utilizando el operador \[\], es decir
+
+`myMap["sun"] = 3;`
+
+## Accediendo a los elementos del mapa.
+
+Para acceder a los elementos del mapa, debe crear un iterador para él. Aquí hay un ejemplo como se dijo antes.
+
+```c++
+map<char, int>::iterator it; 
+ for(it=first.begin(); it!=first.end(); ++it){ 
+  cout << it->first << " => " << it->second << '\n'; 
+ } 
+```
+
+Aquí puedes aprender más sobre el mapa: [cpluspluc\_map](http://www.cplusplus.com/reference/map/map/map/)
+
+NB: Todos los códigos en el ejemplo están en versión C ++ 11. Puedes aprender más sobre la versión de C ++ [aquí](http://en.cppreference.com/w/cpp/compiler_support)

guide/spanish/cplusplus/object-oriented-programming/index.md

@@ -0,0 +1,78 @@
+---
+title: Object Oriented Programming using C++
+localeTitle: Programación orientada a objetos utilizando C ++
+---
+## Programación orientada a objetos utilizando C ++
+
+La programación orientada a objetos, POO para abreviar, tiene como objetivo implementar entidades del mundo real como herencia, ocultamiento y polimorfismo en la programación. El objetivo principal de OOP es unir los datos y las funciones que operan en ellos para que ninguna otra parte del código pueda acceder a estos datos, excepto esa función.
+
+Aprendamos sobre las diferentes características de un lenguaje de programación orientado a objetos:
+
+### Objeto:
+
+Los objetos son entidades de tiempo de ejecución básicas en un sistema orientado a objetos, los objetos son instancias de una clase, son tipos de datos definidos por el usuario definidos.
+
+```cpp
+class person 
+ { 
+    char name[20]; 
+    int id; 
+ public: 
+    void getdetails(){} 
+ }; 
+ 
+ int main() 
+ { 
+   person p1; //p1 is an object 
+ } 
+```
+
+Los objetos ocupan espacio en la memoria y tienen una dirección asociada como un registro en pascal o estructura o unión en C.
+
+Cuando se ejecuta un programa, los objetos interactúan enviándose mensajes entre sí.
+
+Cada objeto contiene datos y código para manipular los datos. Los objetos pueden interactuar sin tener que conocer detalles de los demás datos o códigos. Es suficiente conocer el tipo de mensaje aceptado y el tipo de respuesta devuelta por los objetos.
+
+### Clase:
+
+La clase es un plano de datos y funciones o métodos. La clase no ocupa ningún espacio.
+
+```cpp
+class class_name 
+ { 
+  private: 
+     //data members and member functions declarations 
+  public: 
+     //data members and member functions declarations 
+  protected: 
+     //data members and member functions declarations 
+ }; 
+```
+
+La clase es un tipo de datos definido por el usuario como estructuras y uniones en C.
+
+Por defecto, las variables de clase son privadas pero en el caso de la estructura es pública. en el ejemplo anterior la persona es una clase.
+
+### Encapsulación y abstracción de datos:
+
+La finalización (combinación) de datos y funciones en una sola unidad se conoce como encapsulación. Los datos no son accesibles al mundo exterior y solo las funciones que están envolviendo en la clase pueden acceder a ellos. Este aislamiento de los datos del acceso directo por parte del programa se denomina ocultación de datos o ocultación de información.
+
+La abstracción de datos se refiere a proporcionar solo la información necesaria al mundo exterior y ocultar los detalles de la implementación. Por ejemplo, considere un complejo de clase con funciones públicas como getReal () y getImag (). Podemos implementar la clase como una matriz de tamaño 2 o como dos variables. La ventaja de las abstracciones es que podemos cambiar la implementación en cualquier momento, los usuarios de la clase Complex no se verán afectados ya que nuestra interfaz de método sigue siendo la misma. Si nuestra implementación fuera pública, no hubiéramos podido cambiarla.
+
+### Herencia:
+
+Herencia es el proceso por el cual los objetos de una clase adquieren las propiedades de los objetos de otra clase. Apoya el concepto de clasificación jerárquica. La herencia proporciona reutilización. Esto significa que podemos agregar características adicionales a una clase existente sin modificarla.
+
+### Polimorfismo:
+
+Polimorfismo significa capacidad para tomar más de una forma. Una operación puede exhibir diferentes comportamientos en diferentes instancias. El comportamiento depende de los tipos de datos utilizados en la operación.
+
+C ++ admite la sobrecarga de operadores y la sobrecarga de funciones. La sobrecarga del operador es el proceso de hacer que un operador exhiba diferentes comportamientos en diferentes instancias. La sobrecarga de funciones está utilizando un solo nombre de función para realizar diferentes tipos de tareas. El polimorfismo se usa ampliamente en la implementación de la herencia.
+
+### Encuadernación dinámica:
+
+En el enlace dinámico, el código que se ejecutará en respuesta a la llamada de función se decide en tiempo de ejecución. C ++ tiene funciones virtuales para soportar esto.
+
+### Paso de mensajes:
+
+Los objetos se comunican entre sí enviando y recibiendo información entre sí. Un mensaje para un objeto es una solicitud para la ejecución de un procedimiento y, por lo tanto, invocará una función en el objeto receptor que genera los resultados deseados. El paso de mensajes implica especificar el nombre del objeto, el nombre de la función y la información que se enviará.

guide/spanish/cplusplus/overloading/index.md

@@ -0,0 +1,102 @@
+---
+title: C++ Overloading
+localeTitle: Sobrecarga de C ++
+---
+C ++ le permite especificar más de una definición para un nombre de función o un operador en el mismo ámbito, lo que se denomina sobrecarga de funciones y sobrecarga de operadores respectivamente.
+
+Una declaración sobrecargada es una declaración que se declara con el mismo nombre que una declaración previamente declarada en el mismo ámbito, excepto que ambas declaraciones tienen argumentos diferentes y, obviamente, una definición (implementación) diferente.
+
+Cuando llama a una función u operador sobrecargado, el compilador determina la definición más apropiada para usar, comparando los tipos de argumentos que ha usado para llamar a la función u operador con los tipos de parámetros especificados en las definiciones. El proceso de selección de la función u operador sobrecargado más apropiado se denomina resolución de sobrecarga.
+
+### Sobrecarga de funciones en C ++
+
+Puede tener varias definiciones para el mismo nombre de función en el mismo ámbito. La definición de la función debe diferir entre sí por los tipos y / o el número de argumentos en la lista de argumentos. No puede sobrecargar las declaraciones de funciones que difieren solo por el tipo de retorno.
+
+A continuación se muestra un ejemplo en el que se utiliza la misma función print () para imprimir diferentes tipos de datos:
+
+```cpp
+#include <iostream> 
+ #include <string> 
+ using namespace std; 
+ 
+ class printData { 
+   public: 
+      void print(int i) { 
+        cout << "Printing int: " << i << endl; 
+      } 
+      void print(double  f) { 
+        cout << "Printing float: " << f << endl; 
+      } 
+      void print(const string& s) { 
+        cout << "Printing string: " << s << endl; 
+      } 
+ }; 
+ 
+ int main() { 
+   printData pd; 
+ 
+   // Call print to print integer 
+   pd.print(5); 
+ 
+   // Call print to print float 
+   pd.print(500.263); 
+ 
+   // Call print to print string 
+   pd.print("Hello C++"); 
+ 
+   return 0; 
+ } 
+```
+
+Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:
+```
+Printing int: 5 
+ Printing float: 500.263 
+ Printing string: Hello C++ 
+```
+
+### Sobrecarga del operador en C ++
+
+La mayoría de los operadores integrados también pueden sobrecargarse en C ++. Esto permite a los programadores asignar diferentes implementaciones a los operadores dependiendo de los argumentos. Estos operadores sobrecargados pueden trabajar para la clase definida por el usuario.
+```
+#include<iostream> 
+ using namespace std; 
+ 
+ class Complex_Number{ 
+ private: 
+    int real; 
+    int imag; 
+ public: 
+    Complex_Number(int i = 0, int j =0) 
+    { 
+        real = i; 
+        imag = j; 
+    } 
+    //Here the operator '+' is being overloaded 
+    Complex_Number operator + (Complex_Number const &a) 
+    { 
+         Complex_Number x; 
+         x.real = real + a.real; 
+         x.imag = imag + a.imag; 
+         return x; 
+    } 
+    void print() 
+    { 
+         cout<<real<<" + i"<<imag<<endl; 
+    } 
+ }; 
+ 
+ int main() 
+ { 
+    Complex_Number c1(3, 2), c2(1, 1); 
+    //Here, the overloaded operator is called. The numbers get added according to the function defined 
+    Complex_Number c3 = c1 + c2; 
+    c3.print(); 
+ } 
+```
+
+Salida para el programa anterior.
+```
+4 + i3 
+
+```

guide/spanish/cplusplus/preprocessors/index.md

@@ -0,0 +1,160 @@
+---
+title: Preprocessors
+localeTitle: Preprocesadores
+---
+## Preprocesadores en C / CPP
+
+Como su nombre lo indica, los preprocesadores son programas que procesan nuestro código fuente antes de compilar. Hay una serie de pasos involucrados entre escribir un programa y ejecutar un programa en C / C ++. Echemos un vistazo a estos pasos antes de que realmente comencemos a aprender acerca de los preprocesadores.
+
+![Img](https://i.imgur.com/Pb0aTkV.png)
+
+Puedes ver los pasos intermedios en el diagrama de arriba. El código fuente escrito por los programadores se almacena en el archivo program.c. Este archivo luego es procesado por preprocesadores y se genera un archivo de código fuente expandido denominado programa. El compilador compila este archivo expandido y se genera un archivo de código de objeto denominado program.obj. Finalmente, el enlazador vincula este archivo de código de objeto con el código de objeto de las funciones de la biblioteca para generar el archivo ejecutable program.exe.
+
+Los programas de preprocesador proporcionan directivas de preprocesadores que le indican al compilador que preprocese el código fuente antes de compilar. Todas estas directivas de preprocesador comienzan con un símbolo `#` (hash). Este símbolo ('#') al comienzo de una declaración en un programa C / C ++ indica que es una directiva de preprocesador. Podemos colocar estas directivas de preprocesador en cualquier lugar de nuestro programa. Algunos ejemplos de directivas de preprocesador son: `#include` , `#define` , `#ifndef` etc.
+
+### Tipos de directivas de preprocesador:
+
+1.  Macros
+2.  Inclusión de archivos
+3.  Compilación condicional
+4.  Otras directivas
+
+### Macros
+
+Las macros son parte de código en un programa que recibe un nombre. Cuando el compilador encuentra este nombre, el compilador reemplaza el nombre con el fragmento de código real. La directiva `#define` se usa para definir una macro.
+
+```cpp
+  #include<iostream> 
+  #define LIMIT 3 
+  int main() 
+  { 
+    for(int i=0; i < LIMIT; i++) 
+    { 
+      std::cout<<i<<" " ; 
+    } 
+      return 0; 
+  } 
+```
+
+Salida:
+
+`0 1 2`
+
+En el programa anterior, cuando el compilador ejecuta la palabra `LIMIT` , la reemplaza por 3. La palabra `LIMIT` en definición de macro se llama plantilla de macro y '3' es expansión de macro.
+
+No debe haber un punto y coma (';') al final de la definición de la macro. Las definiciones de macros no necesitan un punto y coma para terminar.
+
+### Inclusión de archivos:
+
+Este tipo de directiva de preprocesador le dice al compilador que incluya un archivo en el programa de código fuente. Hay dos tipos de archivos que pueden ser incluidos por el usuario en el programa:
+
+*   \#### Archivos de encabezado o archivos estándar: Estos archivos contienen una definición de funciones predefinidas como printf (), ... scanf (), etc. Estos archivos deben incluirse para trabajar con estas funciones. ... Diferentes funciones se declaran en diferentes archivos de cabecera. Por ejemplo ... las funciones de E / S estándar están en el archivo 'iostream', mientras que las funciones que ... realizan operaciones de cadena están en el archivo 'cadena'.
+
+#### Sintaxis:
+
+`#include< file_name >` donde nombre\_archivo es el nombre del archivo que se incluirá. Los corchetes `<` y `>` le indican al compilador que busque el archivo en el directorio estándar.
+
+*   \#### Archivos definidos por el usuario: Cuando un programa se vuelve muy grande, es una buena práctica dividirlo en archivos más pequeños e incluirlos cuando sea necesario. Estos tipos de archivos son archivos definidos por el usuario. Estos archivos pueden ser incluidos como: ... `#include"filename"`
+
+### Compilación condicional:
+
+Las directivas de compilación condicional son tipos de directivas que ayudan a compilar una parte específica del programa o a saltarse la compilación de una parte específica del programa en función de algunas condiciones. Esto se puede hacer con la ayuda de dos comandos de preprocesamiento `ifdef` y `endif` .
+
+#### Sintaxis:
+
+```cpp
+  ifdef macro_name 
+    statement1; 
+    statement2; 
+    statement3; 
+    . 
+    . 
+    . 
+    statementN; 
+  endif 
+```
+
+Si se define la macro con el nombre como 'macroname', entonces el bloque de instrucciones se ejecutará normalmente, pero si no está definido, el compilador simplemente saltará este bloque de instrucciones.
+
+### Otras directivas:
+
+Aparte de las directivas anteriores, hay dos directivas más que no se utilizan comúnmente. Estos son:
+
+1.  \##### `#undef` Directiva: La directiva `#undef` se usa para no definir una macro existente. Esta directiva funciona como:
+
+##### Sintaxis:
+
+`#undef LIMIT` El uso de esta declaración anulará la definición de la macro existente. Después de esta declaración, cada declaración `#ifdef LIMIT` se evaluará como falsa.
+
+2.  \##### `#pragma` Directiva: Esta directiva es una directiva de propósito especial y se usa para activar o desactivar algunas funciones. Este tipo de directivas son específicas del compilador, es decir, varían de compilador a compilador. Algunas de las directivas `#pragma` se discuten a continuación:
+
+##### `#pragma startup` y `#pragma exit` :
+
+Estas directivas nos ayudan a especificar las funciones que se necesitan para ejecutar antes del inicio del programa (antes de que el control pase a main ()) y justo antes de la salida del programa (justo antes de que el control regrese de main ()).
+
+```cpp
+#include<stdio.h> 
+ void func1(); 
+ void func2(); 
+ #pragma startup func1 
+ #pragma exit func2 
+ void func1() 
+ { 
+    printf("Inside func1() "); 
+ } 
+ void func2() 
+ { 
+    printf("Inside func2() "); 
+ } 
+ int main() 
+ { 
+    printf("Inside main() "); 
+ 
+    return 0; 
+ } 
+```
+
+Salida:  
+`Inside func1() Inside main() Inside func2()`  
+El código anterior producirá la salida como se indica a continuación cuando se ejecute en compiladores GCC:  
+Salida:  
+`Inside main()`  
+Esto sucede porque GCC no admite #pragma startup o exit. Sin embargo, puede utilizar el siguiente código para obtener un resultado similar en los compiladores GCC.
+
+```cpp
+#include<stdio.h> 
+ void func1(); 
+ void func2(); 
+ void __attribute__((constructor)) func1(); 
+ void __attribute__((destructor)) func2(); 
+ void func1() 
+ { 
+    printf("Inside func1()\n"); 
+ } 
+ void func2() 
+ { 
+    printf("Inside func2()\n"); 
+ } 
+ int main() 
+ { 
+    printf("Inside main()\n"); 
+ 
+    return 0; 
+ } 
+```
+
+##### `#pragma warn` directiva:
+
+Esta directiva se utiliza para ocultar el mensaje de advertencia que se muestra durante la compilación. Podemos ocultar las advertencias como se muestra a continuación:
+
+##### `#pragma warn -rvl` :
+
+Esta directiva oculta las advertencias que aparecen cuando una función que se supone que devuelve un valor no devuelve un valor.
+
+##### `#pragma warn -par` :
+
+Esta directiva oculta las advertencias que aparecen cuando una función no utiliza los parámetros que se le pasan.
+
+##### `#pragma warn -rch`
+
+Esta directiva oculta las advertencias que se generan cuando no se puede acceder a un código. Por ejemplo: cualquier código escrito después de la declaración de retorno en una función es inalcanzable.

guide/spanish/cplusplus/queue/index.md

@@ -0,0 +1,197 @@
+---
+title: queue
+localeTitle: cola
+---
+## Colas
+
+`queue` es uno de los contenedores más utilizados en C ++. Un contenedor es una estructura de datos que almacena una colección de objetos, algunos en orden, otros no. Todos los contenedores tienen un conjunto diferente de funciones que le permiten acceder a un objeto (s) en esa colección.
+
+`std::queue` es parte de la biblioteca estándar de C ++ (de ahí el prefijo `std::` y le permite almacenar datos en el orden First In First Out (FIFO). NOTA: **Todos los objetos dentro de una cola deben ser del mismo tipo de datos**
+
+El tipo de datos que almacena dentro de una cola va entre paréntesis angulares junto a la palabra clave de la cola. Por ejemplo, si desea almacenar una colección de enteros, la cola sería `std::queue<int> queue_name`
+
+### Explicación de cola LIFO
+
+`queue` nos permite empujar / poner en cola y hacer pop / sacar de la cola en un orden específico. **Empujar** significa insertar un objeto en la parte delantera de la cola. **Pop** significa sacar el objeto "más antiguo" del final de la cola. Así que cuando lo presionas está en la parte delantera y cuando haces pop extraes el elemento más antiguo.
+
+![alt text](https://github.com/mohammadaziz313/helloworld/blob/master/Fifo_queue.png "Ejemplo de cola y salida de cola FIFO")
+
+### Operaciones de cola
+
+El contenedor de cola soporta las siguientes operaciones:
+
+*   empujar (poner en cola)
+*   pop (dequeue)
+*   vacío
+*   tamaño
+*   frente
+*   espalda
+
+#### empujar
+
+Le permite insertar un nuevo elemento al final de la cola, después de su último elemento actual.
+
+```cpp
+//Push operation in Queue 
+ #include <iostream>       // std::cout 
+ #include <queue>          // std::queue 
+ 
+ int main () 
+ { 
+  std::queue<int> q; 
+ 
+  q.push(1);    //Pushing 1 at front of the queue 
+  q.push(2);    //Pushing 2 at front of the queue 
+ 
+  return 0; 
+ } 
+```
+
+#### Frente
+
+Le permite acceder al siguiente elemento en la cola sin eliminarlo. El siguiente elemento es el elemento "más antiguo" en la cola.
+
+```cpp
+//Front operation in Queue 
+ #include <iostream>       // std::cout 
+ #include <queue>          // std::queue 
+ 
+ int main () 
+ { 
+  std::queue<int> q; 
+ 
+  q.push(1);    //Pushing 1 at front of the queue 
+  q.push(2);    //Pushing 2 at front of the queue 
+ 
+  std::cout<<q.front()<<'\n';     //Accessing the front of the queue 
+  std::cout<<q.front()<<'\n';     //Accessing the front of the queue 
+ 
+  return 0; 
+ } 
+```
+
+```
+Output: 
+ 1 
+ 1 
+```
+
+#### Popular
+
+Le permite eliminar el siguiente elemento en la cola, reduciendo efectivamente su tamaño en uno. El elemento eliminado es el elemento "más antiguo".
+
+```cpp
+//Pop operation in Queue 
+ #include <iostream>       // std::cout 
+ #include <queue>          // std::queue 
+ 
+ int main () 
+ { 
+  std::queue<int> q; 
+ 
+  q.push(1);    //Pushing 1 at front of the queue 
+  q.push(2);    //Pushing 2 at front of the queue 
+ 
+  std::cout<<q.front()<<'\n';     //Accessing the front of the queue 
+  q.pop();                        //Removing the oldest element 
+  std::cout<<q.front()<<'\n';     //Accessing the front of the queue 
+  q.pop();                        //Removing the oldest element 
+ 
+  return 0; 
+ } 
+```
+
+```
+Output: 
+ 1 
+ 2 
+```
+
+#### tamaño
+
+Devuelve el número de elementos en la `queue` .
+
+```cpp
+//Size operation in Queue 
+ #include <iostream>       // std::cout 
+ #include <queue>          // std::queue 
+ 
+ int main () 
+ { 
+  std::queue<int> q; 
+ 
+  q.push(1);    //Pushing 1 at front of the queue 
+  q.push(2);    //Pushing 2 at front of the queue 
+ 
+  std::cout<<q.size()<<'\n';     //Accessing the front of the queue 
+  q.pop();                        //Removing the oldest element 
+  std::cout<<q.size()<<'\n';     //Accessing the front of the queue 
+  q.pop();                        //Removing the oldest element 
+  std::cout<<q.size()<<'\n';     //Accessing the front of the queue 
+ 
+  return 0; 
+ } 
+```
+
+```
+Output: 
+ 2 
+ 1 
+ 0 
+```
+
+#### Vacío
+
+Devuelve si la `queue` está vacía, es decir, si el tamaño de la cola es cero. Devuelve `true` si el tamaño de la cola 0, si no, devuelve `false`
+
+\`\` \`cpp // operación vacía en la cola
+
+# incluir // std :: cout
+
+# incluir // std :: stack
+
+int main () { std :: queue q;
+
+q.push (1); q.push (2);
+
+while (q.empty ()! = true) { std :: cout << q.front () << '\\ n'; q.pop (); }
+
+std :: cout << "Out of loop" << '\\ n'; devuelve 0; }
+```
+    Output: 
+    1 
+    2 
+    Out of loop 
+ 
+ #### Back 
+ 
+ Allows you to access the last element in the queue without removing it. 
+ The next element is the "newest" element in the queue. 
+```
+
+cpp // Operación trasera en cola
+
+# incluir // std :: cout
+
+# incluir // std :: queue
+
+int main () { std :: queue q;
+
+q.push (1); // Empujando 1 al frente de la cola q.push (2); // Empujando 2 al frente de la cola
+
+std :: cout << q.back () << '\\ n'; // Accediendo al dorso de la cola std :: cout << q.back () << '\\ n'; // Accediendo al dorso de la cola
+
+devuelve 0; } \`\` \`
+```
+Output: 
+ 2 
+ 2 
+```
+
+### Para más recursos:
+
+http://www.cplusplus.com/reference/queue/queue/
+
+### Citaciones:
+
+Cortesía de imagen: https://en.wikipedia.org/wiki/FIFO _(computación y_ electrónica)

guide/spanish/cplusplus/random-functions/index.md

@@ -0,0 +1,88 @@
+---
+title: Random Functions
+localeTitle: Funciones aleatorias
+---
+*   Los números aleatorios son una forma conveniente de introducir la asignación al azar en su programa. Por ejemplo, si desea ejecutar cualquier simulación, o jugar juegos, eliminar índices aleatorios de una matriz, etc., entonces los números aleatorios son el camino a seguir.
+*   El archivo de encabezado que se debe incluir para usar números aleatorios en c ++ es `cstdlib` .
+*   `cpp #include<bits/stdc++.h>` _profesional:_ puede usar `cpp #include<bits/stdc++.h>` para incluir todas las funciones de todos los archivos de encabezado.
+
+Función: - rand ()  
+\- Devuelve un número pseudoaleatorio (entero) de 0 a RAND _MAX. No toma ningún argumento. - RAND_ MAX es el número entero máximo permitido. Es un compilador dependiente y generalmente es 2147483647.
+
+A continuación se muestra un ejemplo:
+
+```cpp
+#include <cstdlib> 
+ #include <iostream> 
+ using namespace std; 
+ 
+ int main() { 
+  cout << rand() << endl; 
+  cout << rand() << endl; 
+  cout << rand() << endl; 
+  return 0; 
+ } 
+ 
+ /* 
+ Output:- (Note that the output is random and will differ from what is mentioned here) 
+ 1804289383 
+ 846930886 
+ 1681692777 
+ */ 
+```
+
+Ahora, ejecute el programa una vez más. Y otra vez. Y otra vez. ¿Que ves? La misma salida se imprime una y otra vez.
+
+Regresemos a la definición de la función rand ():
+
+rand (): _devuelve un número **pseudoaleatorio** (entero) de 0 a RAND\_MAX. No toma ningún argumento._
+
+Entonces, ¿qué es un número pseudoaleatorio?
+
+*   Como su nombre indica, un número que no es verdaderamente aleatorio es pseudoaleatorio.
+*   Los números psicoaleatorios no están criptográficamente seguros y son vulnerables a los ataques.
+*   En el contexto de C ++, el número aparece aleatorio, pero no verdaderamente aleatorio. La función asume que cada número de 0 a RAND\_MAX es igualmente probable y escupe un número. (En realidad, Este no es el caso, pero está cerca). Por ejemplo, el número 5 se utiliza en casi todas partes. Si un número aleatorio escupe 5, podría no pensar que el número es de hecho, aleatorio.
+*   La función aleatoria rand () toma un número muy grande, aplica módulo por un número primo grande y realiza todo tipo de operaciones en un número y devuelve un valor. Por muy complicado que sea, todavía es posible romperlo.
+
+¿Cómo obtenemos un conjunto único de números aleatorios durante la ejecución de cada programa?
+
+Utilizamos `void srand(int seed)` ;
+
+*   "Semilla" es el nombre dado a un número que hace que el generador de secuencia aleatoria comience en un punto de partida diferente cada vez. Esto asegura que la función aleatoria no arroje los mismos valores durante la ejecución del programa.
+*   **Es importante invocar solo la llamada srand ONCE al comienzo del programa.**
+*   No es necesario repetir las llamadas para generar el generador de números aleatorios (de hecho, hará que su número sea menos equitativo). repartido).
+*   Una técnica comúnmente utilizada es colocar el generador de números aleatorios usando el reloj, ya que el reloj te da una salida diferente cada vez que lo miras. Entonces, para la semilla, puedes tomar la salida del tiempo y conectarlo al generador de números aleatorios.
+*   La función time () devolverá el tiempo de la computadora. Esto se expresa en términos del número de segundos que han transcurrido desde el 1 de enero de 1970 (la época).
+*   El tiempo de la función (NULL) devolverá el número de segundos transcurridos en el tiempo de la computadora.
+*   El archivo de encabezado que debe incluirse para las funciones de tiempo: \`ctime '.
+
+Fragmento de código:
+
+```cpp
+#include <ctime> 
+ 
+ srand(time(NULL)); 
+ cout << rand(); 
+ 
+ /* 
+ Output: (Will differ from computer to computer, and because of the seed, will also differ from time to time, literally. :D) 
+ 1696269016 
+ */ 
+```
+
+Esto produce valores diferentes cada vez que se ejecuta el programa.
+
+Bono: Ajustar el rand () para su conveniencia.
+
+*   Dado que rand () devuelve un número aleatorio de 0 a RAND\_MAX, si quieres un número entre 0 y 8 por ejemplo, entonces haz -rand ()% 9. Cualquier número módulo 9 devolverá un valor de 0 a 8.
+    
+*   Más formalmente, si desea un número entre L (incluido) y U (incluido), debe hacer `int num = L + rand()%(U-L+1).` Explicación: - rand ()% (UL + 1) devuelve un número aleatorio (pseudoaleatorio, no olvide) entre 0 y (UL). Por lo tanto, agregar L asegura que obtengamos un valor entre L y U.
+    
+    Resumen:-
+    
+
+1.  int rand (): devuelve un número aleatorio entre 0 y RAND\_MAX.
+    
+2.  void srand (int seed): se utiliza para inicializar el generador de números aleatorios. Basta con llamar a esta función _una_ sola _vez_ .
+    
+    ### Fuentes: - [Generación de números aleatorios](http://www.math.uaa.alaska.edu/~afkjm/csce211/handouts/RandomFunctions)

guide/spanish/cplusplus/range-for-loop/index.md

@@ -0,0 +1,30 @@
+---
+title: Range For Loop
+localeTitle: Rango de bucle
+---
+## Rango basado en bucle
+
+El bucle `for` basado en rangos permite un bucle fácil en una gama de elementos (elementos similares en un contenedor).
+
+Con tradicional `for` bucle:
+
+```cpp
+std::vector<std::string> stringList {"one", "two", "three"}; 
+ 
+ for (size_t il; il < stringList.size(); il++ 
+ { 
+  std::cout << stringList.at(il) << std::endl; 
+ } 
+```
+
+Con rango basado `for` bucle:
+
+```cpp
+std::vector<std::string> stringList {"one", "two", "three"}; 
+ 
+ for (auto& singleString : stringList) 
+ { 
+  std:cout << singleString << std::endl; 
+ } 
+
+```

guide/spanish/cplusplus/set/index.md

@@ -0,0 +1,94 @@
+---
+title: Set
+localeTitle: Conjunto
+---
+Una estructura de datos de conjunto en c ++ se define de la misma manera que un conjunto se define en el contexto de las matemáticas.
+
+Más formalmente hablando, los Conjuntos son un tipo de contenedores asociativos en los que cada elemento tiene que ser único.
+
+*   El valor del elemento no se puede modificar una vez que se ingresa, aunque se permite eliminar un elemento e insertar un nuevo elemento, de la misma manera que lo hacemos en matemáticas.
+*   Establecer la estructura de datos se puede utilizar para modelar, bueno, se configura a sí mismo. Se hace fácil encontrar intersecciones, uniones etc.
+*   Similar al vector, pero solo se permiten valores únicos.
+*   El conjunto organiza los elementos en orden creciente a medida que se insertan elementos en el conjunto.
+
+El archivo de encabezado requerido para usar la estructura de datos establecida es 'conjunto'. es decir, `#include<set>` debe estar allí en su código para que pueda utilizar la estructura de datos establecida.
+
+`#include<bits/stdc++.h>` **profesional** : use `#include<bits/stdc++.h>` para incluir todas las funciones y estructuras de datos de C ++, en lugar de agregarlas una por una.  
+Algunas de las funciones que se pueden realizar con un conjunto:
+
+1.  begin (): devuelve un iterador al primer elemento del conjunto
+2.  end (): devuelve un iterador al elemento teórico que sigue al último elemento del conjunto
+3.  size () - Devuelve el número de elementos en el conjunto
+4.  max\_size (): devuelve el número máximo de elementos que puede contener el conjunto
+5.  vacío () - Devuelve si el conjunto está vacío
+6.  borrar (const g): elimina el valor 'g' del conjunto
+7.  clear () - Elimina todos los elementos del conjunto
+
+Veamos un ejemplo:
+
+```cpp
+#include <iostream> 
+ #include <set> 
+ #include <iterator> 
+ 
+ using namespace std; 
+ int main() 
+ { 
+    set <int> myset;   //an empty set container. Note that size of the set need not be declared, similar to vector. 
+ 
+    // insert elements in random order 
+    myset.insert(65); 
+    myset.insert(30); 
+    myset.insert(80); 
+    myset.insert(20); 
+    myset.insert(9); 
+    myset.insert(9); // only one 9 will be added to the list. 
+ 
+ 
+    // printing set myset 
+    set <int> :: iterator itr; //an iterator is like a pointer. 
+    cout << "\nThe contents of myset : "; 
+    for (itr = myset.begin(); itr != myset.end(); ++itr) 
+    { 
+        cout << '\t' << *itr; 
+    } 
+    cout << endl; 
+ 
+ 
+    // remove all elements up to 65 in myset from the beginning:- 
+    cout << "\nContents of myset after removal of elements less than 30 : "; 
+    myset.erase(myset.begin(), myset.find(30)); 
+    for (itr = myset.begin(); itr != myset.end(); ++itr) 
+    { 
+        cout << '\t' << *itr; 
+    } 
+ 
+    // remove element with value 50 in myset 
+ 
+    int num = myset.erase(80); //returns true (and deletes) if 80 is there in the list else returns 0. 
+    cout<<"\n\n After doing myset.erase(80), "<<num<<" element is removed\n\n"; 
+    cout<<"Contents of the modified set:\t"; 
+    for (itr = myset.begin(); itr != myset.end(); ++itr) 
+    { 
+        cout << '\t' << *itr; 
+    } 
+ 
+    cout << endl; 
+ 
+ 
+    return 0; 
+ 
+ } 
+```
+
+\`\` \`cpp Salida:- Los contenidos de myset: 9 20 30 65 80.
+
+Contenido de myset después de la eliminación de elementos menores de 30: 30 65 80
+
+Después de hacer myset.erase (80), se elimina 1 elemento.
+
+Contenido del conjunto modificado: 30 65. \`\` \`
+
+\### Fuentes
+
+1.  [Geeks para Geeks](https://www.geeksforgeeks.org/set-in-cpp-stl/)

guide/spanish/cplusplus/stack/index.md

@@ -0,0 +1,174 @@
+---
+title: stack
+localeTitle: apilar
+---
+## Pilas
+
+`stack` es uno de los contenedores más utilizados en C ++. Un contenedor es una estructura de datos que almacena una colección de objetos, algunos en orden, otros no. Todos los contenedores tienen un conjunto diferente de funciones que le permiten acceder a un objeto (s) en esa colección.
+
+`std::stack` forma parte de la biblioteca estándar de C ++ (de ahí el prefijo `std::` y le permite almacenar datos en el orden Last In First Out (LIFO). NOTA: **Todos los objetos dentro de una pila deben ser del mismo tipo de datos**
+
+El tipo de datos que almacena dentro de una pila va entre paréntesis angulares junto a la palabra clave de pila. Por ejemplo, si desea almacenar una colección de enteros, la pila sería `std::stack<int> stack_name`
+
+### Explicación de pila LIFO
+
+`stack` nos permite empujar y hacer estallar en orden específico. **Empujar** significa insertar un objeto en la parte superior de la pila. **Pop** significa sacar el último objeto insertado de la parte superior de la pila. Por lo tanto, cuando lo empuja, se encuentra en la parte superior y cuando abre, extrae el último elemento insertado.
+
+![alt text](https://github.com/mohammadaziz313/helloworld/blob/master/Lifo_stack.png "Ejemplo de push y pop de pila LIFO")
+
+### Operaciones de pila
+
+El contenedor de pila admite las siguientes operaciones:
+
+*   empujar
+*   popular
+*   vacío
+*   tamaño
+*   espalda
+
+#### empujar
+
+Le permite insertar un nuevo elemento en la parte superior de la pila, sobre el elemento superior actual.
+
+```cpp
+//Push operation in Stack 
+ #include <iostream>       // std::cout 
+ #include <stack>          // std::stack 
+ 
+ int main () 
+ { 
+  std::stack<int> s; 
+ 
+  s.push(1);    //Pushing 1 at top of the stack 
+  s.push(2);    //Pushing 2 at top of the stack 
+ 
+  return 0; 
+ } 
+```
+
+#### Parte superior
+
+Le permite acceder al elemento superior sin quitarlo de su pila.
+
+```cpp
+//Top operation in Stack 
+ #include <iostream>       // std::cout 
+ #include <stack>          // std::stack 
+ 
+ int main () 
+ { 
+  std::stack<int> s; 
+ 
+  s.push(1);    //Pushing 1 at top of the stack 
+  s.push(2);    //Pushing 2 at top of the stack 
+ 
+  std::cout<<s.top()<<'\n';     //Accessing the top of the stack 
+  std::cout<<s.top()<<'\n';     //Accessing the top of the stack 
+ 
+  return 0; 
+ } 
+```
+
+```
+Output: 
+ 2 
+ 2 
+```
+
+#### Popular
+
+Elimina el elemento en la parte superior de la pila, reduciendo efectivamente el tamaño de tu pila en uno.
+
+```cpp
+//Pop operation in Stack 
+ #include <iostream>       // std::cout 
+ #include <stack>          // std::stack 
+ 
+ int main () 
+ { 
+  std::stack<int> s; 
+ 
+  s.push(1);    //Pushing 1 at top of the stack 
+  s.push(2);    //Pushing 2 at top of the stack 
+ 
+  std::cout<<s.top()<<'\n';   //Accessing the top of the stack 
+  s.pop();                    //Removing element from the top of stack 
+  std::cout<<s.top()<<'\n';   //Accessing the top of the stack 
+ 
+ 
+  return 0; 
+ } 
+```
+
+```
+Output: 
+ 2 
+ 1 
+```
+
+#### tamaño
+
+Devuelve el número de elementos en la `stack` .
+
+```cpp
+//Size operation in Stack 
+ #include <iostream>       // std::cout 
+ #include <stack>          // std::stack 
+ 
+ int main () 
+ { 
+  std::stack<int> s; 
+ 
+  s.push(1);    //Pushing 1 at top of the stack 
+  s.push(2);    //Pushing 2 at top of the stack 
+ 
+  std::cout<<s.size()<<'\n';  //Showing the size of the stack 
+  s.pop();                    //Removing element from the top of stack 
+  std::cout<<s.size()<<'\n';  //Showing the size of the stack 
+  s.pop();                    //Removing element from the top of stack 
+  std::cout<<s.size()<<'\n';  //Showing the size of the stack 
+ 
+  return 0; 
+ } 
+```
+
+```
+Output: 
+ 2 
+ 1 
+ 0 
+```
+
+#### Vacío
+
+Devuelve si la `stack` está vacía, es decir, si el tamaño de tu pila es cero. Devuelve `true` si el tamaño de la pila 0 si no devuelve `false`
+
+```cpp
+//Empty operation in Stack 
+ #include <iostream>       // std::cout 
+ #include <stack>          // std::stack 
+ 
+ int main () 
+ { 
+  std::stack<int> s; 
+ 
+  s.push(1); 
+  s.push(2); 
+ 
+  while(s.empty() != false){ 
+      std::cout<<s.top()<<'\n'; 
+      s.pop(); 
+  } 
+ 
+  std::cout<<"Out of loop"<<'\n'; 
+  return 0; 
+ } 
+```
+
+```
+Output: 
+ 2 
+ 1 
+ Out of loop 
+
+```

guide/spanish/cplusplus/switch-statements/index.md

@@ -0,0 +1,43 @@
+---
+title:Switch Statement
+localeTitle: undefined
+---
+Una declaración de cambio permite que una variable se pruebe para determinar su igualdad frente a una lista de valores. Cada valor se llama un caso, y la variable que se está activando se comprueba para cada caso.
+
+Sintaxis: interruptor (expresión) { expresión-constante del caso declaración (es); descanso; //Opcional expresión-constante del caso declaración (es); descanso; //Opcional
+
+// puedes tener cualquier número de declaraciones de casos. por defecto: // Opcional declaración (es); }
+
+Las siguientes reglas se aplican a una instrucción de cambio:
+
+La expresión utilizada en una instrucción de conmutación debe tener un tipo integral o enumerado, o debe ser de un tipo de clase en el que la clase tenga una única función de conversión a un tipo integral o enumerado.
+
+Puede tener cualquier número de declaraciones de casos dentro de un interruptor. Cada caso va seguido del valor que se va a comparar y dos puntos.
+
+La expresión constante para un caso debe ser el mismo tipo de datos que la variable en el conmutador, y debe ser una constante o un literal.
+
+Cuando la variable que se está activando es igual a un caso, las sentencias que siguen a ese caso se ejecutarán hasta que se alcance una sentencia de ruptura.
+
+Cuando se alcanza una declaración de interrupción, el interruptor termina y el flujo de control salta a la siguiente línea que sigue a la instrucción de cambio.
+
+No todos los casos necesitan contener un descanso. Si no aparece ninguna ruptura, el flujo de control caerá a los casos subsiguientes hasta que se alcance una ruptura.
+
+Una declaración de cambio puede tener un caso predeterminado opcional, que debe aparecer al final del cambio. El caso predeterminado se puede usar para realizar una tarea cuando ninguno de los casos es verdadero. No se necesita un descanso en el caso predeterminado.
+
+Ejemplo: \`\` \`C ++
+
+# incluir
+
+utilizando namespace std;
+
+int main () { // declaración de variable local: grado de char = 'D';
+
+interruptor (grado) { caso 'A': cout << "Excelente!" << endl; descanso; caso 'B': caso 'C': cout << "Bien hecho" << endl; descanso; caso 'D': cout << "Pasaste" << endl; descanso; caso 'F': cout << "Mejor inténtalo de nuevo" << endl; descanso; defecto : cout << "Grado no válido" << endl; } cout << "Su grado es" << grado << endl;
+
+devuelve 0; } \`\` \`
+
+Salida: Pasaste Tu nota es d
+
+### Fuentes
+
+https://www.tutorialspoint.com

guide/spanish/cplusplus/terms-to-know-for-beginners/index.md

@@ -0,0 +1,142 @@
+---
+title: IDE and Printing different text 
+localeTitle: IDE y la impresión de diferentes textos
+---
+# Introducción a un IDE e impresión de diferentes textos:
+
+*   En el último artículo, algunos enlaces de descarga de software requeridos para la programación. Software como este es conocido como un IDE. **IDE significa Ambiente de Desarrollo Integrado**
+
+## Los IDE consisten principalmente en 3 tipos de software:
+
+**1 Editor:** un editor de texto ligeramente modificado para facilitar la codificación. Un ejemplo de un editor para la codificación es Notepad ++.
+
+**2 Depurador:** software que le ayuda a encontrar errores en su programa y a resolverlos antes de la ejecución. Imagina que FaceBook se cuelga al cargar una aplicación o un juego que se estrella de repente. Para evitar la ejecución defectuosa de un programa, el depurador es el mejor amigo de un programador.
+
+**3 Compilador:** Un compilador es la parte de la computadora que convierte su código de programa de alto nivel en código de máquina simple: 0s y 1s; Para que una computadora entienda los comandos y los ejecute. A partir de ahora, estaremos repitiendo la palabra **compilador con** frecuencia.
+
+_P: Intente buscar un IDE en Google y ejecute su primer programa en él. Comprueba la salida_
+
+Ahora, instale el IDE e intente cambiar el texto del programa en el último artículo.
+
+### Cambio de texto en C ++
+
+*   Para cambiar el texto, cambie lo que está escrito en `""` después de `cout<<`
+
+Un programa de muestra:
+
+```cpp
+#include <iostream> 
+ using namespace std : 
+ int main() 
+ { 
+    cout << "I Love freeCodeCamp ! "; 
+ } 
+```
+
+El código anterior devuelve un error porque en la línea 2, hemos usado dos puntos (:) en lugar de un punto y coma (;) Entonces, vamos a depurar el error:
+
+```C++
+#include <iostream> 
+ using namespace std ; 
+ int main() 
+ { 
+    cout << "I Love freeCodeCamp ! "; 
+    return 0; 
+ } 
+```
+
+Tenga en cuenta que ahora el programa se ejecuta perfectamente. La salida será: `I Love freeCodeCamp!`
+
+### Ahora, cambiemos el texto a algo como esto:
+
+```cpp
+    cout << "Hello World!\t I love freeCodeCamp!"; 
+```
+
+La salida será algo diferente esta vez:
+```
+Hello World!     I love freeCodeCamp! 
+```
+
+Si se dio cuenta, el comando `\t` creó un _espacio de tabulación_ entre los dos textos. Este es un tipo de comando especial en C ++. Estos comandos especiales se conocen como _secuencias de escape_ . Se utilizan para imprimir ciertos caracteres especiales que un compilador no puede mostrar.
+
+#### Secuencias de escape útiles:
+
+*   `\'` para imprimir una sola coma invertida
+*   `\"` para imprimir una coma doble invertida
+*   `\n` para imprimir en una nueva línea
+*   `\t` para una pestaña horizontal
+*   `\f` para una nueva página
+*   `\\` para una barra invertida
+*   `\?` para un signo de interrogación
+
+##### Ahora, intentemos imprimir números y caracteres especiales con algunas secuencias de escape:
+
+```cpp
+    cout << "40158 \t 236708 ! \n \\ @ \?" << endl; 
+```
+
+La salida cambia a:
+```
+40158      236708 ! 
+ \ @ ? 
+```
+
+##### Probemos algunas otras formas de imprimir:
+
+```cpp
+    cout << "1+2" << endl; 
+    cout << 1+2 << endl; 
+```
+
+Salida:
+
+*   La primera declaración de salida es `1+2`
+*   La segunda declaración de salida es `3`
+
+Esto se debe a que no agregamos las comillas invertidas para la segunda declaración de impresión y, por lo tanto, el compilador agregó los números antes de imprimirlos.
+
+#### Comentarios:
+
+*   Los comentarios son una característica importante de muchos lenguajes de programación. Permiten que el programador tome notas para la autoayuda y no afectará la ejecución del programa.
+
+**Los diferentes tipos de comentarios y la sintaxis de un comentario** :
+
+1 `//` ~ _Comentarios de una sola línea_ : La longitud de estos comentarios es de 1 línea (la línea en la que se escribe). 2 `/* */` ~ _Comentarios de líneas múltiples_ : estos comentarios pueden ocupar un espacio de más de una línea.
+
+#### Ejemplo de uso de comentarios:
+
+\`\` \`cpp cout << "Hello Comment" << endl; // cout << "Hello Comment" << endl; , Comentario de una sola línea.
+```
+/* This is an example of a multi line comment. No output is generated for this . 
+ I now end the comment.  :) */ 
+```
+
+\`\` \`
+
+La salida será:
+
+`Hello Comment`
+
+Como puede observar, los comentarios se ignoran durante la ejecución del programa y no aparecen al verificar la salida del programa. Debe tenerse en cuenta que si bien los comentarios agregan un nivel adicional de legibilidad al código, es un mal hábito confiar demasiado en los comentarios para describir la lógica de su código. En general, su código debe hablar por sí mismo y reflejar la intención del programador.
+
+Como puede observar, los comentarios se ignoran durante la ejecución del programa y no aparecen al verificar la salida del programa.
+
+#### Los operadores
+
+*   Los operadores te permiten comparar dos o más expresiones
+*   `==` igual a
+*   `!=` no es igual a
+*   `<` menos que
+*   `>` mayor que
+*   `<=` menor o igual que
+*   `>=` mayor que o igual a
+
+```cpp
+    (7==5); 
+```
+
+Esto se evalúa como falso
+
+`cpp (7!=5);` Esto se evalúa como verdadero
+

guide/spanish/cplusplus/the-auto-feature/index.md

@@ -0,0 +1,74 @@
+---
+title: The Auto Feature
+localeTitle: La característica de auto
+---
+## La característica de auto
+
+`auto` es una característica de C ++ 11 que le permite al compilador inferir el tipo de datos para usted en una definición. Esto puede ahorrarle mucho escribir, especialmente con tipos complicados.
+
+Sin `auto`
+
+```cpp
+double x = 10.425; 
+ double y = x * x; 
+```
+
+Con `auto`
+
+```cpp
+double x = 10.425; 
+ auto y = x * x; 
+```
+
+Si bien puede parecer trivial, se vuelve increíblemente útil cuando los tipos de datos comienzan a complicarse. Por ejemplo, suponga que desea almacenar un [`vector`](https://guide.freecodecamp.org/cplusplus/vector) de empleados y que solo está interesado en su nombre y edad. Una forma de almacenar el nombre y la edad podría ser un `pair` con una `string` y un `unsigned int` . Esto se declara como `std::vector<std::pair<std::string, unsigned int>> employees` . Ahora suponga que desea acceder al último empleado agregado:
+
+```cpp
+std::vector<std::pair<std::string, unsigned int>> employees; 
+ 
+ // without auto, you have to write: 
+ std::pair<std::string, unsigned int>> last_employee = employees.back(); 
+ 
+ // with auto, you just have to write: 
+ auto last_employee = employees.back(); 
+```
+
+Una vez que el compilador determina el tipo en el lado derecho de `=` , reemplaza `auto` con ese tipo.
+
+En las versiones modernas de C ++ (desde C ++ 14), `auto` también se puede usar en una declaración de función como tipo de retorno. El compilador luego inferirá el tipo de retorno de la declaración de retorno dentro de la función. Siguiendo el ejemplo con los empleados:
+```
+std::vector<std::pair<std::string, unsigned int>> employees; 
+ auto get_last_employee() { 
+    return employees.back(); // Compiler knows the return type from this line. 
+ } 
+```
+
+El compilador sabrá por la línea con la declaración de retorno que el tipo de retorno de la función debe ser `std::vector<std::pair<std::string, unsigned int>>` .
+
+Si bien es bastante técnico, la [página cppreference en auto](http://en.cppreference.com/w/cpp/language/auto) describe muchos más usos de `auto` y los detalles de cuándo se puede y no se puede usar.
+
+### `auto` antes de C ++ 11
+
+En algunos libros de texto antiguos que contienen código _muy_ antiguo, la palabra clave `auto` se utiliza de una manera muy diferente.
+
+Este `auto` particular fue una palabra clave prestada de C, y probablemente fue la palabra clave menos utilizada de todos los tiempos.
+
+En C ++, todas las variables tienen _una duración automática_ , es decir, se definen hasta que se sale de la función en la que están definidas.
+
+Por ejemplo:
+
+\`\` \`cpp
+
+# incluir
+
+int main () { int a a = 1; // tiene sentido, como se definió en la misma función
+```
+    return 0; 
+```
+
+} a = 2; // no tiene sentido, ya que no se define aquí \`\` \`
+
+Esto se da en C ++, y se especifica `auto` que la variable debe tener una _duración automática_ , de ahí la falta de uso.
+
+## Otras lecturas :
+
+*   http://www.stroustrup.com/C++11FAQ.html#auto

guide/spanish/cplusplus/the-if-statement/index.md

@@ -0,0 +1,95 @@
+---
+title: C++ If Statement
+localeTitle: C ++ If Declaración
+---
+# La declaración IF.
+
+**¿Qué hace una sentencia if?**
+
+*   La instrucción `if` evalúa la expresión de prueba presente dentro del paréntesis.
+*   La instrucción `if` usa operadores relacionales y lógicos para hacer expresiones lógicas.
+
+* * *
+
+La forma general de la declaración `if` :
+
+```cpp
+  if (Test Expression / Condition) 
+  { 
+    // Block of statements if test expression is True 
+  } 
+```
+
+Si el valor de la expresión de prueba es **verdadero** , entonces el bloque de Código dentro de la sentencia if se ejecuta.
+
+Si el valor de la expresión de prueba es **falso** , entonces el bloque de el código dentro de la sentencia if se omite y su código continúa.
+
+Ejemplo `if` declaración:
+
+```cpp
+  int a = 10; 
+ 
+  // true statement 
+  if (a < 20) 
+  { 
+    // execute this block of code 
+  } 
+ 
+  // false statement 
+  if (a < 0) 
+  { 
+    // Skip this block of code. 
+  } 
+```
+
+Ejemplo en C ++:
+
+```cpp
+  // Program to check if number entered by the user is positive 
+  // If negative, the block of code is skipped 
+ 
+  #include <iostream> 
+  using namespace std; 
+ 
+  int main() 
+  { 
+    int no ; 
+    cout << "Enter a number: "; 
+    cin >> no; 
+ 
+    // if statement to check if the number is positive 
+    if ( no > 0) 
+    { 
+      cout << "You have entered a positive number: " << no << endl; 
+    } 
+ 
+    // If number is not positive, then if statement is skipped a program continues 
+    cout << "This step is always printed" << endl; 
+ 
+    return 0; 
+  } 
+```
+
+**Salida:**
+
+SALIDA 1:
+```
+Enter a number: 5 
+ You have entered a positive number: 5 
+ This step is always printed 
+ ``` 
+ This is the output when the number entered is positive. 
+ 
+ OUTPUT 2: 
+```
+
+Introduce un número: -1 Este paso siempre se imprime. \`\` \` Esta es la salida cuando el número introducido es negativo.
+
+[Pruebe el código usted mismo! :)](https://repl.it/Mg9X)
+
+_FELICIDADES . Este es el final del artículo sobre la declaración IF._
+
+**Buena suerte a todos ustedes**
+
+**¡Feliz codificación! :)**
+

guide/spanish/cplusplus/tokens-operators/index.md

@@ -0,0 +1,186 @@
+---
+title: Operators
+localeTitle: Los operadores
+---
+# Operadores:
+
+*   Los operadores le permiten realizar operaciones en sus datos.
+*   Los datos que se están operando se denominan _operandos_ .
+*   Los diferentes tipos de operadores en C ++ son:
+*   _Los OPERANDOS_ son los datos sobre los cuales el operador realiza ciertos comandos.
+*   Los operadores son de 3 tipos: unario (funciona en 1 operando), binario (funciona en 2 operandos), ternario (trabaja en 3 operandos).
+
+### 1 Los operadores de E / S -
+
+*   Estos operadores le permiten dirigir la entrada y la salida.
+    
+    ## El oerador de entrada ">>" ##
+    
+    se utiliza para leer datos de entrada estándar (la declaración "cin").
+    
+    ## El operador de salida "<<"
+    
+    se utiliza para enviar la salida en la declaración `cout` .
+    
+
+### 2 Los operadores aritméticos -
+
+*   Estos operadores le permiten realizar operaciones aritméticas básicas.
+
+1.  El operador `+` _agrega_ los dos operandos.
+    
+2.  El operador `-` _resta_ los dos operandos.
+    
+3.  El operador `*` _multiplica_ los dos operandos.
+    
+4.  El operador `/` _divide_ y da el _cociente_ de los dos operandos.
+    
+5.  El operador `%` _divide_ y da el _resto_ de los dos operandos. (O, para el lector más inclinado matemáticamente, `a % b` es esencialmente el resultado de "a mod b"
+    
+    ### Ejemplo de uso de operadores aritméticos:
+    
+    \`\` \`cpp
+    
+
+# incluir
+
+utilizando namespace std;
+
+int main () { int a = 5; // 1er operando int b = 10; // 2do operando
+```
+    cout << "+ operator " << a+b << "\n"; //Add 
+    cout << "- operator " << ab << "\n"; //Subtract 
+    cout << "* operator " << a*b << "\n"; //Multiply 
+    cout << "/ operator " << b/a << "\n"; //Find Quotient 
+    cout << "modulus operator " << b%a << "\n"; //Find remainder 
+ 
+    return 0; 
+```
+
+} \`\` \`
+
+SALIDA:
+```
++ operator 15 
+ - operator -5 
+ * operator 50 
+ / operator 2 
+ modulus operator 0 
+```
+
+[Pruebe el código usted mismo! :)](https://repl.it/Mge9)
+
+### El operador de incremento:
+
+*   `++` se conoce como el operador de incremento. Aumenta el valor de una variable entera en 1.
+
+Los 2 tipos de incremento:
+
+*   Pre incrementa primero incrementa el valor y luego lo usa. Ejemplo: `int a ; ++a;`
+*   El incremento posterior primero usa la variable y luego la incrementa. Ejemplo: `int b; b++;`
+
+### El operador decremento:
+
+*   `--` Es conocido como el operador decremento. Disminuye el valor de una variable entera en 1.
+
+Los 2 tipos de decremento:
+
+*   La disminución previa disminuye primero el valor y luego lo utiliza. Ejemplo: `int a ; --a;`
+*   El decremento posterior primero usa la variable y luego la decrementa. Ejemplo: `int b; b--;`
+
+Ejemplo de operadores de incremento y decremento:
+
+```cpp
+#include <iostream> 
+ using namespace std; 
+ 
+ int main() 
+ { 
+        int a = 3 ,b = 4; 
+ 
+         // INCREMENT 
+        cout<< "Value of int a PRE INCREMENTED : " << ++a << "\n"; 
+        cout<< "Value of int b POST INCREMENTED : " << b++ << "\n"; 
+        cout<< "Value of b is changed after using once : " << b << "\n"; 
+ 
+         // DECREMENT 
+        cout << "\n"; //go to next line 
+        a = 10; //Assigning a new value to a 
+        b = 10; //Assigning a new value to b 
+        cout << "Value of int a PRE DECREMENTED : " << --a << "\n"; 
+        cout << "Value of int b POST DECREMENTED : " << b-- << "\n"; 
+        cout << "Value of b is changed after using once : " << b << "\n"; 
+ 
+        return 0; 
+ } 
+```
+
+SALIDA:
+```
+Value of int a PRE INCREMENTED : 4 
+ Value of int b POST INCREMENTED : 4 
+ Value of b is changed after using once : 5 
+ 
+ Value of int a PRE DECREMENTED : 9 
+ Value of int b POST DECREMENTED : 10 
+ Value of b is changed after using once : 9 
+```
+
+[Pruebe el código usted mismo! :)](https://repl.it/Mgg4/2)
+
+### 3: Operadores relacionales:
+
+*   Estos operadores nos dicen la relación entre 2 operandos y devuelven un valor booleano (0 o 1). Si la relación es `true` entonces resulta en 1. Si la realidad es falsa, entonces se convierte en 0.
+    
+*   Los 6 operadores relacionales son:
+    
+    1.  Menos que `<`
+    2.  Mayor que `>`
+    3.  Menor o igual que `<=`
+    4.  Mayor o igual a `>=`
+    5.  Igual a `==`
+    6.  No es igual a `!=`
+
+### 4: Operadores lógicos:
+
+*   Estos operadores combinan expresiones para operaciones lógicas. Son :
+
+1.  AND `&&` lógico: se evalúa como verdadero si ambos valores son verdaderos.
+    
+2.  OR lógico `||` : Se evalúa como verdadero si cualquier valor es verdadero.
+    
+3.  ¡Lógica NO `!` : Si la _expresión_ es verdadera, entonces _! Expresión_ es falsa. Este operador invierte el valor de verdad y es un operador unario.
+    
+    ### 5\. Operadores ternarios:
+    
+    El operador `?:` Es el operador ternario, o el _operador condicional_ , porque se puede utilizar para sustituir una instrucción `if else` , o incluso una instrucción `if else if` . La sintaxis:
+    
+
+`condition ? ValueIfTrue : ValueIfFalse` . Esto se expande a:
+
+```cpp
+if(condition) 
+ ValueIfTrue; 
+ else ValueIfFalse; 
+```
+
+Llamar a `ValueIfTrue` un valor es un poco incorrecto, ya que no es necesario que sea un número. Algo como esto:
+
+`condition ? FirstLevelTrueValue : ConditionIfFalse ? SecondLevelTrueValue : SecondLevelFalseValue` también funciona, y se interpreta como la siguiente instrucción `if else if` :
+
+```cpp
+if(condition) 
+ FirstLevelTrueValue; 
+ else if(ConditionIfFalse) 
+ SecondLevelTrueValue; 
+ else SecondLevelFalseValue; 
+```
+
+Del mismo modo, anidado `if` declaraciones también se pueden hacer utilizando operadores ternarios.
+
+_Camper, ahora sabes lo que son los tokens. El próximo artículo será sobre_ _FELICIDADES_
+
+**Buena suerte a todos ustedes**
+
+**¡Feliz codificación! :)**
+

guide/spanish/cplusplus/tokens-variables/index.md

@@ -0,0 +1,208 @@
+---
+title: Tokens Part 1
+localeTitle: Tokens parte 1
+---
+### ¿Qué son los tokens?
+
+Los tokens son las unidades más pequeñas de un programa que son importantes para el compilador. Hay diferentes tipos de fichas:
+
+*   Palabras clave
+    
+*   Los operadores
+    
+*   Puntuadores
+    
+*   Literales
+    
+*   Identificadores
+    
+*   **Combinación de fichas forman una expresión.**
+    
+
+### ¿Qué son las variables?
+
+*   Definición de libro de texto: las variables se denominan ubicaciones de memoria cuyos datos pueden modificarse.
+    
+*   Pero me gustaría que pensaras en una variable como algo así como una caja, algo como esto: ![Img](https://i.imgur.com/YdbgWHL.png)
+    
+
+Así por ejemplo : Me estoy mudando a un nuevo lugar y necesito arreglar mis cosas en cajas. Por lo tanto, se me ocurren 2 cosas: **¿Qué tipo de cosas se almacenarán en la caja, de modo que se conozca el tamaño de la caja (el tipo de datos)** y **cómo se identifica la caja? (Nombrar la variable)**  
+Por lo tanto, sabemos que una variable en C ++ necesita un _nombre_ y un _tipo de datos_ y que el valor almacenado en ellos puede cambiarse.
+
+### Tipos de datos en C ++:
+
+Al declarar variables en c ++, deben tener un nombre al que se referirá más adelante, un valor (constante o no) y un tipo. El tipo le dirá al compilador los valores que la variable puede usar, las posibles operaciones y guardará un cierto espacio en la memoria. En c ++ hay dos tipos de datos:
+
+*   Tipo simple
+*   Tipo de struct
+
+### Tipos de datos simples
+
+*   Booleano - bool Funciona como un interruptor, puede estar encendido o apagado.
+*   Personaje - char Almacena un solo personaje.
+*   Entero - int Almacena un [entero](https://en.wikipedia.org/wiki/Integer) .
+*   Punto flotante - flotador Pueden usar decimales.
+*   Doble punto flotante - doble Doble precisión del tipo flotador.
+
+Aquí puedes ver algunos ejemplos:
+
+```cpp
+bool GameRunning = true; 
+ char a; 
+ int x = 2; 
+```
+
+#### Estos tipos también pueden modificarse con modificadores tales como:
+
+firmado no firmado corto largo
+
+### Tipo de datos Struct
+
+#### Identificadores
+
+*   Los identificadores son los nombres dados a una variable o una clase o una función o cualquier función definida por el usuario.
+
+## Reglas para nombrar una variable:
+
+*   Comience a nombrar con una letra de AZ o az.
+*   Los números pueden seguirte a la primera letra, pero no podemos comenzar a nombrar con números.
+*   NO se permite el uso de espacios o caracteres especiales, en su lugar, use UNDERSCORE \_.
+
+#### Declarando un variabe:
+
+La sintaxis es la siguiente < _tipo de datos_ > < _nombre de variable_ >; o < _tipo de datos_ > < _nombre de variable_ > = < _valor_ >; Si también queremos inicializar la variable.
+
+Por ejemplo : `cpp int a ; //declaring a variable named 'a' of type integer. a=4; //initializing a variable int b = 5 ; //declaring and initializing a variable 'b' of type integer.`
+
+**Ejemplos de declarar una variable:**
+
+```cpp
+int a9; 
+ char A; 
+ double area_circle; 
+ long l; 
+```
+
+**Maneras equivocadas de declarar variables** -
+
+```cpp
+int 9a; 
+ char -a; 
+ double area of circle; 
+ long l!!; 
+```
+
+*   Los nombres de variables no pueden comenzar con un número
+*   Caracteres especiales no están permitidos
+*   No se permiten espacios.
+
+Puedes imaginar diferentes cajas de diferentes tamaños y almacenar diferentes cosas como diferentes variables.
+
+**NOTAS:**
+
+1.  **El compilador de C ++ ignora los espacios en blanco y generalmente se usan para embellecer el código de modo que sea fácil para cualquier programador depurar o entender el código.**
+2.  **Si una variable no está inicializada, contiene un valor de basura. Déjame dar un ejemplo:**
+
+### Alcance de las variables
+
+Todas las variables tienen su área de funcionamiento, y fuera de ese límite no tienen su valor, este límite se denomina alcance de la variable. Para la mayoría de los casos es entre llaves, en la cual se declara que una variable existe, no fuera de ella. Estudiaremos las clases de almacenamiento más adelante, pero a partir de ahora, podemos dividir las variables en dos tipos principales,
+
+\*Variables globales.
+
+\* Variables locales.
+
+#### Variables globales
+
+Las variables globales son aquellas que se declaran una vez y pueden ser utilizadas durante toda la vida útil del programa por cualquier clase o función. Deben ser declarados fuera de la función main (). Si solo se declaran, se les pueden asignar diferentes valores en diferentes momentos de la vida del programa. Pero incluso si se declaran y se inicializan al mismo tiempo fuera de la función main (), también se les puede asignar cualquier valor en cualquier punto del programa.
+
+Ejemplo: Solo declarado, no inicializado.
+
+```cpp
+#include <iostream> 
+ using namespace std; 
+ int x;                // Global variable declared 
+ int main() 
+ { 
+ x=10;                 // Initialized once 
+ cout <<"first value of x = "<< x; 
+ x=20;                 // Initialized again 
+ cout <<"Initialized again with value = "<< x; 
+ } 
+```
+
+#### Variables locales
+
+Las variables locales son las variables que existen solo entre las llaves, en las que se declara. Fuera de eso no están disponibles y conduce a un error de tiempo de compilación.
+
+Ejemplo:
+
+```cpp
+#include <iostream> 
+ using namespace std; 
+ int main() 
+ { 
+ int i=10; 
+ if(i<20)        // if condition scope starts 
+  { 
+    int n=100;   // Local variable declared and initialized 
+  }              // if condition scope ends 
+ cout << n;      // Compile time error, n not available here 
+ } 
+```
+
+### Variables constantes
+
+Variable constante son las variables que no pueden ser cambiadas. Por ejemplo, si necesita "pi" en su código, no querrá cambiarlo después de la inicialización.
+
+Ejemplo:
+
+```cpp
+#include <iostream> 
+ using namespace std; 
+ const double PI = 3.14159253; 
+ int main() 
+ { 
+ //Calculating the area of a circle, using user provided radius 
+ double radius; 
+ //input and output explained in other guide 
+ cin>>radius; 
+ //pi*r^2 
+ double area = PI*radius*radius; 
+ cout<<area<<endl; 
+ } 
+```
+
+### Valores de basura en una variable
+
+Si una variable no está inicializada, contiene un valor de basura. Por ejemplo:
+
+Así que en términos de cajas, puedes imaginar esto como ...
+
+![Img](https://i.imgur.com/YdbgWHL.png)
+
+\`\` \`cpp #incluir utilizando namespace std; int main () { int a cout << "Valor de basura en a:" << a << endl; // declarando la variable llamada 'a' de tipo entero a = 5; // inicializando variable. cout << "Nuevo valor en a" << a << endl;
+
+} \`\` \`
+
+### La salida es:
+```
+Garbage value in a : 0 
+ New value in a :  5 
+```
+
+Como puede ver, ya hay un valor almacenado en 'a' antes de que le demos un valor (aquí, es 0). Esto debería permanecer en la mente de cada programador para que cuando se utilicen las variables no creen un error lógico e impriman valores de basura.
+
+[Pruebe el código usted mismo! :)](https://repl.it/Mg7j)
+
+#### Palabras clave:
+
+_Las palabras clave son palabras reservadas que transmiten un significado especial al compilador. **NO se** pueden usar para nombrar en c ++._ Ejemplos de palabras clave: en línea, operador, int privado, doble, vacío, char, plantilla, uso, virtual, ruptura, mayúscula, interruptor, amigo, etc.
+
+**Cada una de estas palabras clave se usa para una función especial en C ++.**
+
+_Tokens parte 1 ha terminado. Nos vemos campistas en la [Parte 2](https://guide.freecodecamp.org/cplusplus/tokens-part-II) de Tokens :)_
+
+**Buena suerte a todos ustedes**
+
+**¡Feliz codificación! :)**
+

guide/spanish/cplusplus/tokens-variables/static-variable-info/index.md

@@ -0,0 +1,120 @@
+---
+title: Variables
+localeTitle: Variables
+---
+Vamos a discutir algo conocido como variables. Las variables son como un cubo. Puedes poner algo en él y luego cambiarlo. después cuando sea necesario. En C ++, hay muchos tipos de variables como enteros, cadenas, booleanos y muchos otros. Veamos un programa simple usando variables enteras. Los enteros almacenan números enteros que son positivos, negativos o cero. Los números enteros no son números fraccionarios, por ejemplo, 1/2, 1/4 y 1/5. Veamos un programa simple que usa un entero variable.
+
+```cpp
+#include <iostream> 
+ using namespace std ; 
+ int main() 
+ { 
+    int a;          // Declare an integer variable a 
+    a = 5;          // Assign value of 5 to variable a 
+    cout << a;      // Display the value of variable a which contains 5 
+    return 0; 
+ } 
+```
+
+Cuando ejecute este programa, verá 5 en la pantalla
+
+*   Tenga en cuenta que en el programa anterior // se coloca después de las líneas. El símbolo "//" es para comentar nuestro código. Código después del símbolo. "//" no se ejecuta en la línea donde está ubicado.
+    
+*   En la línea 5 n se declara una variable entera simple.
+    
+*   En la línea 6 se asigna el valor 5 a la variable a. Ahora cada vez que usamos la variable a en nuestro programa su valor será 5 A menos que lo cambiemos.
+    
+*   En la línea 7 mostramos el valor de la variable a y 5 se imprime en la pantalla.
+    
+
+### Alcance de las variables
+
+Todas las variables tienen su área de funcionamiento, y fuera de ese límite no tienen su valor, este límite se denomina alcance de la variable. Para la mayoría de los casos es entre llaves, en la cual se declara que una variable existe, no fuera de ella. Estudiaremos las clases de almacenamiento más adelante, pero a partir de ahora, podemos dividir las variables en dos tipos principales,
+
+\*Variables globales.
+
+\* Variables locales.
+
+#### Variables globales
+
+Las variables globales son aquellas que se declaran una vez y pueden ser utilizadas durante toda la vida útil del programa por cualquier clase o función. Deben ser declarados fuera de la función main (). Si solo se declaran, se les pueden asignar diferentes valores en diferentes momentos de la vida del programa. Pero incluso si se declaran y se inicializan al mismo tiempo fuera de la función main (), también se les puede asignar cualquier valor en cualquier punto del programa.
+
+Ejemplo: Solo declarado, no inicializado.
+
+```cpp
+include <iostream> 
+ using namespace std; 
+ int x;                // Global variable declared 
+ int main() 
+ { 
+ x=10;                 // Initialized once 
+ cout <<"first value of x = "<< x; 
+ x=20;                 // Initialized again 
+ cout <<"Initialized again with value = "<< x;` 
+ } 
+```
+
+#### Variables locales
+
+Las variables locales son las variables que existen solo entre las llaves, en las que se declara. Fuera de eso no están disponibles y conduce a un error de tiempo de compilación.
+
+Ejemplo:
+
+```cpp
+include <iostream> 
+ using namespace std; 
+ int main() 
+ { 
+ int i=10; 
+ if(i<20)        // if condition scope starts 
+  { 
+    int n=100;   // Local variable declared and initialized 
+  }              // if condition scope ends 
+ cout << n;      // Compile time error, n not available here 
+ } 
+```
+
+Ahora vamos a leer acerca de un nuevo tipo de variable
+
+#### Variable estática
+
+Variables estáticas: cuando una variable se declara como estática, el espacio para ella se asigna durante la vida útil del programa. Incluso si la función se llama varias veces, el espacio para la variable estática se asigna solo una vez y el valor de la variable en la llamada anterior se transmite a través de la siguiente llamada a la función. Esto es útil para implementar coroutines en C / C ++ o en cualquier otra aplicación donde se deba almacenar el estado de función anterior. En términos simples, significa que una variable normal cuando se sale del ámbito pierde su identidad (valor), pero una variable estática tiene un alcance global y conserva su valor hasta el final del programa, pero a diferencia de la variable global no es necesario declararla Al inicio del programa.
+
+#### EXTRA-
+
+Static es una palabra clave en C ++ utilizada para dar características especiales a un elemento. A los elementos estáticos se les asigna almacenamiento solo una vez en la vida útil del programa en el área de almacenamiento estático. Y tienen un alcance hasta la vida del programa.
+
+#### CÓDIGO-
+```
+#include <iostream> 
+ #include <string> 
+ using namespace std; 
+ 
+ void howstaticworks() 
+ { 
+    static int count = 0;  // static variable 
+    cout << count << " "; 
+ 
+    /* value is updated and 
+     will be carried to next 
+     function calls*/ 
+    count++; 
+ } 
+ 
+ int main() 
+ { 
+    for (int i=0; i<5; i++) 
+        howstaticworks(); 
+    return 0; 
+ } 
+```
+
+#### Pruébate
+
+simplemente copia el código y pégalo en el enlace dado. Ejecutar en IDE- https://ideone.com/
+
+Salida: 0 1 2 3 4
+
+Puede ver en el programa anterior que el conteo de variables está declarado como estático. Por lo tanto, su valor se lleva a través de las llamadas de función. La cuenta variable no se está inicializando cada vez que se llama a la función.
+
+Probemos el mismo código eliminando la palabra clave "estática", adivinemos la salida y comparémosla con una del IDE. La estática ahora se convierte en variable normal

guide/spanish/cplusplus/vector/index.md

@@ -0,0 +1,211 @@
+---
+title: Vectors
+localeTitle: Vectores
+---
+## Vectores
+
+El `vector` C ++ es uno de los contenedores más utilizados en C ++. Un contenedor es una estructura de datos que almacena una colección de objetos que pueden variar desde que se ordenan (¡como `vector` !) A desordenados (como `set` ). Todos los contenedores de C ++ tienen un conjunto diferente de funciones que le permiten acceder a un objeto (s) en esa colección, modificar y recorrer los elementos en esa estructura de datos.
+
+Los vectores son similares a ArrayLists en Java ya que no tiene que especificar la longitud del contenedor. Comparado con una matriz donde tiene que definir qué tan grande es, su tamaño depende de su contenido.
+
+`std::vector` es parte de la biblioteca estándar de C ++ (de ahí el prefijo `std::` y le permite almacenar datos contiguos del mismo tipo de datos. NOTA: **Todos los objetos dentro de un vector deben ser del mismo tipo de datos**
+
+El tipo de datos que almacena dentro de un vector va entre paréntesis angulares junto a la palabra clave del vector. Por ejemplo, si desea almacenar una colección de cadenas, el vector sería `std::vector<std::string> vector_name`
+
+_NOTA_ : ¡Debes incluir la biblioteca de vectores siempre que uses vectores!
+
+`#include <vector>`
+
+### Construcción de vectores
+
+Hay muchas formas convenientes de construir un vector.
+
+Usando una lista de intializer - donde los objetos están listados dentro de un conjunto de llaves: `{ }`
+
+```cpp
+std::vector<int> a{1, 2, 3, 4, 5}; // a is a vector of 5 ints: 1, 2, 3, 4 and 5 
+ std::vector<std::string> b{"hello", "world"}; // b is a vector of 2 strings: "hello" and "world" 
+ std::vector<bool> v; // v is an empty vector 
+```
+
+Construyéndolo a partir de otro vector (esto se conoce como una construcción de copia)
+
+```cpp
+std::vector<double> a{1.0, 2.0, 3.0}; 
+ std::vector<double> b(a); // b is a vector of 3 doubles: 1.0, 2.0 and 3.0 
+```
+
+Inicializándolo con el mismo elemento:
+
+```cpp
+std::vector<int> a(100, -1); // a is a vector of 100 elements all set to -1 
+```
+
+### Iteradores vectoriales
+
+Los iteradores se pueden considerar como punteros utilizados específicamente para navegar por los contenedores. (como los vectores). Los iteradores más importantes son `begin()` y `end()` . `begin()` devuelve un puntero al primer elemento en un vector mientras que los puntos `end()` a una posición después del último elemento en un vector. Como tal en bucle a través de una vector se puede hacer como:
+
+```cpp
+std::vector<int> vec{1, 2, 3}; 
+ 
+ for(auto vec_it = vec.begin(); vec_it != vec.end(); it++){ 
+    // since vec_it is a pointer and points to the memory address of the item 
+    // inside the vector, vec_it must be dereferenced using '*' 
+    std::cout << *it << '\n'; 
+ } 
+ /*  Output 
+    1 
+    2 
+    3 
+ */ 
+```
+
+### Modificar un vector
+
+Empujando elementos a un vector:
+
+```cpp
+std::vector<int> vec; // constructs an empty vector 
+ 
+ for (int i = 0; i < 10; i = i + 2){ 
+    vec.push_back(i); 
+ } 
+ // vec now holds [0, 2, 4, 6, 8] 
+```
+
+Insertar un artículo en una posición particular es ligeramente diferente. El vector C ++ insert La función funciona en iteradores. Insertará el elemento dado una posición antes del dado. iterador
+
+```cpp
+std::vector<unsigned int> vec{3, 400, 12, 45}; 
+ 
+ auto iter = vec.begin() + 2; // iter now points to '12' 
+ vec.insert(iter, 38); // inserts '38' before '12' 
+ 
+ // vec: [3, 400, 38, 12, 45] 
+```
+
+### Elemento de acceso
+
+La biblioteca estándar proporciona diferentes funciones para acceder a elementos particulares en su vector.
+
+```cpp
+std::vector<std::string> a{"test", "element", "access"}; 
+ 
+ std::string first_item = a.front(); // gets the first item of the vector ("test") 
+ std::string last_item = a.back(); // gets the last item in the vector ("access") 
+ 
+ // To get an element at a specific index (remember: vector indices start at 0) 
+ std::string second_item = a.at(2); // gets "element" 
+ // OR 
+ std::string second_item = a[2]; // gets "element" 
+```
+
+### Bucle sobre elementos en un `vector`
+
+El bucle sobre elementos en un C ++ `std::vector` es bastante diferente del bucle sobre elementos en un vector en JavaScript o Ruby. Debido a que C ++ es una abstracción delgada de C, solo puede recorrer elementos utilizando estas pequeñas y ingeniosas variables llamadas iteradores para acceder a cada elemento. Los iteradores a menudo vienen en forma de punteros que son variables que almacenan la dirección de memoria de otra variable. Puedes aprender más sobre punteros [aquí](https://www.tutorialspoint.com/cplusplus/cpp_pointers.htm) . Sin embargo, debido a que los iteradores actúan como punteros (o viceversa), para ver a qué apuntan, debe desreferirlo en una variable del tipo apropiado. Cómo hacemos esto? AQUÍ. NOSOTROS. ¡IR!
+
+```cpp
+std::vector<std::string> a{"test", "element", "access"}; 
+ for(auto it = v.begin(); it != v.end(); it++) { //notice use of auto keyword 
+    cout<<*it<<endl; //Will print out string that the iterator is currently ppointing to 
+ } 
+```
+
+¡Desde aquí, puedes hacer todo tipo de cosas interesantes, como manipular el vector o desordenar el orden que desees!
+
+### Algunas funciones útiles para miembros
+
+La biblioteca de plantillas estándar (STL) también proporciona diferentes _métodos_ para usted:
+
+```cpp
+std::vector.size(); // returns the size of the vector (the number of positions in the vector) 
+ std::vector.begin(); // returns an iterator which is a pointer to the beginning of the vector 
+ std::vector.end(); // returns an iterator which is a pointer to the end of the vector 
+ std::vector.empty(); // returns true if the vector is empty, otherwise returns false. 
+ std::vector.front(); // returns the first element of the vector. 
+ std::vector.back(); // returns the last element of the vector. 
+ std::vector.push_back(n); // inserts the element "n" to the end of the vector. 
+ std::vector.pop_back(n); // removes the last element of the vector 
+```
+
+### Iterador de vectores
+
+Los iteradores proporcionan otro método para acceder a los elementos en tu vector.
+
+Declaración del iterador.
+
+```cpp
+std::vector<int> v; 
+ //Iterator delcaration for the above vector will correspond to 
+ std::vector<int>::iterator it; 
+```
+
+Usando el iterador para imprimir elementos del vector usando for loop
+
+```cpp
+for(it=v.begin(); it!=v.end(); ++it) 
+ //std::vector::begin and std::vector::end return iterator pointing to first and last element of the vector respectively. 
+  cout<<*it; 
+```
+
+### Iterando a través de un vector
+
+Existen diferentes formas de iterar a través de un vector y acceder a sus contenidos. Las siguientes formas son equivalentes, la primera implica el uso de una expresión basada en rango (desde C ++ 11), la segunda utiliza iteradores y la última es una iteración basada en índices
+
+\`\` \`cpp
+
+# incluir
+
+# incluir
+
+// Primero declara el vector std :: vector myVector {1, 2, 3, 4, 5}; // a es un vector de 5 pulgadas: 1, 2, 3, 4 y 5
+
+// Usando un bucle basado en rango (desde C ++ 11) for (int element: myVector) {// Se lee como "para cada elemento en myVector" std :: cout << "El elemento es" << elemento << std :: endl; }
+
+// Usando un iterador std :: vector :: iterador it; // Declara el iterador para (it = myVector.begin (); it! = myVector.end (); ++ it) { std :: cout << "El elemento es" << \* it << std :: endl; // Dereferencia del iterador para acceder a sus datos. }
+
+// Usando índices para (std :: vector :: size\_type i = 0; i! = myVector.size (); i ++) { std :: cout << "El elemento es" << myVector \[i\] << std :: endl; // Dereferencia del iterador para acceder a sus datos. }
+```
+### Sorting A Vector In Ascending Order 
+ Sorting a vector based on ascending order can be done with the help of Sort() in C++. 
+```
+
+cpp
+
+# incluir
+
+# incluir
+
+# incluir
+
+utilizando namespace std;
+
+int main () {
+
+vector v {10, 5, 82, 69, 64, 70, 3, 42, 28, 0}; sort (v.begin (), v.end ());
+
+cout << "Contenido de vectores ordenados en orden ascendente: \\ n"; para (int e: v) { cout << e << ""; }
+
+devuelve 0; }
+```
+### Sorting Vector In Descending Order 
+ Sorting Vector in descending order can be done with the help of third argument namely greater<int>() in Sort() in C++. 
+```
+
+cpp
+
+# incluir
+
+# incluir
+
+# incluir
+
+utilizando namespace std;
+
+int main () {
+
+vector v {10, 5, 82, 69, 64, 70, 3, 42, 28, 0}; sort (v.begin (), v.end (), mayor ());
+
+cout << "Contenido de vectores ordenados en orden ascendente: \\ n"; para (int e: v) { cout << e << ""; }
+
+devuelve 0; } \`\` \`

guide/spanish/cplusplus/while-loop/index.md

@@ -0,0 +1,37 @@
+---
+title:While-loop
+localeTitle: undefined
+---
+Una instrucción de bucle while ejecuta repetidamente una instrucción de destino siempre que una condición dada sea verdadera.
+
+Sintaxis: while (condición) { declaración (es); }
+
+Un punto clave del bucle while es que tal vez el bucle no se ejecute nunca. Cuando se prueba la condición y el resultado es falso, se omitirá el cuerpo del bucle y se ejecutará la primera declaración después del bucle while.
+
+Ejemplo:
+
+```C++
+#include <iostream> 
+ using namespace std; 
+ 
+ int main () { 
+   // Local variable declaration: 
+   int a = 10; 
+ 
+   // while loop execution 
+   while( a < 20 ) { 
+      cout << "value of a: " << a << endl; 
+      a++; 
+   } 
+ 
+   return 0; 
+ } 
+```
+
+Salida:
+
+valor de a: 10 valor de a: 11 valor de a: 12 valor de a: 13 valor de a: 14 valor de a: 15 valor de a: 16 valor de a: 17 valor de a: 18 valor de a: 19
+
+### Fuentes
+
+www.tutorialspoint.com