Mudanças nas primeiras seções

docs/tutorial/secao012.md

@@ -159,8 +159,8 @@ int main()
 {
   Pessoa pessoa("John Doe", 30); // Chama o primeiro construtor
 
-  Pessoa pessoa("John Doe"); // Chama o segundo construtor
+  Pessoa pessoa("John Doe");     // Chama o segundo construtor
 
-  Pessoa pessoa(30); // Chama o teceiro construtor
+  Pessoa pessoa(30);             // Chama o terceiro construtor
 }
 ```

docs/tutorial/secao1.md

@@ -4,11 +4,10 @@ Seção 1 - Opções e Configurando o Ambiente
 
 Primeiramente, precisamos configurar o ambiente de programação para conseguirmos começar a programar.
 
-Mas, o que seria um ambiente de programação? No caso, iremos te dar opções de IDE's.
+Mas, o que seria um ambiente de programação?
 
-- IDE(Ambiente de Desenvolvimento Integrado) é um programa que reúne ferramentas para ajudar o desenvolvedor.
-
-Existe várias IDE's para C++ e iremos te dar algumas opções:
+- Uma IDE (Ambiente de Desenvolvimento Integrado) é um programa que reúne ferramentas para ajudar o desenvolvedor.
+Existem várias IDEs para C++ e iremos te dar algumas opções:
 
 - <a href="https://sourceforge.net/projects/falconcpp" target="_blank" rel="noreferrer">Falcon C++</a>
 
@@ -18,6 +17,10 @@ Existe várias IDE's para C++ e iremos te dar algumas opções:
 
 ![Code::Blocks](../.vuepress/assets/codeblocks.png)
 
+- <a href="https://www.qt.io/download" target="_blank" rel="noreferrer">CodeBlocks</a>
+
+![Qt Creator](../.vuepress/assets/qt.png)
+
 - <a href="https://repl.it" target="_blank" rel="noreferrer">Repl.it</a>
 
 ![Repl.it](../.vuepress/assets/replit.png)

docs/tutorial/secao2.md

@@ -1,22 +1,22 @@
 # 2 - Um pouco de teoria
 
-A CPU de um computador é incapaz de falar em C++. O conjunto limitado de instruções que uma CPU pode entender diretamente é chamado de código de máquina (ou linguagem de máquina ou um conjunto de instruções).
+A CPU de um computador é incapaz de diretamente entender C++. O conjunto limitado de instruções que uma CPU pode entender é chamado de código (ou linguagem) de máquina, e é composto de diversos códigos de operação (_opcodes_). 
 
-Aqui está uma instrução de linguagem de máquina de amostra: 101101010.
+Um exemplo de uso de _opcode_ se encontra em `imul    eax, eax`, que efetua a multiplicação em arquiteturas X86, e é tradicionalmente representado por 0x0FAF ou 111110101111.
 
-Quando os computadores foram inventados pela primeira vez, os programadores tinham que escrever programas diretamente em linguagem de máquina, o que era uma coisa muito difícil e demorada de se fazer.
+Durante muitos anos programadores haviam de escrever programas diretamente em linguagem de máquina, o que era algo muito difícil e demorado de se fazer, por diversos motivos.
 
 Como essas instruções estão organizadas está além do escopo desta introdução, mas é interessante notar duas coisas. Primeiro, cada instrução é composta por uma sequência de 1 e 0. Cada indivíduo 0 ou 1 é chamado de dígito binário ou bit para abreviar. O número de bits que compõem um único comando varia - Por exemplo, algumas CPUs processam instruções que são sempre de 32 bits, enquanto algumas outras CPUs (como a família x86, que você provavelmente está usando) têm instruções que podem ser comprimento variável.
 
 Cada conjunto de dígitos binários é interpretado pela CPU em um comando para fazer um trabalho muito específico, como comparar esses dois números, ou colocar esse número nesse local de memória. No entanto, como CPUs diferentes têm conjuntos de instruções diferentes, instruções que foram escritas para um tipo de CPU não puderam ser usadas em uma CPU que não compartilhava o mesmo conjunto de instruções. Isso significava que os programas geralmente não eram portáveis ​​(utilizáveis ​​sem grandes retrabalhos) para diferentes tipos de sistema e precisavam ser escritos novamente.
 
-Para resolver as questões de legibilidade e portabilidade, novas linguagens de programação, como C, C ++, Pascal (e mais tarde, linguagens como Java, Javascript e Perl) foram desenvolvidas. Essas linguagens são chamadas de linguagens de alto nível, pois são projetadas para permitir que o programador escreva programas sem ter que se preocupar com o tipo de computador no qual o programa será executado.
+Para resolver as questões de legibilidade e portabilidade, novas linguagens de programação, como C, C ++, Pascal foram desenvolvidas, com compiladores que permitem executar um mesmo código em diversas arquiteturas diferentes.
 
-# O que é C++?
+ Linguagens são classificadas pelos seus níveis de abstração. Por exemplo, C é uma linguagem de baixo nível, pois é sintáticamente próxima de linguagem de máquina, necessitando do programador controles mais manuais ao _hardware_, como controle de memória, evitar acessos e escritas indevidas de memória, e etc. Linguagems alto nível, como Java, são mais fáceis de se codificar, mas tradicionalmente sofrem em performance, assim como muitas vezes dificultam maior controle ao hardware.
 
-C++ (pronunciado como C plus plus) foi desenvolvido por Bjarne Stroustrup no Bell Labs como uma extensão para C, começando em 1979. C++ adiciona muitos recursos à linguagem C, e pode ser considerado um "superconjunto" do C.
-
-O C++ tem uma enorme variedade de códigos, pois alem de seus códigos, pode contar com vários da linguagem C. Esta variedade possibilita a programação em alto e baixo níveis. O C++ apresenta grande flexibilidade, embora seja bom, este fato faz com que a programação seja muito mais cuidadosa para não terem erros.
+A grande vantagem do C++ é sua flexibilidade, isto é, a possibilidade de criar programas de baixo nível, assim como abstrações de mais alto nível, mantendo ainda performance similar à do C. Por este motivo, C++ é tradicionalmente usado em engenharia de sistemas, em programas com necessidade de performance, como em computação gráfica, inteligência artificial, etc.
 
 
+## O que é C++?
 
+C++ (pronunciado como C plus plus) foi desenvolvido por Bjarne Stroustrup no Bell Labs como uma extensão para C, começando em 1979. C++ adiciona muitos recursos à linguagem C, e pode ser considerado um "superconjunto" do C.

docs/tutorial/secao3.md

@@ -23,13 +23,13 @@ int main ()
 
 - A seguir, iremos explicar todos os conceitos por trás deste `Hello World`:
 
-# Sequência
+### Sequência
 
 - O procedimento de código é de cima para baixo e com conteúdos em sequência, separados por `;`
 
 - Será melhor explicado na seção de variáveis.
 
-# Bibliotecas
+### Bibliotecas
 
 ```cpp{0}
 #include <iostream>
