fix(guide): simplify directory structure

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

@@ -0,0 +1,23 @@
+InlocaleTitle: undefined
+troduction de conjuntos na biblioteca C ++ STL Conjuntos são um tipo de contêineres associativos nos quais cada elemento deve ser exclusivo. O valor do elemento não pode ser modificado depois que é adicionado ao conjunto, embora seja possível remover e adicionar o valor modificado desse elemento. Eles são implementados usando uma árvore vermelha e preta.
+
+Benefícios de usar conjuntos
+
+1.  Ele armazena apenas valores exclusivos.
+2.  O valor do elemento se identifica. O valor de um elemento também é a chave usada para identificá-lo.
+3.  Fornece uma pesquisa rápida (O (log n)) usando chaves, ou seja, o próprio elemento.
+4.  Existem muitas funções embutidas na classe que definem conjuntos que facilitam a programação.
+
+Exemplo: '' 'c ++
+
+# incluir
+
+usando namespace std; int main () { conjunto s;
+
+s.insert (2); // insere o elemento 2 no conjunto s s.insert (3); s.insert (5); s.insert (2); // inserindo o mesmo elemento 2 s.insert (6); para (auto i: s) cout << i << ""; cout << s.size () << endl; // dá o tamanho do conjunto
+
+s.erase (5); // apagando o elemento 5 do conjunto s return 0; } '' ' Criando um objeto definido '' 'c ++ conjunto s; '' '
+
+Inserção '' 'c ++ s.insert (valor _a ser_ inserido); '' '
+
+Acessando elementos do conjunto '' 'c ++ conjunto :: iterador; para (it = s.begin (); it! = s.end (); ++ it) cout << \* it; '' '

guide/portuguese/cplusplus/arrays/index.md

@@ -0,0 +1,42 @@
+---
+title: C++ Arrays
+localeTitle: Matrizes C ++
+---
+## O que são matrizes?
+
+Uma matriz é uma série de elementos do mesmo tipo de dados que são armazenados em locais de memória contígua e podem ser referenciados individualmente.
+
+Por exemplo, uma matriz contendo 5 valores inteiros chamados números é declarada da seguinte forma:
+
+```C++
+int numbers [5]; 
+```
+
+Inicialização:
+
+```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 
+```
+
+**Observe** que as matrizes em C ++ não são permutáveis ​​em tamanho, o que significa que, uma vez que você tenha declarado uma matriz com tamanho 5, ela não poderá ser ampliada ou diminuída. Caso você realmente precise de uma matriz maior com as mesmas entradas, você teria que copiar todas as entradas para uma nova matriz de tamanho maior.
+
+### Acesso:
+
+Elementos de uma matriz podem ser acessados ​​por referência de sua posição na matriz. (Comece a contar de 0).  
+Exemplo:
+
+```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/portuguese/cplusplus/casting/index.md

@@ -0,0 +1,88 @@
+---
+title: Casting
+localeTitle: Fundição
+---
+## Fundição
+
+Um elenco é um operador especial que força um tipo de dados a ser convertido em outro
+
+Fundindo em C ++ difere um pouco para isso de C. C ++ faz uso de funções de carcaça distintas.
+
+### static\_cast
+
+Elenco estático é usado para conversões implícitas entre primitivos e sobrecargas de tipos.
+
+### const\_cast
+
+Const cast pode ser usado para expulsar constância. Isso é útil quando há um desejo de alterar um valor constante. Isso deve ser usado com moderação, em vez disso, deve-se considerar a criação de parâmetros / funções não-constantes nos casos em que um const-cast é usado.
+
+Const cast também pode resultar em comportamento indefinido. A única aplicação do const cast deve ser remover a constância de um valor que foi passado para uma função e marcada const. Se o valor é verdadeiramente const, isto é, é marcado como const em tempo de compilação e é atribuído um valor, const cast e mutação da variável resultará em um comportamento indefinido.
+```
+const int y = 10;             // y is set to 10. 
+ const_cast<int &>(y) = 20;    // undefined behaviour. 
+```
+
+### dynamic\_cast
+
+A conversão dinâmica é usada para converter um objeto dentro de sua hierarquia de classes (para pai, pai e irmãos). O elenco dinâmico só pode ser chamado em classes polimórficas. Assim, a classe original neste caso `MyClass` deve ter um membro virtual, que está presente na forma do destruidor virtual.
+
+Se o elenco dinâmico falhar, ele retornará um `nullptr` . O elenco dinâmico pode ser útil na determinação de tipos de objetos em tempo de execução. No entanto, deve-se notar que a conversão dinâmica não é livre e, em alguns casos, outras técnicas podem se mostrar mais eficientes na determinação do tipo de classe em tempo de execução.
+
+### reinterpret\_cast
+
+Reinterpretar elenco é talvez o mais perigoso de todos os elencos C ++, mas quando usado corretamente, pode ser ideal. Reinterpretar conversão não incorre em custo de desempenho, pois não realiza conversões. Ele simplesmente instrui o compilador a tratar o objeto fundido como se fosse o tipo solicitado. Isso também pode trazer problemas de alinhamento, por isso deve ser usado com moderação e somente quando os efeitos colaterais são conhecidos e explicados.
+
+#### Uma nota em moldes de estilo C
+
+O C ++ suporta o uso de conversões no estilo C, embora elas não sejam recomendadas. O uso da conversão de estilo C instruirá o compilador a executar primeiro uma conversão estática _, se a conversão estática_ falhar, reinterpret\_cast será usado em seu lugar. Por esse motivo, os lançamentos no estilo C podem produzir resultados imprevisíveis e gerar problemas inesperados.
+
+## Exemplos
+
+```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/portuguese/cplusplus/clean-code-guidelines/index.md

@@ -0,0 +1,109 @@
+---
+title: Clean Code Guidelines
+localeTitle: Diretrizes de código limpas
+---
+# Diretrizes de código limpas
+
+Ao codificar, o estilo de codificação que você segue pode ser muito importante. Especialmente quando você está trabalhando com uma equipe ou planeja compartilhar código. A maioria dessas diretrizes é padrão e pode ser aplicada à maioria das linguagens de programação, no entanto, aqui você tem aplicativos e snippets com código c ++, para que você possa se familiarizar com isso mais facilmente. Lembre-se de que essas são apenas recomendações para obter clareza, o que pode ser uma preferência pessoal, portanto, siga estas dicas em conta, mas não os leve à letra. Às vezes, quebrar algumas dessas regras pode levar a um código mais limpo.
+
+## Use bons nomes de variáveis ​​e faça comentários
+
+Certifique-se de criar bons nomes de variáveis, por exemplo, se você estiver criando um jogo, evite usar a variável "a" use algo como "p1" referindo-se ao player 1. A [notação húngara](https://en.wikipedia.org/wiki/Hungarian_notation) é comumente distribuída e pode dar algumas orientações para declarar variáveis.
+
+Além disso, por favor, use comentários, eu não estou nem brincando, apenas tente ler alguns projetos antigos que você fez sem comentários ... agora imagine ser outra pessoa que nem mesmo o codificou.
+
+## Variáveis ​​globais
+
+As variáveis ​​globais podem ser fáceis de usar e, com pouco código, podem parecer uma ótima solução. Mas, quando o código fica cada vez maior, fica mais difícil saber quando estão sendo usados.
+
+Em vez de usar variáveis ​​globais, você poderia usar variáveis ​​declaradas em funções que podem ajudá-lo a informar quais valores estão sendo passados e identificar erros mais rapidamente.
+
+```cpp
+#include <iostream> 
+ using namespace std; 
+ 
+ // Global variables are declared outside functions 
+ int cucumber; // global variable "cucumber" 
+```
+
+## Usando goto, continue, etc.
+
+Esta é uma discussão usual entre os programadores, assim como as variáveis ​​globais, esses tipos de declarações são geralmente consideradas más práticas. Eles são considerados ruins porque levam ao ["código spaguetti"](https://en.wikipedia.org/wiki/Spaghetti_code) . Quando programamos, queremos um fluxo linear, ao usar essas instruções, o fluxo é modificado e leva a um fluxo "torcido e emaranhado".
+
+Goto foi usado no passado quando, enquanto, por, se funciona, no entanto, com a introdução desses programas estruturados foi criado. Em geral, evite usar o goto, a menos que tenha certeza de que ele tornará seu código mais limpo e mais fácil de ler. Um exemplo pode ser usá-lo em loops aninhados.
+
+O uso de break e continue é praticamente o mesmo. Use-os em switches e tente fazer funções com um único propósito, para que você tenha apenas um ponto de saída.
+
+![img](https://imgs.xkcd.com/comics/goto.png)
+
+## Evite alterar a variável de controle dentro de um loop for
+
+Geralmente há trabalhos em torno disso que parecem mais claros e menos confusos, por exemplo. enquanto loops. Faz:
+
+```cpp
+int i=1; 
+ while (i <= 5) 
+ { 
+    if (i == 2) 
+        i = 4; 
+ 
+    ++i; 
+ } 
+```
+
+Ao invés de:
+
+```cpp
+for (int i = 1; i <= 5; i++) 
+ { 
+    if (i == 2) 
+    { 
+       i = 4; 
+    } 
+    // Do work 
+ } 
+```
+
+## Declarar constantes e tipos no topo
+
+Eles geralmente são declarados após as bibliotecas, o que os torna mais próximos e mais fáceis de ler. Para variáveis ​​locais, acontece o mesmo, declare-os no topo (outras pessoas preferem declará-los o mais tarde possível para economizar memória veja: [cplusplus.com](http://www.cplusplus.com/forum/general/33612/)
+
+## Use apenas uma função de retorno no final
+
+Assim como dissemos antes, tendemos a fazer apenas uma entrada e sair para deixar o fluxo mais claro.
+
+## Use chaves até mesmo ao escrever uma linha
+
+Fazê-lo sistematicamente irá ajudá-lo a fazê-lo mais rápido e no caso de você querer mudar o código no futuro, você será capaz de fazê-lo sem preocupações.
+
+Ao invés de:
+
+```cpp
+for (int i = 1; i <= 5; i++) 
+    //CODE 
+```
+
+Faz:
+
+```cpp
+for (int i = 1; i <= 5; i++) 
+ { 
+    //CODE 
+ } 
+```
+
+## Outras recomendações
+
+*   #### Use para quando você sabe o número de iterações, enquanto e quando você não sabe.
+    
+*   #### Use const, passe por valor / referência quando adequado. Isso ajudará a economizar memória.
+    
+*   \#### Escreve const em letras maiúsculas, tipos de dados que começam com T e variáveis ​​em letras minúsculas.
+    
+
+```cpp
+const int MAX= 100;             //Constant 
+ typedef int TVector[MAX];       //Data type 
+ TVector vector;                 //Vector 
+
+```

guide/portuguese/cplusplus/compilers/index.md

@@ -0,0 +1,55 @@
+---
+title: C++ Compilers
+localeTitle: Compiladores C ++
+---
+# Introdução aos Compiladores C ++
+
+Para começar com C ++, você precisará aprender um pouco sobre compiladores e como o C ++ é executado em seu computador.
+
+Quando tudo estiver dito e feito, os computadores só entendem uma linguagem, linguagem de máquina. Linguagem de máquina é inteiramente composta de bits binários, ou 0s e 1s. Embora seja possível programar em binário, seria extremamente tedioso e demorado. Então, nós humanos desenvolvemos linguagens de programação para facilitar o desenvolvimento de software. Linguagem de montagem é um direto de 1 para 1 com a máquina língua. Idiomas como C, C ++ e COBOL são um pouco mais altos e precisam ser compilados. Vai ainda mais alto. línguas como JavaScript e Python tem componentes que são traduzidos para C ++ ou outras linguagens de baixo nível antes de serem compiladas, efetivamente tornando-os linguagens "superiores" que C ou C ++. Como a arquitetura de computadores é composta de switches e cabos eletrônicos que só podem funcionar com 1s e 0s binários, você precisa de um compilador para traduzir seu código de alto nível C ++ para linguagem de máquina que a CPU possa entender.
+
+Compiladores são programas utilitários que pegam seu código e o transformam em arquivos executáveis ​​de código de máquina. Quando você executa um compilador no seu código, primeiro, o pré-processador lê o código-fonte (o arquivo C ++ que você acabou de escrever). O pré-processador procura por qualquer diretivas de pré-processador (linhas de código iniciando com #). As diretivas de pré-processador causam pré-processador para alterar seu código de alguma forma (geralmente adicionando alguma biblioteca ou outro arquivo C ++). Em seguida, o compilador trabalha através do código pré-processado linha por tradução de linha cada linha na instrução de linguagem de máquina apropriada. Isso também revelará os erros de sintaxe que estão presentes no seu código-fonte e lançará um erro na linha de comando. Finalmente, se nenhum erro estiver presente, o compilador cria um objeto arquivo com o binário de linguagem de máquina necessário para executar em sua máquina. Enquanto o arquivo objeto que o compilador acabou de criar é provável o suficiente para fazer algo no seu computador, ainda não é um executável de trabalho do seu programa C ++. Existe uma final passo importante para chegar a um programa executável.
+
+C ++ contém uma vasta biblioteca para auxiliar na execução de tarefas difíceis, como E / S e manipulação de hardware. Você pode incluir esses bibliotecas com diretivas de pré-processador, mas o pré-processador não as adiciona automaticamente ao seu código. Para você ter um programa executável final, outro utilitário conhecido como o vinculador deve combinar seus arquivos de objeto com as funções de biblioteca necessário para executar o código. Pense nisso como tendo todos os blocos necessários para construir uma casa. O compilador fez todos os blocos, mas o linker é o que os une para finalmente criar uma casa. Feito isso, agora você tem um arquivo executável em funcionamento!
+
+## Como compilar um arquivo
+
+Digamos que você tenha um arquivo C ++ chamado `helloWorld.cpp` …
+
+### Se você está no Windows -
+
+#### Usando e IDE como CodeBlocks
+
+É tão simples quanto clicar nos botões build e run, eles irão criar um arquivo na pasta do projeto. ![img](https://i.imgur.com/FwZuFGy.png)
+
+#### Usando o prompt de comando
+
+1.  Abrir um Prompt de Comando do Desenvolvedor - Para esta etapa, você precisará ter o Microsoft Visual Studio ou algum outro IDE permite que você compile seu programa a partir da linha de comando. Você também pode pesquisar online por compiladores C ++.
+    
+2.  Navegue até o código-fonte diretamente
+    
+3.  Execute o compilador no seu código-fonte (supondo que você esteja usando o compilador do Microsoft Visual Studio) `cl /EHsc helloWorld.cpp`
+    
+
+Isso agora criará um arquivo de objeto e o vinculará automaticamente para você. Se você olhar na mesma pasta, verá um O arquivo executável hellWorld.exe (observe a extensão exe) agora está presente.
+
+4.  Digite `helloWorld` no prompt para executar o executável
+
+Alternativamente, muitos IDEs permitem a criação e visualização rápida de seu programa. Isso pode ser mais fácil, já que sua versão do O Windows pode não vir pré-empacotado com um utilitário de compilação.
+
+### Se você está no Linux ou OSX -
+
+1.  Abra uma janela de terminal e navegue até o diretório do código-fonte
+2.  Execute o compilador no seu código-fonte `g++ helloWorld.cpp -o helloWorld`
+
+Isso criará um arquivo de objeto e o vinculará automaticamente para você. Olhe na pasta e você verá um helloWorld.exe arquivo executável (observe a extensão exe).
+
+3.  Digite `./helloWorld` na janela do terminal para executar o arquivo executável
+
+g ++ é o compilador padrão do Linux e é um ótimo utilitário. Vem embalado com o sistema operacional.
+
+NOTA: para compilar e executar seu código diretamente, execute `g++ -o helloWorld helloWorld.cpp; ./helloWorld` então quando você precisar compilar e executar seu código várias vezes, seta para cima
+
+* * *
+
+Existem vários tipos diferentes de compiladores. Os dois listados são os dois que geralmente são empacotados com o Windows ou Linux / OSX.

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

@@ -0,0 +1,44 @@
+---
+title: Conditional Operator
+localeTitle: Operador Condicional
+---
+## Operador Condicional
+
+O operador condicional é um operador ternário, ou seja, ele precisa de 3 operandos. Ele retorna um dos dois valores dependendo do resultado de uma expressão O operador condicional é usado para substituir uma instrução if-else simples.
+
+Sintaxe:
+
+```cpp
+  (condition)?(expression-1):(expression-2); 
+```
+
+Aqui, a expressão-1 é avaliada quando a condição é verdadeira e a expressão-2 é avaliada quando a condição é falsa. Declaração if-else semelhante seria:
+
+```cpp
+if(condition) 
+  { 
+    expression-1; 
+  } 
+ else 
+  { 
+    expression-2; 
+  } 
+```
+
+Portanto, o operador condicional é muito útil quando você precisa escrever instruções if-else simples. Também pode ser usado em #define pré-processador quando uma condição semelhante é usada em vários locais.
+
+Por exemplo, para encontrar o máximo de dois operadores condicionais numéricos pode ser usado da seguinte forma:
+
+```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 
+```
+
+**Boa sorte para todos vocês**
+
+**Codificação Feliz! :)**
+
+**Sinta-se à vontade para fazer qualquer pergunta sobre a página GitHub do [FreeCodeCamp](https://forum.freecodecamp.org/) ou [sobre o Fórum do FreeCodeCamp.](https://forum.freecodecamp.org/)**

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

@@ -0,0 +1,43 @@
+---
+title: do while loop
+localeTitle: fazer loop while
+---
+## Do While Loop
+
+O `do while loop` é quase o mesmo que o loop while. O `do while loop` tem o seguinte formato:
+
+```cpp
+do 
+ { 
+  // do something; 
+ } while(expression); 
+```
+
+Nota: Lembre-se de usar um ponto e vírgula ';' no final da condição.
+
+## Detalhes sobre o loop do-while
+
+O loop do-while é usado sempre que você tem certeza de que um determinado processo (dentro do loop) deve ser executado pelo menos uma vez. Ele tem muitas vantagens, como não inicializar a variável de verificação (por exemplo, char addmore = 'Y') etc. O ponto e vírgula no final do tempo é uma obrigação.
+
+Faça algo primeiro e depois teste se tivermos que continuar. O resultado é que o bloco do é executado pelo menos uma vez. (Porque o teste de expressão vem depois). Dê uma olhada em um exemplo:
+
+```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/portuguese/cplusplus/dynamic-memory-allocation/index.md

@@ -0,0 +1,40 @@
+---
+title: Dynamic Memory Allocation
+localeTitle: Alocação Dinâmica de Memória
+---
+## Alocação de Memória Dinâmica em C ++
+
+### O que é alocação dinâmica de memória em C ++?
+
+*   **Alocação de memória** em C ++ refere-se à memória alocada para as variáveis ​​que você usa em todo o seu programa.
+*   **Alocação de Memória Dinâmica** é a memória que é atribuída às variáveis ​​no tempo de execução e a quantidade de memória requerida também é decidida no tempo de execução.
+*   Essa memória vem do **heap** , enquanto variáveis _não estáticas_ e variáveis _locais_ obtêm memória da **pilha** .
+*   Em C ++, o programador pode executar alocações de memória manualmente e é chamado como **_alocação de memória dinâmica_** .
+*   Era possível em C fazer alocação de memória dinâmica, usando _funções calloc_ e _malloc_ para alocar memória e usar função _livre_ para desalocar a memória dinâmica.
+*   Em C ++, além de acima, há duas funções, _new_ e _delete_ para executar alocação de memória dinâmica e desalocação.
+
+### NOVO operador
+
+*   `new` operador pode conceder a memória do programador do heap (se disponível). Se a memória solicitada pelo programador estiver disponível, o `new` operador inicializa a memória e retorna o endereço (referência) da memória alocada.
+*   **Sintaxe**  
+    `pointer-variable-type` = **novo** `data-type;`  
+    Exemplo 1: `int *ptr` = **new** `int;`  
+    Exemplo 2: `int *ptr2` = **new** `int[10];`  
+    Aqui, `pointer-variable-type` é um **ponteiro** de `data type` de `data type` . O `data-type` pode ser int, char, etc. ou tipo de dados definido pelo usuário.
+
+### Operador DELETE
+
+*   É responsabilidade do programador des-alocar a memória alocada dinamicamente, caso contrário a memória não estará disponível para ser reatribuída até o final do programa.
+    
+*   Para desalocar a memória, o operador `delete` está disponível e pode ser usado pelo programador.
+    
+*   **Sintaxe**  
+    **delete** `pointer-type-variable;`  
+    Por exemplo, para liberar a memória alocada no exemplo 1 acima, nós digitamos:  
+    `delete ptr;`  
+    Da mesma forma, por exemplo 2, a memória pode ser liberada por:  
+    `delete ptr2` ;
+    
+    ### Perdas de memória
+    
+    Os vazamentos são causados ​​quando você não consegue desalocar a memória dinâmica alocada por meio do operador `New` no final do programa. Se você não desalocá-lo com o operador Excluir, seu computador continuará criando nova memória no heap toda vez que o programa for executado. Isso faz com que o computador fique lento porque a memória não é excluída e a memória disponível diminui.

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

@@ -0,0 +1,88 @@
+---
+title: Erase–remove idiom
+localeTitle: Apagar - remover idioma
+---
+## Descrição
+
+Como remover elementos do container é uma pergunta comum da entrevista C ++, para que você possa ganhar alguns pontos de brownie, se você ler esta página cuidadosamente. A expressão apagar e remover é uma técnica de C ++ para eliminar elementos que preenchem um determinado critério de um contêiner. No entanto, é possível eliminar elementos com o tradicional loop escrito à mão, mas o idioma apagar-remover tem várias vantagens.
+
+### Comparação
+
+```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 você pode ver, o código com loop escrito à mão requer um pouco mais de digitação, mas também tem um problema de desempenho. Cada chamada de `erase` tem que avançar todos os elementos após o apagado, para evitar "lacunas" na coleção. A chamada `erase` várias vezes no mesmo container gera muita sobrecarga de movimentação dos elementos.
+
+Por outro lado, o código com o idioma apagar-remover não é apenas mais expressivo, mas também é mais eficiente. Primeiro, use `remove_if/remove` para mover todos os elementos que não se encaixam nos critérios de remoção para a frente do intervalo, mantendo a ordem relativa dos elementos. Então, depois de chamar `remove_if/remove` , uma única chamada de `erase` exclui todos os elementos restantes no final do intervalo.
+
+### Exemplo
+
+```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 
+ */ 
+```
+
+### Fontes
+
+"Erase – remove idiom" Wikipedia: A enciclopédia livre. Wikimedia Foundation, Inc. [en.wikipedia.org/wiki/Erase-remove\_idiom](https://en.wikipedia.org/wiki/Erase%E2%80%93remove_idiom)
+
+Meyers, Scott (2001). STL Efetivo: 50 Formas Específicas de Melhorar o Uso da Biblioteca de Modelos Padrão. Addison-Wesley.

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

@@ -0,0 +1,49 @@
+---
+title: Error Handling
+localeTitle: Tratamento de erros
+---
+# Manipulação de exceção de C ++
+
+Uma exceção é um problema que surge durante a execução de um programa. As exceções fornecem uma maneira de transferir o controle de uma parte de um programa para outra. O tratamento de exceções do C ++ é construído sobre três palavras-chave: #try, #catch e #throw.
+
+*   # throw - Um programa gera uma exceção quando um problema é exibido. Isso é feito usando uma palavra-chave throw.
+    
+*   # catch - Um programa captura uma exceção com um manipulador de exceção no local em um programa onde você deseja lidar com o problema. A palavra-chave catch indica a captura de uma exceção.
+    
+*   #try - Um bloco try identifica um bloco de código para o qual exceções específicas serão ativadas. É seguido por um ou mais blocos 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 você ir ...
+
+## Uma revisão
+
+*   Agrupamento de tipos de erros.
+*   Separação de código de tratamento de erros do código normal.
+*   Funções / métodos podem manipular quaisquer exceções que escolherem.

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

@@ -0,0 +1,91 @@
+---
+title: For Loop
+localeTitle: Para loop
+---
+Um For Loop é uma instrução repetitiva que é usada para verificar alguma condição e, em seguida, com base na condição, um bloco de código é executado repetidamente até que a condição especificada seja satisfeita.
+
+O loop for é distinguido de outras instruções de loop através de um contador de loop explícito ou uma variável de loop que permite que o corpo do loop saiba o seqüenciamento exato de cada iteração.
+
+Portanto, um loop for é uma estrutura de controle de repetição que permite escrever com eficiência um loop que precisa executar um número específico de vezes.
+
+## Sintaxe
+```
+for ( init; condition; increment ) { 
+   statement(s); 
+ } 
+```
+
+É permitido colocar o incremento dentro do loop for como em um loop while. Ou seja, uma sintaxe como essa também pode funcionar.
+```
+for ( init; condition;) { 
+   statement(s); 
+   increment; 
+ } 
+```
+
+### nisso
+
+Esta etapa permite declarar e inicializar qualquer variável de controle de loop. Essa etapa é executada primeiro e apenas uma vez.
+
+### condição
+
+Em seguida, a condição é avaliada. Se for verdade, o corpo do loop é executado. Se for falso, o corpo do loop não é executado e o fluxo de controle pula para a próxima iteração (repetição de um processo).
+
+### atualizar
+
+A instrução de atualização é usada para alterar a variável de loop usando operações simples como adição, subtração, multiplicação ou divisão. A instrução de atualização é executada após a execução do corpo do loop.
+
+## IMPLEMENTAÇÃO:
+
+```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 usando namespace std;
+
+int main () { // Single line for loop para (int a = 10; a <20; a = a + 1) cout << "valor de a:" << a << endl;
+
+return 0; } \`\` \`
+
+Isso geraria a mesma saída do programa anterior. ou seja Saída: valor de: 10 valor de um: 11 valor de: 12 valor de: 13 valor de a: 14 valor de: 15 valor de um: 16 valor de: 17 valor de um: 18 valor de um: 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: container) afirmações); }
+
+int \[5\] array = {1, 2, 3, 4, 5} para (int i: array) cout << i << endl; }
+
+Saída: 1 2 3 4 5 \`\` \`

guide/portuguese/cplusplus/functions/index.md

@@ -0,0 +1,59 @@
+---
+title: Functions in C++
+localeTitle: Funções em C ++
+---
+## Definição:
+
+Uma função é um grupo de instruções que juntas executam uma tarefa. Todo programa C ++ tem pelo menos uma função, que é main ().
+
+Uma declaração de função informa ao compilador sobre o nome de uma função, tipo de retorno e parâmetros. Uma definição de função fornece o corpo real da função.
+
+## A forma geral de uma definição de função C ++:
+
+```cpp
+return_type function_name( parameter list ) 
+ { 
+   body of the function 
+ } 
+```
+
+### Tipo de retorno:
+
+Uma função pode retornar um valor. O _tipo de_ retorno _é o tipo de dados do valor que a função retorna. Algumas funções executam as operações desejadas sem retornar um valor. Nesse caso, o_ tipo de _retorno_ é a palavra-chave void.
+
+### Nome da função:
+
+Este é o nome real da função. O nome da função e a lista de parâmetros juntos constituem a assinatura da função.
+
+### Parâmetros:
+
+Um parâmetro é como um marcador de posição. Quando uma função é chamada, você passa um valor para o parâmetro. Este valor é referido como parâmetro ou argumento real. A lista de parâmetros refere-se ao tipo, ordem e número dos parâmetros de uma função. Parâmetros são opcionais; isto é, uma função pode não conter parâmetros.
+
+### Corpo da função:
+
+O corpo da função contém uma coleção de instruções que definem o que a função faz.
+
+## Exemplo:
+
+```cpp
+int max(int num1, int num2) 
+ { 
+   // local variable declaration 
+   int result; 
+ 
+   if (num1 > num2) 
+      result = num1; 
+   else 
+      result = num2; 
+ 
+   return result; 
+ } 
+```
+
+## Por que as funções são importantes?
+
+As funções suportam a modularidade (decomposição do trabalho em partes menores chamadas módulos), que é uma característica essencial da OOP que separa principalmente C ++ de C. Ter funções específicas para executar tarefas específicas elimina a confusão e reduz o tamanho da função principal. A função também executa a capacidade de reutilização do código. Então, da próxima vez que você tiver que calcular o máximo de dois números diferentes antes e novamente no mesmo programa, você não precisa copiar e colar seu código. Você só tem que chamar a função e faz o resto do trabalho.
+
+## Mais Informações
+
+*   [TutorialsPoint](https://www.tutorialspoint.com/cplusplus/cpp_functions.htm)

guide/portuguese/cplusplus/goto/index.md

@@ -0,0 +1,27 @@
+---
+title: goto as a powerful utility
+localeTitle: goto como um poderoso utilitário
+---
+# Introdução ao uso de goto e rótulos
+
+goto é uma das mais poderosas e subestimadas partes da lógica em c ++. Uma quantidade louca de otimização pode ser obtida usando o goto, desde que seja usado corretamente. Faz aquilo que é chamado como. Vai para a ocorrência mencionada do próximo rótulo, onde quer que esteja.
+
+# Terminologia
+```
+goto - The keyword used to go to the particular label. 
+ label - this can be named anything. 
+```
+
+# sintaxe
+
+goto ;
+
+(sem o <>);
+
+// Isso leva o exe para a próxima aparição do rótulo.
+
+goto é algo que transcende todos os loops.Para ser mais claro sobre este ponto, aqui está um exemplo.
+
+https://code.sololearn.com/cI4qqQA8W2q3
+
+No entanto, deve-se tomar cuidado ao usar o goto com muito cuidado, especialmente nos primeiros dias de codificação, pois isso pode levar a problemas malucos, se não for bem compreendido.

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

@@ -0,0 +1,192 @@
+---
+title: If-Else Statement
+localeTitle: Declaração If-Else
+---
+## O que faz uma declaração If-Else?
+
+*   A instrução If-Else é uma extensão da instrução If simples.
+*   Na declaração if simples, se o valor da expressão de teste for falso, então pulamos o código do bloco e continuamos com nossa próxima instrução.
+*   Porém, muitas vezes, queremos executar determinadas etapas se o valor da expressão de teste for falso.
+*   Em tais casos, usamos a instrução if-else.
+
+### Formulário Geral da Declaração 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 
+ } 
+```
+
+### Exemplo de declaração If-Else
+
+Se a expressão de teste for verdadeira:
+
+```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 
+```
+
+Se a expressão de teste for 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 
+```
+
+### Exemplo em 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; 
+ } 
+```
+
+#### Saída
+
+*   Quando um número positivo é inserido:
+```
+Enter a number: 
+ 4 
+ You entered a positive number: 4 
+ This step is always printed 
+```
+
+*   Quando um número negativo é inserido:
+```
+Enter a number: 
+ -200 
+ You entered a negative number: -200 
+ This step is always printed 
+```
+
+[Experimente o código você mesmo](https://repl.it/MzBq)
+
+# **Sinta-se à vontade para fazer qualquer pergunta sobre a página GitHub do [FreeCodeCamp](https://forum.freecodecamp.org/) ou [sobre o Fórum do FreeCodeCamp.](https://forum.freecodecamp.org/)**
+
+[Experimente o código você mesmo](https://repl.it/MzBq)
+
+### Uso de if… else if… else ladder
+
+Se tivermos que tomar decisões com base em mais de uma condição usando if mais. Nós usamos mais se a condição da seguinte forma -
+
+```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; 
+ } 
+```
+
+#### Saída
+```
+Enter your score: 
+ 85 
+ Good performance 
+```
+
+### Outro exemplo de if… else if… else ladder
+
+Suponha que o usuário tenha inserido dois números e vamos exibir se um dos números for maior que o outro. E se nenhum dos dois é maior que o outro, então imprimimos a declaração "Ambos são iguais".
+
+Neste scinerio nós precisaremos de uma declaração if… else if… else ladder. O programa ficará assim:
+```
+#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; 
+ } 
+```
+
+#### Saída
+```
+Enter first number: 
+ 85 
+ Enter second number: 
+ 86 
+ Number 2 is greater. 
+```
+
+*   Observe que o programa só verificará a condição 'else if' quando a condição inicial 'if' não for satisfeita. E se nenhuma dessas condições for satisfeita, o último bloco 'else' será executado, imprimindo a declaração: "Ambos os números são iguais".
+    
+*   O tamanho da escada if… else if… else pode variar dependendo do problema que o programa está tentando resolver e do número de condições que precisam ser verificadas.
+    
+
+**Boa sorte para todos vocês**
+
+**Codificação Feliz! :)**
+

guide/portuguese/cplusplus/index.md

@@ -0,0 +1,103 @@
+---
+title: C++
+localeTitle: C ++
+---
+# Olá Mundo! - Seu primeiro programa C ++
+
+## O que é o C ++?
+
+*   C ++ é uma linguagem de programação de uso geral que tem sido usada desde a década de 1990
+    
+*   Foi projetado por Bjarne Stroustrup sob o nome "C com classes".
+    
+*   É uma versão do C que inclui elementos orientados a objetos, incluindo classes e funções.
+    
+*   É considerada uma das maiores linguagens de programação, como você pode ver na imagem a seguir: ![Img](http://static1.businessinsider.com/image/59deb30392406c21008b6148-1200/for-bonus-points-heres-the-chart-showing-these-languages-relative-popularity.jpg) _fonte: Github_
+    
+
+### Seu primeiro programa em C ++
+
+```cpp
+#include <iostream> 
+ using namespace std; 
+ int main() 
+ { 
+    cout << "Hello World" << endl; 
+    return 0; 
+ } 
+```
+
+#### A saída deste programa será simplesmente:
+```
+Hello World! 
+```
+
+Agora, vamos detalhar o código:
+
+#### Linhas 1 e 2
+
+```cpp
+#include <iostream> 
+ using namespace std; 
+```
+
+*   A primeira linha informa ao computador para usar o arquivo de cabeçalho "iostream" para este programa específico. Um arquivo de cabeçalho é um arquivo separado com código C ++ pré-escrito. Existem muitos outros arquivos de cabeçalho que são necessários para que um programa específico seja executado corretamente. Alguns deles são: matemática, vetor e string. Arquivos de cabeçalho geralmente são representados por uma extensão ".h" (você não precisa adicionar .h ao incluir arquivos de biblioteca padrão C ++)
+*   `iostream` significa fluxo de entrada-saída. O arquivo "iostream" contém código para permitir que o computador receba entrada e gere uma saída, usando a linguagem C ++.
+*   A segunda linha diz ao computador para usar o namespace padrão que inclui recursos do C ++ padrão. Você poderia escrever este programa sem esta linha, mas você teria que usar `std::cout` vez de `cout` e `std::endl` vez de `endl` na linha 4. Isso torna o código mais legível e nossa vida como programadores mais fácil.
+
+#### Linha 3 e 4
+
+```cpp
+int main() 
+ { 
+```
+
+*   C ++ inicia a execução de um programa a partir da função -main- `int main()` . Durante a execução, o computador começa a executar o código de cada linha de `{` (colchete de abertura) até `}` (colchete de fechamento) **NOTA: Cada função começa com uma chave de abertura "{" e termina com uma chave de fechamento "}".**
+*   A linha 4 indica o início da função main ().
+
+#### Linhas 5, 6 e 7
+
+```cpp
+    cout << "Hello World" << endl; 
+    return 0; 
+ } 
+```
+
+*   A palavra `cout` em C ++ é usada para saída.
+*   É seguido por `<<` , o _operador de inserção_ .
+*   O que quer que esteja entre as aspas duplas `""` é impresso. Certos caracteres especiais têm uma sintaxe diferente para instruções de impressão
+*   Agora, para imprimir qualquer outro tipo de dados, você precisa adicionar `<<` .
+
+**_Desafio: Tente mudar o Hello World para qualquer outra frase ou palavra (s). Qual será o resultado?_**
+
+*   `endl` é uma palavra reservada ao usar a linguagem C ++ para **finalizar esta linha e ir para a próxima linha durante a saída** . - _cout significa "saída do console"_
+*   Finalmente, termine o comando com um ponto `;` vírgula `;` .
+
+**OBSERVAÇÃO: Todos os comandos, exceto a definição da função principal e a diretiva #include, precisam ser finalizados pelo ponto-e-vírgula. Sem um ";" , você pode encontrar um erro.**
+
+*   `return 0;` com segurança termina a função atual ou seja, 'main ()' neste caso e desde que nenhuma função segue após 'main ()' o programa é encerrado.
+*   Não se esqueça de informar ao computador que este é o fim da função main (). Para fazer isso, você adiciona a chave de fechamento "}". Você encontrará um erro antes da execução do programa se você não incluir o **}** .
+
+### O código deve ser algo como isto:
+
+![Img](https://i.imgur.com/d1liGwI.png)
+
+Os programadores usam um programa Hello World (como este) como um ritual no uso de uma nova linguagem de programação. É um símbolo de boa sorte.  
+_Você terminou de codificar seu primeiro programa C ++ e entendeu a maior parte do código que você escreveu / digitou. PARABÉNS!_
+
+**Boa sorte para todos vocês e feliz codificação! :)**
+
+**Codificação Feliz! :)**
+
+**Sinta-se à vontade para fazer qualquer pergunta na página do GitHub do [FreeCodeCamp](https://forum.freecodecamp.org/) ou [no Fórum do FreeCodeCamp.](https://forum.freecodecamp.org/)**
+
+[Tente você mesmo ! :)](https://repl.it/L4k3)
+
+**Você pode precisar de algum software para escrever e executar o código C ++. Eu recomendo usar CodeBlocks. Há um link de download abaixo:**
+
+Download Link: [Download Aqui](http://www.codeblocks.org/downloads/26)
+
+*   Clique no link com o compilador GNU / GCC para windows. Isso não exigirá uma instalação adicional
+
+Outras alternativas podem ser o visual studio, usando um compilador ou um IDE on-line como o Cloud9 ou o repl.it
+

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

@@ -0,0 +1,80 @@
+---
+title: Inline Function
+localeTitle: Função Inline
+---
+# Função Inline
+
+## Introdução
+
+A função Inline é uma função especial definida em C ++ e é expandida em linha quando é chamada.
+
+Agora, o que isso significa exatamente?
+
+Sempre que uma função é chamada, é preciso muito tempo extra para executar uma série de atividades, como saltar para a função, salvar registros, empurrar argumentos para a pilha e retornar à função de chamada. Então leva muito tempo. Mas uma função inline é uma função na qual o compilador foi solicitado a executar uma expansão inline. Onde a função solicita ao compilador para inserir o corpo completo da função em cada lugar que a função é chamada, em vez de gerar código para chamar a função em um local é definido.
+
+No entanto, não podemos garantir que todas as funções declaradas em linha sejam inline. Porque quando declaramos uma função como `inline` , é um pedido, não um comando. Compilador pode ignorar o pedido de inlining nas seguintes situações: - 1) Se a função contém loop, por exemplo, `for` loop, `while` loop, `do-while` loop etc. 2) Se a função contiver um `switch` ou instrução `goto` . 3) Se a função não retornar nada, mesmo se o tipo de retorno (diferente de `void` claro) for mencionado. 4) Se a função contiver uma variável estática. 5) Se a função contiver uma chamada recursiva.
+
+\`\` \`c ++
+
+## sintaxe: -
+
+inline return _type_ nome da _função_ (argument\_list) {
+
+// corpo da função
+
+}
+```
+## 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
+
+usando namespace std;
+
+class 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 << "Adição é:" << obj.add (34,12) << <"\\ n"; cout << "Divisão é:" << obj.div (12.3.4) << "\\ n";
+
+return 0;
+
+} \`\` \`
+
+## Vantagens da função Inline
+
+*   Ele salva a sobrecarga da chamada de retorno de uma função.
+*   Aumenta a localidade de referência utilizando o cache de instruções.
+*   Acelera o seu programa, evitando overheads de chamadas de funções.
+*   Ele economiza sobrecarga de variáveis ​​de operações push / pop na pilha, quando as chamadas de função acontecem.
+*   É possível colocar uma definição de função em um arquivo de cabeçalho, isto é, ela pode ser incluída em várias unidades de compilação, sem que o vinculador se queixe.
+
+## Desvantagens da função inline
+
+*   Quando usado em um cabeçalho, torna o seu arquivo de cabeçalho maior com informações que os usuários não se importam.
+*   Aumenta o tamanho do executável devido à expansão do código.
+*   Inline C ++ é resolvido em tempo de compilação. O que significa que se você alterar o código da função inline, você precisaria recompilar todo o código usando-o para ter certeza de que ele será atualizado.
+*   Como mencionado acima, aumenta o tamanho do executável, o que pode causar uma surra na memória. Mais número de falhas de página, reduzindo o desempenho do seu programa.

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

@@ -0,0 +1,119 @@
+---
+title: Inline Functions in C++
+localeTitle: Funções Inline em C ++
+---
+## Funções Inline em C ++
+
+Quando o programa executa a instrução de chamada de função, a CPU armazena o endereço de memória da instrução após a chamada de função, copia os argumentos da função na pilha e, finalmente, transfere o controle para a função especificada. A CPU então executa o código de função, armazena o valor de retorno da função em um local / registro de memória predefinido e retorna o controle para a função de chamada. Isso pode se tornar uma sobrecarga se o tempo de execução da função for menor que o tempo de chaveamento da função chamador para a função chamada (chamada). Para funções que são grandes e / ou executam tarefas complexas, a sobrecarga da chamada de função é geralmente insignificante comparada à quantidade de tempo que a função leva para ser executada. No entanto, para funções pequenas e comumente usadas, o tempo necessário para fazer a chamada de função é geralmente muito maior do que o tempo necessário para realmente executar o código da função. Essa sobrecarga ocorre para pequenas funções porque o tempo de execução da função pequena é menor que o tempo de comutação.
+
+C ++ fornece funções embutidas para reduzir a sobrecarga da chamada de função. A função inline é uma função que é expandida em linha quando é chamada. Quando a função inline é chamada código inteiro, a função inline é inserida ou substituída no ponto da chamada de função inline. Essa substituição é executada pelo compilador C ++ no tempo de compilação. A função inline pode aumentar a eficiência se for pequena. A sintaxe para definir a função inline é:
+
+```cpp
+inline return-type function-name(parameters) 
+ { 
+    // function code 
+ } 
+```
+
+Lembre-se, inlining é apenas um pedido para o compilador, não um comando. O compilador pode ignorar a solicitação de inlining. O compilador não pode executar inlining em tais circunstâncias como:
+
+*   Se uma função contiver um loop. (por enquanto, do-while)
+*   Se uma função contiver variáveis ​​estáticas.
+*   Se uma função é recursiva.
+*   Se um tipo de retorno de função é diferente de void, e a declaração de retorno não existe no corpo da função.
+*   Se uma função contiver uma instrução switch ou goto.
+
+### Funções inline fornecem as seguintes vantagens:
+
+*   A sobrecarga da chamada de função não ocorre.
+*   Ele também salva a sobrecarga de variáveis ​​push / pop na pilha quando a função é chamada.
+*   Também economiza a sobrecarga de uma chamada de retorno de uma função.
+*   Quando você inline uma função, você pode habilitar o compilador para executar otimização específica do contexto no corpo da função. Essas otimizações não são possíveis para chamadas de função normais. Outras otimizações podem ser obtidas considerando os fluxos de contexto de chamada e o contexto chamado.
+*   A função inline pode ser útil (se for pequena) para sistemas embarcados, pois inline pode render menos código do que o preâmbulo e retorno da chamada de função.
+
+### Desvantagens da função inline:
+
+*   As variáveis ​​adicionadas da função inline consomem registradores adicionais, After in-line function se o número de variáveis ​​que usarão registradores aumenta do que eles podem criar sobrecarga na utilização de recursos de variáveis ​​de registro. Isso significa que quando o corpo da função inline é substituído no ponto da chamada de função, o número total de variáveis ​​usadas pela função também é inserido. Assim, o número de registros a ser usado para as variáveis ​​também será aumentado. Então, se após a função inline os números das variáveis ​​aumentarem drasticamente, isso certamente causaria uma sobrecarga na utilização do registro.
+    
+*   Se você usar muitas funções embutidas, o tamanho do arquivo executável binário será grande, devido à duplicação do mesmo código.
+    
+*   O inlining em excesso também pode reduzir a taxa de acertos do cache de instruções, reduzindo, assim, a velocidade de busca da instrução, desde a memória cache até a memória principal.
+    
+*   A função inline pode aumentar a sobrecarga de tempo de compilação se alguém alterar o código dentro da função inline e todo o local de chamada tiver que ser recompilado, pois o compilador precisaria substituir todo o código novamente para refletir as alterações, caso contrário, ele continuará com a funcionalidade antiga.
+    
+*   Funções embutidas podem não ser úteis para muitos sistemas embarcados. Porque em sistemas embarcados o tamanho do código é mais importante que a velocidade.
+    
+*   Funções inline podem causar thrashing porque inlining pode aumentar o tamanho do arquivo executável binário. Bater na memória faz com que o desempenho do computador seja degradado.
+    
+
+O programa a seguir demonstra esse conceito:
+
+```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; 
+ } 
+```
+
+Saída:
+```
+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/portuguese/cplusplus/input-and-output/index.md

@@ -0,0 +1,136 @@
+---
+title: Input and Output
+localeTitle: Entrada e saída
+---
+## Entrada e Saída com Fluxos
+
+Para imprimir coisas no console, ou ler a partir dele, use `cout` e `cin` , que são os chamados `streams` . Essa metáfora é usada porque você usa fluxos como o que você usaria uma pia ou um toque: ou você descarrega dados em uma pia ( `cout` ) ou obtém dados de um toque ( `cin` ).
+
+### Saída com cout
+
+O programa "Hello World" usa `cout` para imprimir "Hello World!" para o console:
+
+```C++
+#include<iostream> 
+ using namespace std; 
+ 
+ int main() 
+ { 
+  cout << "Hello world!" << endl; 
+ } 
+```
+
+As duas primeiras linhas no topo são necessárias para você usar `cout` e outros fluxos. `#include<iostream>` faz com que os objetos de fluxo estejam disponíveis e `using namespace std;` permite que você digite `cout` diretamente ao invés de ter que digitar `std::cout` , isto é, ter que especificar que queremos usar `cout` do namespace `std` .
+
+`cout` significa "Console Output" e é um chamado _fluxo de saída_ que representa o console. Quando você quiser imprimir algo no console, você pode colocá-lo em `cout` ; imagine-o como um buraco que leva ao terminal. Para colocar coisas neste buraco, uma de cada vez, você usa o operador `<<` , também conhecido como o _operador de inserção_ 1 . O operador pode ser acorrentado, ou seja, você pode colocar várias coisas em uma após a outra. O seguinte irá imprimir "O bolo é uma mentira":
+
+`cout << "The cake " << "is " << "a " << "lie." << endl;`
+
+`endl` significa "End Line" e é outro item que vem de `<iostream>` . Quando você coloca `endl` em `cout` , ele irá imprimir um caractere de nova linha ( "\\ n") para o console, e também _alinhada_ `cout` , o que significa que ele irá forçar `cout` para imprimir tudo o que você colocar nele _agora._ Se você não colocar `endl` em `cout` , `cout` pode manter os dados que você colocou nele, mas esperar por mais dados antes de realmente imprimir tudo. Isto é chamado de _buffer_ e é muito bom para o desempenho, mas se você já tiver dado tudo o que é suposto para imprimir, você quer `cout` imprimi-lo immediatelly. Portanto, é uma boa prática terminar com `endl` em lugares onde faz sentido.
+
+Quase tudo pode ser colocado em um fluxo: strings, números, variáveis, expressões, etc. Aqui estão alguns exemplos de inserções de fluxo 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 
+```
+
+### Uma nota sobre o espaço em branco
+
+C ++ sempre coloca _você_ no controle e faz exatamente as coisas que você diz para fazer. Isso às vezes pode ser surpreendente, como no exemplo a seguir:
+
+```C++
+string name = "Sarah"; 
+ cout << "Good morning" << name << "how are you today? << endl; 
+```
+
+Você pode esperar que seja impresso "Bom dia Sarah, como você está hoje?", Mas na verdade, a saída seria "Bom dia, Sarah, como você está hoje?". A razão para esse bug é que você não escreveu espaços nas strings ao redor do `name` , e assim, como você não especificou nenhum espaço, o `cout` não imprimiu nenhum. A versão correta seria: `cout << "Good morning " << name << " how are you today? << endl;`
+
+Quebras de linha também não acontecem sozinhas. Você pode pensar que isso imprimiria uma receita em quatro linhas:
+
+```C++
+cout << "To make bread, you need:"; 
+ cout << "* One egg"; 
+ cout << "* One water"; 
+ cout << "* Two wheat"; 
+```
+
+mas a saída é na verdade tudo em uma linha: "Para fazer pão, você precisa: \* Um ovo \* Uma água \* Dois de trigo". Isso ocorre porque não há caracteres de nova linha no final das linhas, portanto, naturalmente, o C ++ assume que não queremos imprimir caracteres de nova linha.
+
+Você poderia consertar isso adicionando `endl` s após cada linha, porque, como discutido anteriormente, o `endl` insere um caractere de nova linha no fluxo de saída. No entanto, isso também força o buffer a ser liberado, o que nos perde um pouco o desempenho, já que poderíamos imprimir todas as linhas de uma só vez. Portanto, o melhor seria adicionar caracteres reais de nova linha no final das linhas e usar somente `endl` no final:
+
+```C++
+cout << "To make bread, you need:\n"; 
+ cout << "* One egg\n"; 
+ cout << "* One water\n"; 
+ cout << "* Two wheat" << endl; 
+```
+
+Se você está apenas imprimindo uma pequena receita, o tempo que você economiza é minúsculo e não vale a pena, mas se você estiver imprimindo milhões de itens, a diferença pode ser muito perceptível.
+
+### Entrada com cin
+
+Para ler a partir do console, você usa o _fluxo de entrada_ `cin` da mesma forma como faria `cout` , mas em vez de colocar as coisas em `cin` , você "tirá-los". O programa a seguir lê dois números do usuário e os adiciona juntos:
+
+```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 "Console Input" e é um _fluxo de entrada_ que representa a entrada do console. Na expressão `cin >> a;` , os dados são lidos de `cin` e salvos na variável `a` , usando o operador `>>` , o _operador de extração_ 2 . O operador de extração lê exatamente a quantidade de dados necessária para gravar na variável que especificamos e pula qualquer espaço em branco, portanto, se o usuário digitar "6", isso será lido apenas como o valor `6` .
+
+Vale a pena notar que o `cin` irá parar todo o programa para esperar que o usuário digite seu valor. O programa não continuará até que o usuário tenha pressionado enter e alguns dados serão gravados na variável. Se o usuário apenas pressionar enter sem digitar nada, o `cin` continuará esperando por um valor.
+
+O operador de extração `<<` pode ser encadeado também. Aqui está o mesmo programa da última vez, mas escrito de uma maneira mais 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; 
+ } 
+```
+
+Quando encadeado, o operador de extração primeiro lerá os dados de `cin` para preencher `a` e, em seguida, lerá os dados para preencher `b` .
+
+As instruções printf e scanf padrão de C também podem ser usadas com o c ++ importando ' ' arquivo de cabeçalho.
+
+## Fontes
+
+1.  http://www.cplusplus.com/reference/ostream/ostream/operator%3C%3C/
+2.  http://www.cplusplus.com/reference/istream/istream/operator%3E%3E/

guide/portuguese/cplusplus/lists/index.md

@@ -0,0 +1,13 @@
+---
+title: C++ Lists
+localeTitle: Listas de C ++
+---
+# O que é uma lista STL?
+
+Listas em C ++ são uma ferramenta poderosa semelhante ao seu primo mais conhecido, o C ++ Vectors. Enquanto os vetores são um contêiner seqüencial Onde os elementos são indexados em uma cadeia contínua, as listas também são um contêiner seqüencial, mas são organizadas de maneira diferente. Elementos de lista apontam para o próximo elemento, então todos os elementos são ordenados em seqüência, mas não usam indexação. Como? Você pode perguntar. Eles fazem isso não indexando, mas usando uma ferramenta especial chamada iteradores. Iteradores são como ponteiros especiais cujo trabalho é manter a ordem dos elementos da lista como a ligação entre dois vagões de trem. Aqui está um bom visual de como as listas são organizadas em comparação com vetores e matrizes. ![img](https://imgur.com/SiU8uTe.png)
+
+## Como declarar uma lista
+
+Se você quiser declarar uma lista de números, escreva:
+
+'' 'std :: list Números;'''

guide/portuguese/cplusplus/loops/index.md

@@ -0,0 +1,84 @@
+---
+title: Loops
+localeTitle: rotações
+---
+# rotações
+
+## Introdução
+
+Agora vamos discutir algo conhecido como loop. Suponha que você queira imprimir os números pares de 1 a 1000 na tela. Mão única fazer isso é escrever as seguintes linhas
+
+\`\` \`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 (condição) { // Código que será executado enquanto a condição for verdadeira } Faz { // Será executado uma vez e até que a condição seja falsa } while (condição);
+```
+### 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 uma variável; verificar uma condição; incrementar a variável inicializada) { // Código para executar }
+```
+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; }
+
+\`\` \`
+
+*   A diferença no primeiro programa e no segundo é a parte de incremento. O resto do código é o mesmo. Este programa imprimirá 0 e em seguida, adicione 2 a ele e imprima 2 no console e assim por diante até o valor de i se torna igual a 1000.
+    
+    Nosso programa final para imprimir números pares de 0 a 1000 será assim.
+    
+    \`\` \`c ++
+    
+    # incluir
+    
+    usando namespace std; int main () { para (int i = 0; i <= 1000; i = i + 2) { cout << i << endl; } return 0; } \`\` \`

guide/portuguese/cplusplus/map/index.md

@@ -0,0 +1,81 @@
+---
+title: Map
+localeTitle: Mapa
+---
+## Introdução do mapa
+
+`map` é um contêiner associativo que armazena elementos no par de valores-chave. Assim como em `Java` tem coleção, array associativo em PHP e assim por diante.
+
+## Benefícios do uso do mapa
+
+*   Ele armazena apenas chaves exclusivas e isso também na ordem classificada com base em seus critérios de classificação atribuídos.
+*   Como as chaves estão na ordem de classificação, portanto, pesquisar elemento no mapa através da tecla é muito rápido, ou seja, leva tempo logarítmico.
+*   No `map` , haverá apenas um valor associado à chave every.
+*   `map` pode ser usado como matrizes associativas.
+*   Pode ser implementado usando árvores binárias balanceadas.
+
+Aqui está um exemplo:
+
+```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; 
+ } 
+```
+
+Saída:
+```
+a => 10 
+ b => 20 
+ c => 30 
+ d => 40 
+```
+
+## Criando objeto de mapa
+
+`map<string, int> myMap;`
+
+## Inserção
+
+Inserindo dados com a função de membro de inserção.
+
+```c++
+myMap.insert(make_pair("earth", 1)); 
+ myMap.insert(make_pair("moon", 2)); 
+```
+
+Nós também podemos inserir dados em std :: map usando operator \[\] ie
+
+`myMap["sun"] = 3;`
+
+## Acessando elementos do mapa
+
+Para acessar os elementos do mapa, você precisa criar um iterador para ele. Aqui está um exemplo como dito antes.
+
+```c++
+map<char, int>::iterator it; 
+ for(it=first.begin(); it!=first.end(); ++it){ 
+  cout << it->first << " => " << it->second << '\n'; 
+ } 
+```
+
+Aqui você pode aprender mais sobre o mapa: [cpluspluc\_map](http://www.cplusplus.com/reference/map/map/map/)
+
+NB: Todos os códigos no exemplo estão na versão C ++ 11. Você pode aprender mais sobre a versão C ++ [aqui](http://en.cppreference.com/w/cpp/compiler_support)

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

@@ -0,0 +1,78 @@
+---
+title: Object Oriented Programming using C++
+localeTitle: Programação Orientada a Objetos usando C ++
+---
+## Programação Orientada a Objetos usando C ++
+
+A programação orientada a objetos, abreviada para OOP, visa implementar entidades do mundo real como herança, ocultação e polimorfismo na programação. O principal objetivo da OOP é vincular os dados e as funções que operam neles, de modo que nenhuma outra parte do código possa acessar esses dados, exceto essa função.
+
+Vamos aprender sobre diferentes características de uma linguagem de programação orientada a objetos:
+
+### Objeto:
+
+Objetos são entidades básicas de tempo de execução em um sistema orientado a objetos, objetos são instâncias de uma classe, são definidos como tipos de dados definidos pelo usuário.
+
+```cpp
+class person 
+ { 
+    char name[20]; 
+    int id; 
+ public: 
+    void getdetails(){} 
+ }; 
+ 
+ int main() 
+ { 
+   person p1; //p1 is an object 
+ } 
+```
+
+Objetos ocupam espaço na memória e possuem um endereço associado como um registro em pascal ou estrutura ou união em C.
+
+Quando um programa é executado, os objetos interagem enviando mensagens entre si.
+
+Cada objeto contém dados e código para manipular os dados. Os objetos podem interagir sem precisar conhecer detalhes dos dados ou códigos dos outros. É suficiente saber o tipo de mensagem aceita e o tipo de resposta retornada pelos objetos.
+
+### Classe:
+
+Class é um modelo de dados e funções ou métodos. Classe não ocupa espaço.
+
+```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 
+ }; 
+```
+
+Classe é um tipo de dados definido pelo usuário, como estruturas e uniões em C.
+
+Por padrão, as variáveis ​​de classe são privadas, mas no caso de estrutura, são públicas. no exemplo acima, a pessoa é uma classe.
+
+### Encapsulamento e abstração de dados:
+
+Agrupar (combinar) dados e funções em uma única unidade é conhecido como encapsulamento. Os dados não são acessíveis ao mundo externo e apenas as funções que estão agrupadas na classe podem acessá-lo. Esse isolamento dos dados do acesso direto pelo programa é chamado de ocultação de dados ou ocultação de informações.
+
+A abstração de dados se refere a fornecer apenas informações necessárias para o mundo externo e a ocultar detalhes da implementação. Por exemplo, considere uma classe Complex com funções públicas como getReal () e getImag (). Podemos implementar a classe como uma matriz de tamanho 2 ou como duas variáveis. A vantagem das abstrações é que podemos alterar a implementação a qualquer momento, os usuários da classe Complex não serão afetados, pois a interface do nosso método permanece a mesma. Se a nossa implementação fosse pública, não teríamos conseguido alterá-la.
+
+### Herança:
+
+Herança é o processo pelo qual objetos de uma classe adquirem as propriedades de objetos de outra classe. Suporta o conceito de classificação hierárquica. A herança fornece reutilização. Isso significa que podemos adicionar recursos adicionais a uma classe existente sem modificá-la.
+
+### Polimorfismo:
+
+Polimorfismo significa capacidade de tomar mais de um formulário. Uma operação pode exibir diferentes comportamentos em diferentes instâncias. O comportamento depende dos tipos de dados usados ​​na operação.
+
+C ++ suporta sobrecarga do operador e sobrecarga de funções. A sobrecarga do operador é o processo de fazer com que um operador exiba comportamentos diferentes em instâncias diferentes. A sobrecarga de funções está usando um único nome de função para executar diferentes tipos de tarefas. O polimorfismo é amplamente utilizado na implementação de herança.
+
+### Ligação Dinâmica:
+
+Na ligação dinâmica, o código a ser executado em resposta à chamada de função é decidido no tempo de execução. C ++ tem funções virtuais para suportar isso.
+
+### Passagem de mensagens:
+
+Os objetos se comunicam entre si enviando e recebendo informações uns aos outros. Uma mensagem para um objeto é uma solicitação para execução de um procedimento e, portanto, invocará uma função no objeto de recebimento que gera os resultados desejados. A passagem de mensagens envolve a especificação do nome do objeto, o nome da função e as informações a serem enviadas.

guide/portuguese/cplusplus/overloading/index.md

@@ -0,0 +1,102 @@
+---
+title: C++ Overloading
+localeTitle: Sobrecarga C ++
+---
+C ++ permite que você especifique mais de uma definição para um nome de função ou um operador no mesmo escopo, o que é chamado de sobrecarga de função e sobrecarga de operador, respectivamente.
+
+Uma declaração sobrecarregada é uma declaração que é declarada com o mesmo nome que uma declaração declarada anteriormente no mesmo escopo, exceto que ambas as declarações possuem argumentos diferentes e obviamente uma definição diferente (implementação).
+
+Quando você chama uma função ou operador sobrecarregado, o compilador determina a definição mais apropriada a ser usada, comparando os tipos de argumento que você usou para chamar a função ou operador com os tipos de parâmetro especificados nas definições. O processo de seleção da função ou operador sobrecarregado mais apropriado é chamado de resolução de sobrecarga.
+
+### Sobrecarga de função em C ++
+
+Você pode ter várias definições para o mesmo nome de função no mesmo escopo. A definição da função deve diferir uma da outra pelos tipos e / ou pelo número de argumentos na lista de argumentos. Você não pode sobrecarregar as declarações de função que diferem apenas pelo tipo de retorno.
+
+A seguir, o exemplo em que a mesma função print () está sendo usada para imprimir diferentes tipos de dados -
+
+```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; 
+ } 
+```
+
+Quando o código acima é compilado e executado, ele produz o seguinte resultado -
+```
+Printing int: 5 
+ Printing float: 500.263 
+ Printing string: Hello C++ 
+```
+
+### Sobrecarga de Operador em C ++
+
+A maioria dos operadores internos também pode ser sobrecarregada em C ++. Isso permite que os programadores atribuam implementações diferentes aos operadores, dependendo dos argumentos. Esses operadores sobrecarregados podem trabalhar para classes definidas pelo usuário.
+```
+#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(); 
+ } 
+```
+
+Saída para o programa acima
+```
+4 + i3 
+
+```

guide/portuguese/cplusplus/preprocessors/index.md

@@ -0,0 +1,160 @@
+---
+title: Preprocessors
+localeTitle: Pré-processadores
+---
+## Pré-processadores em C / CPP
+
+Como o nome sugere, os pré-processadores são programas que processam nosso código-fonte antes da compilação. Há vários passos envolvidos entre escrever um programa e executar um programa em C / C ++. Vamos dar uma olhada nestes passos antes de começarmos a aprender sobre os pré-processadores.
+
+![Img](https://i.imgur.com/Pb0aTkV.png)
+
+Você pode ver as etapas intermediárias no diagrama acima. O código fonte escrito pelos programadores é armazenado no arquivo program.c. Este arquivo é então processado por pré-processadores e um arquivo de código-fonte expandido é gerado programa nomeado. Este arquivo expandido é compilado pelo compilador e um arquivo de código de objeto é gerado chamado program.obj. Finalmente, o vinculador vincula esse arquivo de código de objeto ao código de objeto das funções de biblioteca para gerar o arquivo executável program.exe.
+
+Os programas de pré-processador fornecem diretivas de pré-processadores que informam ao compilador para pré-processar o código-fonte antes de compilá-lo. Todas essas diretivas de pré-processador começam com um símbolo `#` (hash). Esse símbolo ('#') no início de uma instrução em um programa C / C ++ indica que é uma diretiva de pré-processador. Podemos colocar essas diretivas pré-processador em qualquer parte do nosso programa. Exemplos de algumas diretivas de pré-processador são: `#include` , `#define` , `#ifndef` etc.
+
+### Tipos de diretivas de pré-processador:
+
+1.  Macros
+2.  Inclusão de arquivos
+3.  Compilação Condicional
+4.  Outras diretivas
+
+### Macros:
+
+As macros são uma parte do código em um programa que recebe algum nome. Sempre que esse nome é encontrado pelo compilador, o compilador substitui o nome pela parte real do código. A diretiva `#define` é usada para definir uma macro.
+
+```cpp
+  #include<iostream> 
+  #define LIMIT 3 
+  int main() 
+  { 
+    for(int i=0; i < LIMIT; i++) 
+    { 
+      std::cout<<i<<" " ; 
+    } 
+      return 0; 
+  } 
+```
+
+Saída:
+
+`0 1 2`
+
+No programa acima, quando o compilador executa a palavra `LIMIT` ele o substitui por 3. A palavra `LIMIT` na definição de macro é chamada de modelo de macro e '3' é a expansão de macro.
+
+Não deve haver ponto e vírgula (';') no final da definição macro. As definições de macro não precisam de ponto e vírgula para terminar.
+
+### Inclusão de arquivos:
+
+Esse tipo de diretiva de pré-processador informa ao compilador para incluir um arquivo no programa de código-fonte. Existem dois tipos de arquivos que podem ser incluídos pelo usuário no programa:
+
+*   \#### Arquivos de cabeçalho ou arquivos padrão: Esses arquivos contêm a definição de funções predefinidas como printf (),… scanf () etc. Esses arquivos devem ser incluídos para trabalhar com essas funções. … Funções diferentes são declaradas em diferentes arquivos de cabeçalho. Por exemplo… as funções de E / S padrão estão no arquivo 'iostream', enquanto as funções que… executam operações de string estão no arquivo 'string'.
+
+#### Sintaxe:
+
+`#include< file_name >` onde file\_name é o nome do arquivo a ser incluído. Os colchetes `<` e `>` dizem ao compilador para procurar o arquivo no diretório padrão.
+
+*   \#### Arquivos definidos pelo usuário: Quando um programa se torna muito grande, é recomendável dividi-lo em arquivos menores e incluir sempre que necessário. Esses tipos de arquivos são arquivos definidos pelo usuário. Esses arquivos podem ser incluídos como: … `#include"filename"`
+
+### Compilação Condicional:
+
+As diretivas de compilação condicional são tipos de diretivas que ajudam a compilar uma parte específica do programa ou a pular a compilação de alguma parte específica do programa com base em algumas condições. Isso pode ser feito com a ajuda de dois comandos de pré-processamento `ifdef` e `endif` .
+
+#### Sintaxe:
+
+```cpp
+  ifdef macro_name 
+    statement1; 
+    statement2; 
+    statement3; 
+    . 
+    . 
+    . 
+    statementN; 
+  endif 
+```
+
+Se a macro com nome como 'macroname' for definida, o bloco de instruções será executado normalmente, mas se não for definido, o compilador simplesmente ignorará este bloco de instruções.
+
+### Outras diretivas:
+
+Para além das directivas acima, existem mais duas directivas que não são normalmente utilizadas. Esses são:
+
+1.  \##### `#undef` Directiva: A diretiva `#undef` é usada para indefinir uma macro existente. Esta diretiva funciona como:
+
+##### Sintaxe:
+
+`#undef LIMIT` Usando esta declaração irá indefinir a macro LIMIT existente. Após esta declaração, cada declaração `#ifdef LIMIT` será avaliada como falsa.
+
+2.  \##### `#pragma` directiva: Esta diretiva é uma diretiva de propósito especial e é usada para ativar ou desativar alguns recursos. Esse tipo de diretivas é específico do compilador, ou seja, elas variam de compilador para compilador. Algumas das diretivas # `#pragma` são discutidas abaixo:
+
+##### `#pragma startup` e `#pragma exit` :
+
+Essas diretivas nos ajudam a especificar as funções necessárias para executar antes da inicialização do programa (antes que o controle passe para main ()) e logo antes da saída do programa (logo antes que o controle retorne 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; 
+ } 
+```
+
+Saída:  
+`Inside func1() Inside main() Inside func2()`  
+O código acima irá produzir a saída como indicado abaixo quando executado em compiladores GCC:  
+Saída:  
+`Inside main()`  
+Isso acontece porque o GCC não suporta a inicialização ou a saída #pragma. No entanto, você pode usar o código abaixo para uma saída similar em 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 diretiva é usada para ocultar a mensagem de aviso exibida durante a compilação. Podemos ocultar os avisos conforme mostrado abaixo:
+
+##### `#pragma warn -rvl` :
+
+Essa diretiva oculta os avisos que são gerados quando uma função que deve retornar um valor não retorna um valor.
+
+##### `#pragma warn -par` :
+
+Essa diretiva oculta os avisos que são gerados quando uma função não usa os parâmetros passados ​​para ela.
+
+##### `#pragma warn -rch` :
+
+Essa diretiva oculta os avisos que são gerados quando um código está inacessível. Por exemplo: qualquer código escrito após a declaração de retorno em uma função é inacessível.

guide/portuguese/cplusplus/queue/index.md

@@ -0,0 +1,197 @@
+---
+title: queue
+localeTitle: fila
+---
+## Filas
+
+`queue` é um dos contêineres mais usados ​​em C ++. Um contêiner é uma estrutura de dados que armazena uma coleção de objetos, alguns em ordem, outros não. Todos os contêineres possuem um conjunto diferente de funções que permitem acessar um objeto (s) nessa coleção.
+
+`std::queue` faz parte da biblioteca padrão C ++ (daí o prefixo `std::` e permite que você armazene dados na ordem First In First Out (FIFO). NOTA: **Todos os objetos em uma fila devem ser do mesmo tipo de dados**
+
+O tipo de dados armazenado em uma fila fica entre colchetes angulares ao lado da palavra-chave da fila. Por exemplo, se você gostaria de armazenar uma coleção de inteiros, a fila seria `std::queue<int> queue_name`
+
+### Explicação LIFO da fila
+
+`queue` nos permite enviar / enfileirar e colocar / soltar em ordem específica. **Empurrar** significa inserir um objeto na frente da fila. **Pop** significa retirar o objeto "mais antigo" do final da fila. Então, quando você empurra, está na frente e, quando você abre, extrai o elemento mais antigo.
+
+![alt text](https://github.com/mohammadaziz313/helloworld/blob/master/Fifo_queue.png "Exemplo de Enfileiramento e Desenfileiramento de Filas FIFO")
+
+### Operações de fila
+
+O contêiner de filas suporta as seguintes operações:
+
+*   empurrar (enfileirar)
+*   pop (dequeue)
+*   vazio
+*   Tamanho
+*   frente
+*   costas
+
+#### Empurrar
+
+Permite inserir um novo elemento no final da fila, depois do último elemento atual.
+
+```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
+
+Permite que você acesse o próximo elemento na fila sem removê-lo. O próximo elemento é o elemento "mais antigo" na fila.
+
+```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 
+```
+
+#### Pop
+
+Permite que você remova o próximo elemento na fila, reduzindo efetivamente seu tamanho em um. O elemento removido é o elemento "mais antigo".
+
+```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 
+```
+
+#### Tamanho
+
+Retorna o número de elementos na `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 
+```
+
+#### Vazio
+
+Retorna se a `queue` está vazia, ou seja, se o tamanho da sua fila é zero. Retorna `true` se o tamanho da fila 0 retornar mais `false`
+
+\`\` \`cpp // Operação vazia na fila
+
+# 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 << "Fora de loop" << '\\ n'; return 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 // Voltar operação na fila
+
+# incluir // std :: cout
+
+# incluir // std :: queue
+
+int main () { std :: queue q;
+
+q.push (1); // Empurrando 1 na frente da fila q.push (2); // Empurrando 2 na frente da fila
+
+std :: cout << q.back () << '\\ n'; // Acessando a parte de trás da fila std :: cout << q.back () << '\\ n'; // Acessando a parte de trás da fila
+
+return 0; } \`\` \`
+```
+Output: 
+ 2 
+ 2 
+```
+
+### Para mais recursos:
+
+http://www.cplusplus.com/reference/queue/queue/
+
+### Citações:
+
+Imagem Cortesia: https://en.wikipedia.org/wiki/FIFO _(computação_ and\_electronics)

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

@@ -0,0 +1,88 @@
+---
+title: Random Functions
+localeTitle: Funções Aleatórias
+---
+*   Números aleatórios são uma maneira conveniente de introduzir randomização em seu programa. Por exemplo, se você quiser executar simulações ou jogar, excluir índices aleatórios de uma matriz, etc, então números aleatórios são o caminho a percorrer.
+*   O arquivo de cabeçalho a ser incluído para usar números aleatórios em c ++ é `cstdlib` .
+*   _Dica profissional: -_ Você pode usar `cpp #include<bits/stdc++.h>` para incluir todas as funções de todos os arquivos de cabeçalho.
+
+Função: - rand ()  
+\- Retorna um número pseudo-aleatório (inteiro) de 0 a RAND _MAX. Não aceita argumentos. - RAND_ MAX é o número inteiro máximo permitido. É compilador depedente e geralmente é 2147483647.
+
+Abaixo está um exemplo:
+
+```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 
+ */ 
+```
+
+Agora, execute o programa novamente. E de novo. E de novo. O que você vê? A mesma saída é impressa de novo e de novo.
+
+Vamos voltar para a definição da função rand (): -
+
+rand (): - _Retorna um número **pseudo-aleatório** (inteiro) de 0 a RAND\_MAX. Não aceita argumentos._
+
+Então, o que é um número pseudo-aleatório?
+
+*   Como o nome sugere, um número que não é verdadeiramente aleatório é pseudo-aleatório.
+*   Os números psuorandomizados não são criptograficamente seguros e são vulneráveis ​​a ataques.
+*   No contexto de C ++, o número parece aleatório, mas não verdadeiramente aleatório. A função assume que cada número de 0 a RAND\_MAX é igualmente provável e cospe um número. (Na realidade, este não é o caso, mas está próximo). Por exemplo, o número 5 é usado em quase todos os lugares. Se um número aleatório cospe 5, você pode não achar que o número é de fato aleatório.
+*   A função aleatória rand () recebe um número muito grande, aplica módulo por um número primo grande e faz todos os tipos de operações em um número e retorna um valor. Por mais complicado que seja, ainda é possível quebrá-lo.
+
+Como podemos obter um conjunto único de números aleatórios durante toda a execução do programa?
+
+Usamos `void srand(int seed)` ;
+
+*   "Semente" é o nome dado a um número que faz o gerador de seqüência aleatória começar em um ponto de partida diferente toda vez. Isso garante que a função aleatória não cuspa os mesmos valores durante a execução do programa.
+*   **É importante invocar apenas o srand call ONCE no início do programa.**
+*   Não há necessidade de chamadas repetidas para semear o gerador de números aleatórios (na verdade, isso fará com que seu número seja menos uniforme distribuído).
+*   Uma técnica comumente usada é semear o gerador de números aleatórios usando o relógio, já que o relógio fornece uma saída diferente toda vez que você o analisa. Então, para a semente, você pode pegar a saída do tempo e conectá-la ao gerador de números aleatórios.
+*   A função time () retornará a hora do computador. Isto é expresso em termos do número de segundos que se passaram desde 1 de janeiro de 1970 (a Época).
+*   O tempo de função (NULL) retornará o número de segundos decorridos no tempo do computador.
+*   O arquivo de cabeçalho que deve ser incluído para as funções de hora: \`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 
+ */ 
+```
+
+Isso produz valores diferentes toda vez que o programa é executado.
+
+Bônus: Ajustando o rand () para sua conveniência.
+
+*   Como rand () retorna um número aleatório de 0 a RAND\_MAX, se você quiser um número entre 0 e 8, por exemplo, então -rand ()% 9. Qualquer número módulo 9 retornará um valor de 0 a 8.
+    
+*   Mais formalmente, se você quiser um número entre L (inclusive) e U (inclusive), você deve fazer `int num = L + rand()%(U-L+1).` Explicação: - rand ()% (UL + 1) retorna um número aleatório (pseudo-aleatório, não esqueça) entre 0 e (UL). Portanto, adicionar L garante que obtemos um valor entre L e U.
+    
+    Resumo: -
+    
+
+1.  int rand (): Retorna um número aleatório entre 0 e RAND\_MAX.
+    
+2.  void srand (int seed): Usado para semear o gerador de números aleatórios. É suficiente chamar essa função apenas _uma vez_ .
+    
+    ### Fontes: - [Geração de Números Aleatórios](http://www.math.uaa.alaska.edu/~afkjm/csce211/handouts/RandomFunctions)

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

@@ -0,0 +1,30 @@
+---
+title: Range For Loop
+localeTitle: Faixa para Loop
+---
+## Baseado em intervalo para loop
+
+O loop `for` baseado `for` ranged permite um loop fácil em um intervalo de elementos (como elementos em um contêiner).
+
+Com tradicional `for` loop:
+
+```cpp
+std::vector<std::string> stringList {"one", "two", "three"}; 
+ 
+ for (size_t il; il < stringList.size(); il++ 
+ { 
+  std::cout << stringList.at(il) << std::endl; 
+ } 
+```
+
+Com base `for` intervalo `for` loop:
+
+```cpp
+std::vector<std::string> stringList {"one", "two", "three"}; 
+ 
+ for (auto& singleString : stringList) 
+ { 
+  std:cout << singleString << std::endl; 
+ } 
+
+```

guide/portuguese/cplusplus/set/index.md

@@ -0,0 +1,94 @@
+---
+title: Set
+localeTitle: Conjunto
+---
+Uma estrutura de dados definida em c ++ é definida da mesma forma que um conjunto é definido no contexto da matemática.
+
+Mais formalmente falando, os Conjuntos são um tipo de contêineres associativos nos quais cada elemento tem que ser único.
+
+*   O valor do elemento não pode ser modificado depois que ele é inserido, embora a exclusão de um elemento e a inserção de um novo elemento seja permitida, da mesma forma que fazemos em matemática.
+*   Definir estrutura de dados pode ser usado para modelar, bem, se define. Fica fácil achar interseções, uniões etc.
+*   Semelhante ao vetor, mas somente valores exclusivos são permitidos.
+*   Set organiza os elementos em ordem crescente como e quando você insere elementos no conjunto.
+
+O arquivo de cabeçalho necessário para usar a estrutura de dados definida é 'set'. ou seja, `#include<set>` deve estar lá em seu código para você usar a estrutura de dados definida.
+
+**Dica profissional** : - Use `#include<bits/stdc++.h>` para incluir todas as estruturas e funções de dados do C ++, em vez de adicioná-las uma a uma.  
+Algumas das funções que podem ser executadas com um conjunto: -
+
+1.  begin () - Retorna um iterador para o primeiro elemento no conjunto
+2.  end () - Retorna um iterador ao elemento teórico que segue o último elemento no conjunto
+3.  size () - Retorna o número de elementos no conjunto
+4.  max\_size () - Retorna o número máximo de elementos que o conjunto pode conter
+5.  empty () - Retorna se o conjunto está vazio
+6.  erase (const g) - Remove o valor 'g' do conjunto
+7.  clear () - Remove todos os elementos do conjunto
+
+Vamos ver um exemplo :-
+
+```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 Saída:- O conteúdo do myset: 9 20 30 65 80
+
+Conteúdo do myset após a remoção de elementos inferiores a 30: 30 65 80
+
+Depois de fazer myset.erase (80), 1 elemento é removido
+
+Conteúdo do conjunto modificado: 30 65 \`\` \`
+
+\### Fontes
+
+1.  [Geeks para Geeks](https://www.geeksforgeeks.org/set-in-cpp-stl/)

guide/portuguese/cplusplus/stack/index.md

@@ -0,0 +1,174 @@
+---
+title: stack
+localeTitle: pilha
+---
+## Pilhas
+
+`stack` é um dos contêineres mais usados ​​em C ++. Um contêiner é uma estrutura de dados que armazena uma coleção de objetos, alguns em ordem, outros não. Todos os contêineres possuem um conjunto diferente de funções que permitem acessar um objeto (s) nessa coleção.
+
+`std::stack` faz parte da biblioteca padrão C ++ (daí o prefixo `std::` e permite que você armazene dados na ordem Last In First Out (LIFO). NOTA: **Todos os objetos dentro de uma pilha devem ser do mesmo tipo de dados**
+
+O tipo de dados armazenado em uma pilha fica entre os colchetes angulares ao lado da palavra-chave da pilha. Por exemplo, se você gostaria de armazenar uma coleção de inteiros, a pilha seria `std::stack<int> stack_name`
+
+### Stack LIFO Explanation
+
+`stack` nos permite empurrar e pop em ordem específica. **Empurrar** significa inserir um objeto no topo da pilha. **Pop** significa retirar o último objeto inserido do topo da pilha. Então, quando você empurra, está no topo e quando você estala, extrai o último elemento inserido.
+
+![alt text](https://github.com/mohammadaziz313/helloworld/blob/master/Lifo_stack.png "LIFO Stack Push and Pop Example")
+
+### Operações de pilha
+
+O contêiner de pilha suporta as seguintes operações:
+
+*   empurrar
+*   pop
+*   vazio
+*   Tamanho
+*   costas
+
+#### Empurrar
+
+Permite inserir um novo elemento na parte superior da pilha, acima do elemento superior atual.
+
+```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; 
+ } 
+```
+
+#### Topo
+
+Permite que você acesse o elemento superior sem removê-lo de sua pilha.
+
+```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 
+```
+
+#### Pop
+
+Remove o elemento no topo da pilha, reduzindo efetivamente o tamanho da pilha em um.
+
+```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 
+```
+
+#### Tamanho
+
+Retorna o número de elementos na `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 
+```
+
+#### Vazio
+
+Retorna se a `stack` está vazia, ou seja, se o tamanho da sua pilha é zero. Retorna `true` se o tamanho 0 da pilha retornar mais `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/portuguese/cplusplus/switch-statements/index.md

@@ -0,0 +1,43 @@
+---
+title:Switch Statement
+localeTitle: undefined
+---
+Uma instrução switch permite que uma variável seja testada quanto à igualdade em relação a uma lista de valores. Cada valor é chamado de caso e a variável que está sendo ativada é verificada para cada caso.
+
+Sintaxe: switch (expressão) { expressão constante de caso: afirmações); pausa; //opcional expressão constante de caso: afirmações); pausa; //opcional
+
+// você pode ter qualquer número de declarações de caso. padrão: // Opcional afirmações); }
+
+As seguintes regras se aplicam a uma instrução switch -
+
+A expressão usada em uma instrução switch deve ter um tipo integral ou enumerado, ou ser de um tipo de classe em que a classe tenha uma única função de conversão para um tipo integral ou enumerado.
+
+Você pode ter qualquer número de instruções de caso dentro de um comutador. Cada caso é seguido pelo valor a ser comparado e dois pontos.
+
+A expressão constante para um caso deve ser o mesmo tipo de dados que a variável no switch e deve ser uma constante ou um literal.
+
+Quando a variável que está sendo ligada é igual a um caso, as instruções que seguem esse caso serão executadas até que uma instrução de quebra seja atingida.
+
+Quando uma instrução break é atingida, o switch termina e o fluxo de controle passa para a próxima linha após a instrução switch.
+
+Nem todo caso precisa conter uma pausa. Se nenhuma quebra aparecer, o fluxo de controle cairá para casos subseqüentes até que uma quebra seja atingida.
+
+Uma instrução switch pode ter um caso padrão opcional, que deve aparecer no final do comutador. O caso padrão pode ser usado para executar uma tarefa quando nenhum dos casos é verdadeiro. Nenhuma quebra é necessária no caso padrão.
+
+Exemplo: \`\` \`C ++
+
+# incluir
+
+usando namespace std;
+
+int main () { // declaração de variável local: nota de char = 'D';
+
+switch (grade) { caso 'A': cout << "Excelente!" << endl; pausa; caso 'B': caso 'C': cout << "Bem feito" << endl; pausa; caso 'D': cout << "Você passou" << endl; pausa; caso 'F': cout << "Melhor tentar novamente" << endl; pausa; padrão : cout << "Nota inválida" << endl; } cout << "Sua nota é" << nota << endl;
+
+return 0; } \`\` \`
+
+Saída: Você passou Sua nota é D
+
+### Fontes
+
+https://www.tutorialspoint.com

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

@@ -0,0 +1,142 @@
+---
+title: IDE and Printing different text 
+localeTitle: IDE e impressão de texto diferente
+---
+# Introdução a um IDE e impressão de texto diferente:
+
+*   No último artigo, alguns links para download de software necessários para a programação. Um software como esse é conhecido como IDE. **IDE significa Integrated Development Environment**
+
+## Os IDEs consistem principalmente em 3 tipos de software:
+
+**1 Editor:** Um editor de texto ligeiramente modificado para facilitar a codificação. Um exemplo de editor para codificação é o Notepad ++.
+
+**2 Debugger:** Software que ajuda você a encontrar erros no seu programa e resolvê-los antes da execução. Imagine o FaceBook travando no carregamento de um aplicativo ou um jogo travando de repente. Para evitar a execução defeituosa de um programa, o depurador é o melhor amigo de um programador.
+
+**3 Compiler:** Um compilador é a parte do computador que converte seu código de programa de alto nível em código de máquina simples: 0s & 1s; para que um computador entenda os comandos e os execute. De agora em diante, estaremos usando o **compilador de** palavras com frequência.
+
+_P: Tente pesquisar um IDE no Google e execute seu primeiro programa nele. Verifique a saída_
+
+Agora, instale o IDE e tente alterar o texto do programa no último artigo.
+
+### Alterando o texto em C ++
+
+*   Para alterar o texto, altere o que é digitado no `""` após `cout<<`
+
+Um programa de amostra:
+
+```cpp
+#include <iostream> 
+ using namespace std : 
+ int main() 
+ { 
+    cout << "I Love freeCodeCamp ! "; 
+ } 
+```
+
+O código acima retorna um erro porque na linha 2, usamos dois pontos (:) em vez de um ponto-e-vírgula (;) Então, vamos depurar o erro:
+
+```C++
+#include <iostream> 
+ using namespace std ; 
+ int main() 
+ { 
+    cout << "I Love freeCodeCamp ! "; 
+    return 0; 
+ } 
+```
+
+Note que agora o programa funciona perfeitamente. A saída será: `I Love freeCodeCamp!`
+
+### Agora vamos mudar o texto para algo assim:
+
+```cpp
+    cout << "Hello World!\t I love freeCodeCamp!"; 
+```
+
+A saída será algo diferente desta vez:
+```
+Hello World!     I love freeCodeCamp! 
+```
+
+Se você percebeu, o comando `\t` criou um _espaço de tabulação_ entre os dois textos. Este é um tipo de comando especial em C ++. Esses comandos especiais são conhecidos como _seqüências de escape_ . Eles são usados ​​para imprimir certos caracteres especiais que um compilador não pode exibir.
+
+#### Sequências de escape úteis:
+
+*   `\'` Para imprimir uma única vírgula invertida
+*   `\"` para imprimir uma vírgula invertida dupla
+*   `\n` para imprimir em uma nova linha
+*   `\t` para uma guia horizontal
+*   `\f` para uma nova página
+*   `\\` por uma barra invertida
+*   `\?` para um ponto de interrogação
+
+##### Agora, vamos tentar imprimir números e caracteres especiais com algumas seqüências de escape:
+
+```cpp
+    cout << "40158 \t 236708 ! \n \\ @ \?" << endl; 
+```
+
+A saída muda para:
+```
+40158      236708 ! 
+ \ @ ? 
+```
+
+##### Vamos tentar algumas outras formas de impressão:
+
+```cpp
+    cout << "1+2" << endl; 
+    cout << 1+2 << endl; 
+```
+
+Saída:
+
+*   A primeira declaração de saída é `1+2`
+*   A segunda declaração de saída é `3`
+
+Isso ocorre porque não adicionamos as aspas invertidas para a segunda instrução de impressão e, portanto, o compilador adicionou os números antes de imprimi-los.
+
+#### Comentários:
+
+*   Comentários são uma característica importante de muitas linguagens de programação. Eles permitem que o programador faça anotações para autoajuda e não afetará a execução do programa.
+
+**Os diferentes tipos de comentários e sintaxe de um comentário** :
+
+1 `//` ~ _Single Line Comments_ : O comprimento desses comentários é de 1 linha (a linha em que é digitado). 2 `/* */` ~ _Multi Line Comments_ : Estes comentários podem ocupar um espaço de mais de uma linha.
+
+#### Exemplo de uso de comentários:
+
+\`\` \`cpp cout << "Olá Comentário" << endl; // cout << "Hello Comment" << endl; Comentário de linha única.
+```
+/* This is an example of a multi line comment. No output is generated for this . 
+ I now end the comment.  :) */ 
+```
+
+\`\` \`
+
+A saída será:
+
+`Hello Comment`
+
+Como você pode perceber, os comentários são ignorados durante a execução do programa e não aparecem na verificação da saída do programa. Deve-se notar que, embora os comentários adicionem um nível extra de legibilidade ao código, é um mau hábito confiar demais nos comentários para descrever a lógica em seu código. Em geral, seu código deve falar por si e refletir a intenção do programador.
+
+Como você pode perceber, os comentários são ignorados durante a execução do programa e não aparecem na verificação da saída do programa.
+
+#### Operadores
+
+*   Os operadores permitem comparar duas ou mais expressões
+*   `==` igual a
+*   `!=` não é igual a
+*   `<` menos de
+*   `>` maior que
+*   `<=` menor ou igual a
+*   `>=` maior que ou igual a
+
+```cpp
+    (7==5); 
+```
+
+Isso é avaliado como falso
+
+`cpp (7!=5);` Isso é avaliado como verdadeiro
+

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

@@ -0,0 +1,74 @@
+---
+title: The Auto Feature
+localeTitle: O recurso automático
+---
+## O recurso automático
+
+`auto` é um recurso do C ++ 11 que permite ao compilador inferir o tipo de dados para você em uma definição. Isso pode economizar bastante digitação, especialmente com tipos complicados.
+
+Sem `auto` :
+
+```cpp
+double x = 10.425; 
+ double y = x * x; 
+```
+
+Com `auto` :
+
+```cpp
+double x = 10.425; 
+ auto y = x * x; 
+```
+
+Embora pareça trivial, torna-se incrivelmente útil quando os tipos de dados começam a ficar complicados. Por exemplo, suponha que você queira armazenar um [`vector`](https://guide.freecodecamp.org/cplusplus/vector) de funcionários e esteja interessado apenas em seu nome e idade. Uma maneira de armazenar o nome e a idade pode ser um `pair` com uma `string` e um `unsigned int` . Isso é declarado como `std::vector<std::pair<std::string, unsigned int>> employees` . Agora, suponha que você queira acessar o último funcionário adicionado:
+
+```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(); 
+```
+
+Uma vez que o compilador determina o tipo do lado direito do `=` ele substitui o `auto` por esse tipo.
+
+Nas versões modernas de C ++ (desde C ++ 14), `auto` também pode ser usado em uma declaração de função como o tipo de retorno. O compilador inferirá então o tipo de retorno da declaração de retorno dentro da função. Seguindo o exemplo com funcionários:
+```
+std::vector<std::pair<std::string, unsigned int>> employees; 
+ auto get_last_employee() { 
+    return employees.back(); // Compiler knows the return type from this line. 
+ } 
+```
+
+O compilador saberá da linha com a instrução de retorno que o tipo de retorno da função deve ser `std::vector<std::pair<std::string, unsigned int>>` .
+
+Embora bastante técnica, a [página de autopresença](http://en.cppreference.com/w/cpp/language/auto) descreve muitas outras utilizações de `auto` e os detalhes de quando pode e não pode ser usado.
+
+### `auto` antes do C ++ 11
+
+Em alguns livros antigos contendo código _muito_ antigo, a palavra `auto` chave `auto` é usada de maneira muito diferente.
+
+Esse `auto` particular era uma palavra-chave emprestada de C e provavelmente era a palavra-chave menos usada de todos os tempos.
+
+Em C ++, todas as variáveis ​​têm _duração automática_ , ou seja, são definidas até você sair da função em que estão definidas.
+
+Por exemplo:
+
+\`\` \`cpp
+
+# incluir
+
+int main () { int a; a = 1; // faz sentido, como foi definido na mesma função
+```
+    return 0; 
+```
+
+} a = 2; // não faz sentido, já que não está definido aqui \`\` \`
+
+Este é um dado em C ++, e `auto` especificou que a variável deve ter uma _duração automática_ , daí a falta de uso.
+
+## Leitura adicional:
+
+*   http://www.stroustrup.com/C++11FAQ.html#auto

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

@@ -0,0 +1,95 @@
+---
+title: C++ If Statement
+localeTitle: Declaração de C ++ If
+---
+# A instrução IF.
+
+**O que faz uma declaração if?**
+
+*   A instrução `if` avalia a expressão de teste presente dentro dos parênteses.
+*   A instrução `if` usa operadores relacionais e lógicos para criar expressões lógicas.
+
+* * *
+
+A forma geral da declaração `if` :
+
+```cpp
+  if (Test Expression / Condition) 
+  { 
+    // Block of statements if test expression is True 
+  } 
+```
+
+Se o valor da expressão de teste for **verdadeiro** , o bloco de código dentro da instrução if é executado.
+
+Se o valor da expressão de teste for **falso** , então o bloco de código dentro da instrução if é ignorado e seu código continua.
+
+Exemplo `if` declaração:
+
+```cpp
+  int a = 10; 
+ 
+  // true statement 
+  if (a < 20) 
+  { 
+    // execute this block of code 
+  } 
+ 
+  // false statement 
+  if (a < 0) 
+  { 
+    // Skip this block of code. 
+  } 
+```
+
+Exemplo em 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; 
+  } 
+```
+
+**Saída:**
+
+SAÍDA 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: 
+```
+
+Digite um número: -1 Este passo é sempre impresso \`\` \` Esta é a saída quando o número digitado é negativo.
+
+[Experimente o código você mesmo! :)](https://repl.it/Mg9X)
+
+_Parabéns. Este é o final do artigo sobre a declaração IF_
+
+**Boa sorte para todos vocês**
+
+**Codificação Feliz! :)**
+

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

@@ -0,0 +1,186 @@
+---
+title: Operators
+localeTitle: Operadores
+---
+# Operadores:
+
+*   Os operadores permitem que você execute operações em seus dados.
+*   Os dados que estão sendo operados são chamados de _operando_ .
+*   Os diferentes tipos de operadores em C ++ são:
+*   _OPERANDS_ são os dados em que o operador executa determinados comandos.
+*   Os operadores são de 3 tipos: unário (funciona em 1 operando), binário (trabalha em 2 operandos), ternário (trabalha em 3 operandos).
+
+### 1 Os operadores de I / O -
+
+*   Esses operadores permitem direcionar entrada e saída.
+    
+    ## Oerador de entrada ">>" ##
+    
+    é usado para ler dados da entrada padrão (a instrução "cin").
+    
+    ## O operador de saída "<<"
+    
+    é usado para enviar saída na instrução `cout` .
+    
+
+### 2 Os operadores aritméticos -
+
+*   Esses operadores permitem que você execute operações aritméticas básicas.
+
+1.  O operador `+` _adiciona_ os dois operandos.
+    
+2.  O operador `-` _subtrai_ os dois operandos.
+    
+3.  O operador `*` _multiplica_ os dois operandos.
+    
+4.  O operador `/` _divide_ e fornece o _quociente_ dos dois operandos.
+    
+5.  O operador `%` _divide_ e fornece o _restante_ dos dois operandos. (Ou, para o leitor mais matematicamente inclinado, `a % b` é essencialmente o resultado de "um mod b"
+    
+    ### Exemplo de uso de operadores aritméticos:
+    
+    \`\` \`cpp
+    
+
+# incluir
+
+usando namespace std;
+
+int main () { int a = 5; // 1º operando int b = 10; // 2º 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; 
+```
+
+} \`\` \`
+
+SAÍDA:
+```
++ operator 15 
+ - operator -5 
+ * operator 50 
+ / operator 2 
+ modulus operator 0 
+```
+
+[Experimente o código você mesmo! :)](https://repl.it/Mge9)
+
+### O operador de incremento:
+
+*   `++` é conhecido como o operador de incremento. Aumenta o valor de uma variável inteira em 1.
+
+Os 2 tipos de incremento:
+
+*   O pré-incremento primeiro incrementa o valor e depois o utiliza. Exemplo: `int a ; ++a;`
+*   Post increment primeiro usa a variável, em seguida, incrementa-lo. Exemplo: `int b; b++;`
+
+### O operador de decremento:
+
+*   `--` é conhecido como o operador de decréscimo. Diminui o valor de uma variável inteira por 1.
+
+Os 2 tipos de decréscimo:
+
+*   Pre decrement primeiro decrementa o valor e, em seguida, usa-o. Exemplo: `int a ; --a;`
+*   Post decrement primeiro usa a variável, em seguida, diminui. Exemplo: `int b; b--;`
+
+Exemplo de operadores de incremento e 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; 
+ } 
+```
+
+SAÍDA:
+```
+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 
+```
+
+[Experimente o código você mesmo! :)](https://repl.it/Mgg4/2)
+
+### 3: Operadores Relacionais:
+
+*   Esses operadores nos dizem a relação entre dois operandos e retornam um valor booleano (0 ou 1). Se a relação é `true` então resulta em 1. Se a realção for falsa, isso resultará em 0.
+    
+*   Os 6 operadores relacionais são:
+    
+    1.  Menos que `<`
+    2.  Maior do que `>`
+    3.  Menor ou igual a `<=`
+    4.  Maior que ou igual a `>=`
+    5.  Igual a `==`
+    6.  Não é igual a `!=`
+
+### 4: Operadores Lógicos:
+
+*   Esses operadores combinam expressões para operações lógicas. Eles são :
+
+1.  Lógico E `&&` : Avalia para verdadeiro se ambos os valores forem verdadeiros.
+    
+2.  Lógica OR `||` : Avalia como verdadeiro se algum valor for verdadeiro.
+    
+3.  Lógico NÃO `!` : Se a _expressão_ for verdadeira, então _! A expressão_ é falsa. Este operador inverte o valor verdade e é um operador unário.
+    
+    ### 5\. Operadores Ternarios:
+    
+    O operador `?:` É o operador ternário, ou o _operador condicional_ , porque ele pode ser usado para substituir uma instrução `if else` , ou mesmo uma declaração `if else if` . A sintaxe:
+    
+
+`condition ? ValueIfTrue : ValueIfFalse` . Isso se expande para:
+
+```cpp
+if(condition) 
+ ValueIfTrue; 
+ else ValueIfFalse; 
+```
+
+Chamar `ValueIfTrue` um valor é um pouco errado, já que não precisa ser um número. Algo assim:
+
+`condition ? FirstLevelTrueValue : ConditionIfFalse ? SecondLevelTrueValue : SecondLevelFalseValue` também funciona e é interpretado da seguinte maneira `if else if` :
+
+```cpp
+if(condition) 
+ FirstLevelTrueValue; 
+ else if(ConditionIfFalse) 
+ SecondLevelTrueValue; 
+ else SecondLevelFalseValue; 
+```
+
+Da mesma forma, instruções `if` aninhadas também podem ser feitas usando operadores ternários.
+
+_Camper, agora você sabe quais são as fichas. O próximo artigo será sobre_ _PARABÉNS_
+
+**Boa sorte para todos vocês**
+
+**Codificação Feliz! :)**
+

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

