fix(guide): simplify directory structure

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

@@ -0,0 +1,208 @@
+---
+title: Tokens Part 1
+localeTitle: Tokens Parte 1
+---
+### O que são tokens?
+
+Tokens são as menores unidades de um programa que são importantes para o compilador. Existem diferentes tipos de tokens:
+
+*   Palavras-chave
+    
+*   Operadores
+    
+*   Pontuadores
+    
+*   Literais
+    
+*   Identificadores
+    
+*   **Combinação de fichas forma uma expressão**
+    
+
+### O que são variáveis?
+
+*   Definição de livro de texto: As variáveis ​​são nomeadas locais de memória cujos dados podem ser alterados.
+    
+*   Mas eu gostaria que você pensasse em uma variável para ser algo como uma caixa, algo assim: ![Img](https://i.imgur.com/YdbgWHL.png)
+    
+
+Então, por exemplo: Estou mudando para um novo lugar e preciso arrumar minhas coisas em caixas. Assim, vêm 2 coisas para minha mente **Que tipo de material será armazenado na caixa, de modo que o tamanho da caixa seja conhecido (o tipo de dados)** e **Como eu identifico a caixa? (Nomeando a variável)**  
+Portanto, sabemos que uma variável em C ++ precisa de um _nome_ e um _tipo de dados_ e que o valor armazenado neles pode ser alterado.
+
+### Tipos de dados em C ++:
+
+Ao declarar variáveis ​​em c ++, elas devem ter um nome para o qual você irá referenciar mais tarde, um valor (constante ou não) e um tipo. O tipo informará ao compilador os valores que a variável pode usar, as operações possíveis e economizará um certo espaço no memmory. Em c ++ existem dois tipos de dados:
+
+*   Tipo simples
+*   Tipo de estrutura
+
+### Tipos de dados simples
+
+*   Booleano - bool Funciona como um interruptor, pode ser ligado ou desligado.
+*   Caráter - char Armazena um único caractere.
+*   Inteiro - int Armazena um [inteiro](https://en.wikipedia.org/wiki/Integer) .
+*   Ponto flutuante - flutuar Eles podem usar decimais.
+*   Duplo ponto flutuante - duplo Precisão dupla do tipo flutuante.
+
+Aqui você pode ver alguns exemplos:
+
+```cpp
+bool GameRunning = true; 
+ char a; 
+ int x = 2; 
+```
+
+#### Esses tipos também podem ser modificados com modificadores como:
+
+assinado sem assinatura curto longo
+
+### Tipo de dados de estrutura
+
+#### Identificadores
+
+*   Identificadores são os nomes dados a uma variável ou uma classe ou uma função ou qualquer função definida pelo usuário.
+
+## Regras para nomear uma variável:
+
+*   Comece a nomear com uma letra de AZ ou az.
+*   Os números podem seguir a primeira letra, mas não podemos começar a nomear com números.
+*   NÃO é permitido o uso de espaços ou caracteres especiais, em vez disso, use um UNDERSCORE \_.
+
+#### Declarando um variabe:
+
+A sintaxe é a seguinte < _tipo de dados_ > < _nome da variável_ >; ou < _tipo de dados_ > < _nome da variável_ > = < _valor_ >; se também quisermos inicializar a variável.
+
+Por exemplo : `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.`
+
+**Exemplos de declaração de uma variável:**
+
+```cpp
+int a9; 
+ char A; 
+ double area_circle; 
+ long l; 
+```
+
+**Formas erradas de declarar variáveis**
+
+```cpp
+int 9a; 
+ char -a; 
+ double area of circle; 
+ long l!!; 
+```
+
+*   Nomes variáveis ​​não podem começar com um número
+*   Caracteres especiais não são permitidos
+*   Espaços não são permitidos
+
+Você pode imaginar caixas diferentes de tamanhos diferentes e armazenar coisas diferentes como variáveis ​​diferentes.
+
+**NOTAS :**
+
+1.  **O compilador C ++ ignora os espaços em branco e eles geralmente são usados ​​para embelezar o código, de modo que seja fácil para qualquer programador depurar ou entender o código.**
+2.  **Se uma variável não for inicializada, ela contém um valor de lixo. Deixe-me dar um exemplo:**
+
+### Escopo das Variáveis
+
+Todas as variáveis ​​têm sua área de funcionamento, e fora desse limite elas não mantêm seu valor, esse limite é chamado de escopo da variável. Para a maioria dos casos é entre as chaves, em que a variável é declarada que existe uma variável, não fora dela. Vamos estudar as classes de armazenamento mais tarde, mas a partir de agora, podemos dividir as variáveis ​​em dois tipos principais,
+
+\*Variáveis ​​globais.
+
+\* Variáveis ​​locais.
+
+#### Variáveis ​​globais
+
+Variáveis ​​globais são aquelas que já foram declaradas e podem ser usadas durante toda a vida útil do programa por qualquer classe ou função. Eles devem ser declarados fora da função main (). Se apenas declarado, eles podem receber diferentes valores em diferentes momentos da vida útil do programa. Mas mesmo que eles sejam declarados e inicializados ao mesmo tempo fora da função main (), eles também podem receber qualquer valor em qualquer ponto do programa.
+
+Exemplo: Apenas declarado, não 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; 
+ } 
+```
+
+#### Variáveis ​​Locais
+
+Variáveis ​​locais são as variáveis ​​que existem apenas entre as chaves, nas quais são declaradas. Fora que eles estão indisponíveis e leva a erro de tempo de compilação.
+
+Exemplo:
+
+```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 
+ } 
+```
+
+### Variáveis ​​Constantes
+
+Variável constante são as variáveis ​​que não podem ser alteradas. Por exemplo, se você precisasse de "pi" em seu código, você não desejaria alterá-lo após a inicialização.
+
+Exemplo:
+
+```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 lixo em uma variável
+
+Se uma variável não for inicializada, ela contém um valor de lixo. Por exemplo:
+
+Então, em termos de caixas, você pode imaginar isso como -
+
+![Img](https://i.imgur.com/YdbgWHL.png)
+
+\`\` \`cpp #incluir usando namespace std; int main () { int a; cout << "Valor do lixo em a:" << a << endl; // declarando a variável chamada 'a' do tipo inteiro a = 5; // initializing variable. cout << "Novo valor em um" << a << endl;
+
+} \`\` \`
+
+### A saída é:
+```
+Garbage value in a : 0 
+ New value in a :  5 
+```
+
+Como você pode ver, já existe um valor armazenado em 'a' antes de atribuirmos um valor (aqui, é 0). Isso deve permanecer na mente de cada programador, de modo que, quando as variáveis ​​forem usadas, elas não criem um erro lógico e imprimam valores ilegíveis.
+
+[Experimente o código você mesmo! :)](https://repl.it/Mg7j)
+
+#### Palavras-chave :
+
+_Palavras-chave são palavras reservadas que transmitem um significado especial ao compilador. Eles **NÃO PODEM** ser usados ​​para nomear em c ++._ Exemplos de palavras-chave: inline, operador, privado int, duplo, vazio, char, modelo, usando, virtual, break, caso, switch, amigo, etc.
+
+**Cada uma dessas palavras-chave é usada para uma função especial em C ++.**
+
+_Tokens parte 1 acabou. Vejo vocês campistas na [Parte 2](https://guide.freecodecamp.org/cplusplus/tokens-part-II) de Tokens :)_
+
+**Boa sorte para todos vocês**
+
+**Codificação Feliz! :)**
+

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

@@ -0,0 +1,120 @@
+---
+title: Variables
+localeTitle: Variáveis
+---
+Vamos discutir algo conhecido como variáveis. Variáveis ​​são como um balde. Você pode colocar algo nele e depois alterá-lo depois, quando necessário. Em C ++, existem muitos tipos de variáveis ​​como Integers, Strings, Booleans e muitos outros. Vamos ver um programa simples usando variáveis ​​inteiras. Inteiros armazenam números inteiros positivos, negativos ou nulos. Números inteiros não são números fracionários, por exemplo, 1/2, 1/4 e 1/5. Vamos olhar para um programa simples que usa um inteiro variável.
+
+```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; 
+ } 
+```
+
+Quando você executa este programa, você verá 5 exibidos na tela
+
+*   Note que no programa acima, // é colocado depois das linhas. O símbolo "//" é para comentar nosso código. Código após o símbolo "//" não é executado na linha onde está colocado.
+    
+*   Na linha 5, uma variável inteira simples é declarada.
+    
+*   Na linha 6, o valor 5 é atribuído à variável a. Agora, sempre que usamos a variável a em nosso programa, seu valor será 5 a menos que nós o mudemos.
+    
+*   Na linha 7, exibimos o valor da variável ae 5 é impresso na tela.
+    
+
+### Escopo das Variáveis
+
+Todas as variáveis ​​têm sua área de funcionamento, e fora desse limite elas não mantêm seu valor, esse limite é chamado de escopo da variável. Para a maioria dos casos é entre as chaves, em que a variável é declarada que existe uma variável, não fora dela. Vamos estudar as classes de armazenamento mais tarde, mas a partir de agora, podemos dividir as variáveis ​​em dois tipos principais,
+
+\*Variáveis ​​globais.
+
+\* Variáveis ​​locais.
+
+#### Variáveis ​​globais
+
+Variáveis ​​globais são aquelas que já foram declaradas e podem ser usadas durante toda a vida útil do programa por qualquer classe ou função. Eles devem ser declarados fora da função main (). Se apenas declarado, eles podem receber diferentes valores em diferentes momentos da vida útil do programa. Mas mesmo que eles sejam declarados e inicializados ao mesmo tempo fora da função main (), eles também podem receber qualquer valor em qualquer ponto do programa.
+
+Exemplo: Apenas declarado, não 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;` 
+ } 
+```
+
+#### Variáveis ​​Locais
+
+Variáveis ​​locais são as variáveis ​​que existem apenas entre as chaves, nas quais são declaradas. Fora que eles estão indisponíveis e leva a erro de tempo de compilação.
+
+Exemplo:
+
+```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 
+ } 
+```
+
+Agora vamos ler sobre um novo tipo de variável
+
+#### Variável estática
+
+Variáveis ​​estáticas: quando uma variável é declarada como estática, o espaço para ela é alocado para o tempo de vida do programa. Mesmo que a função seja chamada várias vezes, o espaço para a variável estática é alocado apenas uma vez e o valor da variável na chamada anterior é realizado na próxima chamada de função. Isso é útil para implementar corrotinas em C / C ++ ou qualquer outro aplicativo em que o estado anterior da função precise ser armazenado. Em termos leigos, isso significa que uma variável normal quando sai do escopo perde sua identidade (valor), mas uma variável estática tem um escopo global e retém seu valor até o final do programa, mas ao contrário da variável global, não é necessário declará-lo no início do programa.
+
+#### EXTRA-
+
+Static é uma palavra-chave em C ++ usada para dar características especiais a um elemento. Elementos estáticos são alocados em armazenamento apenas uma vez na vida útil de um programa na área de armazenamento estático. E eles têm um escopo até a vida útil do 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; 
+ } 
+```
+
+#### Tente você mesmo
+
+basta copiar o código e colá-lo no link dado. Execute no IDE - https://ideone.com/
+
+Saída: 0 1 2 3 4
+
+Você pode ver no programa acima que a contagem de variáveis ​​é declarada como estática. Então, seu valor é realizado através das chamadas de função. A contagem de variáveis ​​não está sendo inicializada para cada vez que a função é chamada.
+
+Vamos experimentar o mesmo código removendo a palavra-chave "estática" e adivinhar a saída e compará-la com uma na IDE. A estática é agora convertida em variável normal