@@ -53,7 +53,7 @@ int main() {}
 
 - Todo o procedimento do seu código inicia-se nesta função.
 
-- `{}` é o que chamamos de <strong>escopo</strong>, o que for declarado des de seu início `{` até seu fim `}` irá existir apenas dentro dele.
+- `{}` é o que chamamos de <strong>escopo</strong>, o que for declarado desde seu início `{` até seu fim `}` irá existir apenas dentro dele.
 
 - Como `main` é uma função, precisamos colocar `()` após a declaração de seu nome.
 

docs/tutorial/secao5.md

@@ -58,7 +58,7 @@ int main ()
 {
     int numero = 3 // variavel numero de tipo inteiro que recebe o valor '3'
 
-    /**
+    /*
     Podemos também comentar trechos de código
     que não quisermos utilizar em um
     determinado momento
@@ -126,7 +126,7 @@ int main ()
 ```
 # Entrada de Dados com `std::cin`
 
-Agora iremos falar do `std::cin`(c in) da biblioteca `<iostream>`, ela permite a entrada de dados,sendo sua sintaxe parecida com a do `std::cout`
+Agora iremos falar do `std::cin` da biblioteca `<iostream>`, ela permite a entrada de dados,sendo sua sintaxe parecida com a do `std::cout`
 
 ```cpp{0}
 std::cin >> <variavel>;
@@ -158,7 +158,7 @@ int main ()
 
 - Lembrando que `std::cout << "Digite a idade do aluno: " << std::endl;` é apenas visual para a interação de programa-usuário.
 
-- Existe outras formas de inicialização:
+- Existem outras formas de inicialização:
 
 ```cpp{0}
 #include <iostream>

docs/tutorial/secao6.md

@@ -17,7 +17,7 @@ Operadores de comparação:
 
 Condições são comparações que retornam `verdadeiro` ou `falso` para executar ou não um `bloco(escopo)`.
 
-#`if` (se) `else if` (se senão) `else` (senão)
+`if` (se) `else if` (se senão) `else` (senão)
 
 ```cpp{0}
 #include <iostream>
@@ -31,13 +31,15 @@ int main ()
      *|--------------------------------------|
      */
 
-    char sexo = 'M'; // Declaramos a variável `sexo` do tipo `char` e inicializamos com o caractere `M`
+    char sexo = 'M';    // Declaramos a variável `sexo` do tipo `char` e inicializamos com o caractere `M`
 
     // Queremos comparar para saber se `sexo` é masculino(M) ou feminino(F)
-    if(sexo == 'M')  // Verificando se sexo é igual ao caractere M
-    {// Se a comparação for `verdadeira`, que é o nosso caso, entrará neste escopo
+    if(sexo == 'M')     // Verificando se sexo é igual ao caractere M
+    {
+        // Se a comparação for `verdadeira`, que é o nosso caso, entrará neste escopo
         std::cout << sexo << " e masculino" << std::endl;
-    } // if, else if e else são uma sequência, então assim que o escopo de uma condição acabar podemos colocar em sequência
+    } 
+    // if, else if e else são uma sequência, então assim que o escopo de uma condição acabar podemos colocar em sequência
     else // Como se tem apenas duas opções `M` e `F`, não precisamos usar o `else if`, em caso de precisar fazer outras comparações em uma mesma cadeia, teríamos que usar `else if` e `else` apenas para a última opção que não necessita de comparação
     {
         std::cout << sexo << " e feminino" << std::endl;
@@ -50,8 +52,6 @@ int main ()
 ```cpp{0}
 #include <iostream>
 
-#include <iostream>
-
 int main () 
 {
     /*|--------------------------------------|
@@ -171,7 +171,7 @@ int main ()
     std::cout << "Digite um segundo numero: \n";
     std::cin >> numero2;
 
-    std::cout << "Digite uma opção: (A)Soma / (B) Subtracao / (C) Multiplicacao / (D) Divisao \n";
+    std::cout << "Digite uma opção: (A) Soma / (B) Subtracao / (C) Multiplicacao / (D) Divisao \n";
     std::cin >> opcao;
 
     switch(opcao) // Switch de opcao

docs/tutorial/secao7.md

@@ -25,7 +25,7 @@ int main ()
      */
 
     /**
-      * Um array pode conter (quase)qualquer tipo.
+      * Um array pode conter (quase) qualquer tipo.
       * Por exemplo: int, float, double, std::string
       * Acessar um elemento que está no array leva tempo constante,
       * falaremos mais sobre isso na seção <link pra seção de Big O Nonation>
@@ -120,14 +120,8 @@ int main ()
         std::cout << "Digite a " << (i + 1) << " idade: \n";
         std::cin >> idade[i];
 
-        if(idade[i] >= 18) 
-        {
-            adulto[i] = true;
-        }
-        else 
-        {
-            adulto[i] = false;
-        }
+        adulto[i] = idade[i] >= 18;   // Como o operador >= retorna um booleano, o vetor será corretamente preenchido.
+
         i++; // Sempre que chegar no final do loop, será interado para conseguirmos dar entrada de dados em outra posição do vetor
     }
 
@@ -156,16 +150,25 @@ Como vimos, para percorrer um vetor precisamos de um loop, para percorrer des de
 
 O `FOR` é muito parecido com o `WHILE`, mas com a vantagem de alguns "recursos" incluídos para facilitar a utilização de loop's em determinadas situações.
 
-FOR:
+De modo geral, um `for` segue a seguinte forma:
+
 ```cpp{0}
-for(int i = 0;i < <tamanho_do_vetor>; i++) {}
+for(<bloco de definições>; <bloco de critério-de-parada>; <atualização de variável>) {}
+```
+
+Pode-se definir qualquer quantidade de variáveis no bloco de definições, assim como atualizar qualquer variável no bloco de atualização, mas o bloco de critério de parada deve *sempre* se tratar de uma expressão booleana.
+
+Normalmente, é utilizado da seguinte maneira:
+
+```cpp{0}
+for(int i = 0; i  <tamanho_do_vetor>; i++) {}
 ```
 
 `int i = 0` é o valor inicializado.
 
 `i < <tamanho_do_vetor>` é a condição para o for continuar.
 
-`i++` é o valor que vai ser iterado ao final do loop, igual utilizamos nos exemplo anterioes com `i++` no final de cada loop.
+`i++` é o valor que vai ser iterado ao final do loop, assim como utilizamos nos exemplos anteriores com `i++` no final de cada loop.
 
 * Lembrando que poderia ser qualquer outro valor no `i++`, utilizamos como padrão para avançar a próxima posição no vetor
 
@@ -191,6 +194,8 @@ int main ()
 }
 ```
 
+Para ler, e exibir, dez números letras da linha de comando, pode-se utilizar o código abaixo:
+
 ```cpp{0}
 #include <iostream>
 

docs/tutorial/secao8.md

@@ -15,7 +15,7 @@ void nome_função ()
 }
 ```
 
-`void` são funções que retornam `nada`, também conhecidas como `procedimento`
+`void` são funções que não retornam valor algum, também conhecidas como *procedimento*.
 
 Exemplos:
 
@@ -85,7 +85,7 @@ int main ()
 }
 ```
 
-Como já discutimos em seções anteriores, quando declaramos `tipo a` ou `tipo a = valor` ele existe apenas no escopo onde foi criado, e que chamamos de declaração na memória `stack`(teremos uma seção especificamente para memória `stack` e `heap`)
+Como já discutimos em seções anteriores, quando declaramos `tipo a` ou `tipo a = valor` ele existe apenas no escopo onde foi criado, e que chamamos de declaração na memória `stack` (teremos uma seção especificamente para memória `stack` e `heap`)
 
 Então os parâmetros existem `APENAS` nas funções, no caso a função `CalcularSoma()` não reconhece os inteiros declarados no `main()`
 
@@ -176,7 +176,7 @@ Mas, temos um porém:
 
 `n1` continua com o mesmo valor, pois `a` só existe dentro da função
 
-Da mesma forma que funções void's retornam nada, temos também funções int,float,char... que retornam o seu tipo
+Da mesma forma que funções voids retornam nada, temos também funções int,float,char... que retornam o seu tipo
 
 ```cpp{0}
 #include <iostream>
@@ -283,7 +283,7 @@ Podemos retornar a função main para indicar que tudo ocorreu bem por conseguir
 
 Caso nada seja retornado pela função main, 0 é assumido.
 
-Temos a biblioteca `<cstdlib>` que possui `EXIT_SUCCESS`, considerado uma convensão para programas em C++
+Temos a biblioteca `<cstdlib>` que possui `EXIT_SUCCESS`, considerado uma convensão para programas em C++.
 
 ```cpp{0}
 #include <iostream>

docs/tutorial/secao9.md

@@ -84,3 +84,33 @@ Consequentemente, nosso programa será compilado e vinculado corretamente.
 Se você receber um erro do compilador indicando que media.h não foi encontrado, verifique se o arquivo está realmente com o nome add.h. Dependendo de como você o criou e o nomeou, é possível que o arquivo tenha sido nomeado como add (sem extensão) ou media.h.txt ou media.hpp. Verifique também se ele está no mesmo diretório que o restante dos seus arquivos de código.
 
 Se você receber um erro do vinculador sobre a adição de função não ser definida, inclua media.cpp em seu projeto para que a definição de adição de função possa ser vinculada ao programa.
+
+## Aviso 
+
+O pré-processador *não* checa se o arquivo a ser incluindo está sendo incluindo mais de uma vez. Isto pode se tornar um problema
+em projetos maiores, com diversos `.cpp`, visto que uma inclusão dupla de _header_ causará um problema de compilação.
+
+Para contornar este problema, podemos usar uma estratégia chamada de _header guard_, que consiste em criar uma macro que registra se aquele arquivo já foi incluido previamente.
+
+Exemplo:
+
+Em `media.hpp`
+```cpp{0}
+
+#ifndef __MEDIA                     // Caso __MEDIA não for definido ..
+#define __MEDIA                     // .. definiremos __MEDIA e incluiremos o header
+int media(int a, int b, int c);
+
+    // ...
+
+#endif                              // Finalizando o ifndef
+```
+
+Ou seja, quando o arquivo for incluído uma vez, `__MEDIA` será definido. Quando o arquivo for incluído novamente, o pré-processador verá que `__MEDIA` já foi definido e não incluirá o _header_.
+
+Uma outra alternativa menos portátil é usar um *pragma*.
+```cpp{0}
+
+#pragma once                        // Garante que o arquivo seja incluido apenas uma vez.
+int media(int a, int b, int c);
+```