guide/portuguese/cplusplus/vector/index.md

@@ -0,0 +1,211 @@
+---
+title: Vectors
+localeTitle: Vetores
+---
+## Vetores
+
+O `vector` C ++ é um dos contêineres mais usados ​​em C ++. Um contêiner é uma estrutura de dados que armazena uma coleção de objetos que podem variar de ordenados (como `vector` !) A não ordenados (como `set` ). Todos os contêineres C ++ possuem um conjunto diferente de funções que permitem acessar um objeto nessa coleção, modificar e fazer um loop sobre os elementos nessa estrutura de dados.
+
+Os vetores são semelhantes aos ArrayLists em Java, pois você não precisa especificar o comprimento do contêiner. Comparado a um array onde você tem que definir o tamanho, seu tamanho depende do seu conteúdo.
+
+`std::vector` faz parte da biblioteca padrão C ++ (daí o prefixo `std::` e permite que você armazene dados contíguos do mesmo tipo de dados. NOTA: **Todos os objetos dentro de um vetor devem ser do mesmo tipo de dados**
+
+O tipo de dados armazenado em um vetor fica entre os colchetes angulares ao lado da palavra-chave vector. Por exemplo, se você gostaria de armazenar uma coleção de strings, o vetor seria `std::vector<std::string> vector_name`
+
+_NOTA_ : Você deve incluir a biblioteca de vetores sempre que usar vetores!
+
+`#include <vector>`
+
+### Construção de vetor
+
+Existem muitas maneiras convincentes de construir um vetor.
+
+Usando uma lista de iniciadores - onde os objetos são listados dentro de um conjunto de chaves: `{ }`
+
+```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 
+```
+
+Construindo-o a partir de outro vetor (isso é conhecido como construção de cópia)
+
+```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 
+```
+
+Inicializando-o com o mesmo elemento:
+
+```cpp
+std::vector<int> a(100, -1); // a is a vector of 100 elements all set to -1 
+```
+
+### Iteradores de vetores
+
+Iteradores podem ser considerados como ponteiros usados ​​especificamente para navegar em contêineres (como vetores). Os iteradores mais importantes são `begin()` e `end()` . `begin()` retorna um ponteiro para o primeiro item em um vetor ao passo que `end()` aponta para uma posição após o último item em um vetor. Como tal looping através de um vetor pode ser feito 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 
+ */ 
+```
+
+### Modificando um vetor
+
+Empurrando itens para um vetor:
+
+```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] 
+```
+
+Inserir um item em uma determinada posição é um pouco diferente. A inserção do vetor C ++ função funciona em iteradores. Ele irá inserir o item dado uma posição antes do 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] 
+```
+
+### Acesso ao elemento
+
+A biblioteca padrão fornece diferentes funções para acessar determinados elementos em seu vetor.
+
+```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" 
+```
+
+### Looping sobre elementos em um `vector`
+
+Looping sobre elementos em um C ++ `std::vector` é bem diferente do loop de elementos em um vetor em JavaScript ou Ruby. Devido ao fato do C ++ ser uma pequena abstração de C, você só pode fazer o loop de elementos usando essas pequenas variáveis ​​chamadas iteradores para acessar cada elemento. Os iteradores geralmente vêm na forma de ponteiros, que são variáveis ​​que armazenam o endereço de memória de outra variável. Você pode aprender mais sobre ponteiros [aqui](https://www.tutorialspoint.com/cplusplus/cpp_pointers.htm) . No entanto, como os iteradores agem como ponteiros (ou vice-versa), para ver para o que eles apontam, é necessário desreferencia-lo em uma variável do tipo apropriado. Como vamos fazer isso? AQUI. NÓS. 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 
+ } 
+```
+
+A partir daqui, você pode fazer todos os tipos de coisas legais, como manipular o vetor ou mexer com a ordem que quiser!
+
+### Algumas funções de membro úteis
+
+A biblioteca de modelos padrão (STL) também fornece diferentes _métodos_ para você:
+
+```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 vetor
+
+Os iteradores fornecem outro método para acessar elementos no seu vetor.
+
+Declaração Iterator.
+
+```cpp
+std::vector<int> v; 
+ //Iterator delcaration for the above vector will correspond to 
+ std::vector<int>::iterator it; 
+```
+
+Usando o iterador para imprimir elementos do vetor usando 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 através de um vetor
+
+Existem diferentes maneiras de percorrer um vetor e acessar seu conteúdo. Os seguintes formulários são equivalentes, o primeiro envolve o uso de uma expressão baseada em intervalo (desde C ++ 11), o segundo usa iteradores e o último é uma iteração baseada em índice.
+
+\`\` \`cpp
+
+# incluir
+
+# incluir
+
+// Primeiro declare o vetor std :: vector myVector {1, 2, 3, 4, 5}; // a é um vetor de 5 ints: 1, 2, 3, 4 e 5
+
+// Usando um loop baseado em intervalo (desde C ++ 11) for (int element: myVector) {// Lê como "para cada elemento no myVector" std :: cout << "O elemento é" << element << std :: endl; }
+
+// Usando um iterador std :: vector :: iterador; // Declara o iterador for (it = myVector.begin (); it! = myVector.end (); ++ ele) { std :: cout << "O elemento é" << \* ele << std :: endl; // Dereference o iterador para acessar seus dados }
+
+// Usando índices para (std :: vector :: size\_type i = 0; i! = myVector.size (); i ++) { std :: cout << "O elemento é" << myVector \[i\] << std :: endl; // Dereference o iterador para acessar seus dados }
+```
+### 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
+
+usando namespace std;
+
+int main () {
+
+vetor v {10, 5, 82, 69, 64, 70, 3, 42, 28, 0}; sort (v.begin (), v.end ());
+
+cout << "Conteúdo do vetor classificado em ordem crescente: \\ n"; para (int e: v) { cout << e << ""; }
+
+return 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
+
+usando namespace std;
+
+int main () {
+
+vetor v {10, 5, 82, 69, 64, 70, 3, 42, 28, 0}; sort (v.begin (), v.end (), maior ());
+
+cout << "Conteúdo do vetor classificado em ordem crescente: \\ n"; para (int e: v) { cout << e << ""; }
+
+return 0; } \`\` \`

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

@@ -0,0 +1,37 @@
+---
+title:While-loop
+localeTitle: undefined
+---
+Uma instrução while loop executa repetidamente uma instrução de destino, desde que uma determinada condição seja verdadeira.
+
+Sintaxe: while (condição) { afirmações); }
+
+Um ponto-chave do loop while é que o loop pode não ser executado. Quando a condição é testada e o resultado é falso, o corpo do loop será ignorado e a primeira instrução após o loop while será executada.
+
+Exemplo:
+
+```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; 
+ } 
+```
+
+Saída:
+
+valor de: 10 valor de um: 11 valor de: 12 valor de: 13 valor de a: 14 valor de: 15 valor de um: 16 valor de: 17 valor de um: 18 valor de um: 19
+
+### Fontes
+
+www.tutorialspoint.com