fix(guide): simplify directory structure

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