Palavras reservadas: Try, Catch, Throw !

/*  
     Palavras reservadas 'try', 'catch','throw'.
     *Try: Tentar executar um bloco de codigo;
     *Catch: Pegar algo para tratar;
     *Trow: Lança uma exceção(erro) que a funcão pode pegar através do 'catch'.
*/
#include <iostream>
using namespace std;

double div(double n1, double n2)
{
    if (n2 == 0)
        throw "Divisao por zero!!\n";
    return n1 / n2;
}

int fat(int n) // Fatorial.
{
    if (n < 0)
        throw "Numero negativo!!!";
    if (n == 0 || n == 1)
        return 1; // Porque fatorial de zero ou um é um.
    return n * fat(n - 1);
}

int main(int argc, char *argv[])
{
    try
    {
        cout << "Fatorial de 5: " << fat(5) << endl; // Tento executar esses blocos.

    }
    catch (const char *e) // Se ocorrer algum erro, será capturado pelos 'Catchs'.
    {                     // Exibe a frase com erro.
        cerr << "Erro: " << e << endl;
    }
    catch (...) // Você pode ter vários 'Catchs' pra capturar a exceção.
    {           // Pega qualquer outra coisa.

        cerr << "Erro inesperado!" << endl;
    }

    return 0;
}

Função main, streams e execução do programa.

#include <iostream> 
/*
    Biblioteca que contém as ferramentas para
    manipulação de entrada e saída de dados(Executa
    o fluxo de 'io'(Entrada e saida)) no c++.
    P.S: A biblioteca <iostream> é uma versão
    evoluída da <stdio.h> da linguagem C.Tem 
    implementada palavras especiais pra manipularmos
    a formatação.Traz um conjunto de instruções 
    chamados de manipuladores.
*/
using namespace std;
/*
    Em nosso código, a linha usando namespace std;
    diz ao compilador que use o namespace std (padrão).
    O namespace std inclui recursos da Biblioteca Padrão C++.
*/

/*
    O ponto de entrada de cada programa C ++ é main()
    independente do que o programa faz.
*/
int main(int argc, char *argv[])
{
    int num;
    /*
        Na maioria dos ambientes de programa,
        o destino de saída padrão padrão é a tela. Em C ++,
        cout é o objeto de fluxo usado para acessá-lo.
    */

    cout << "Digite um numero: " << endl;    // << OPERADOR DE INSERÇÃO
    /*
        O manipulador endl move-se para uma nova linha para imprimir o segundo texto.
        O operador cout não insere uma quebra de linha no final da saída.
        Uma maneira de imprimir duas linhas é usar o manipulador de endl,
        que irá colocar uma quebra de linha.
    */
    /*
        cout => CONSOLE.OUTPUT
        cout << É o nosso objeto de saída de fluxo, ou seja, passamos
        a este o que deve ser exibido no monitor.//OBJETO DE SAÍDA
    */
    cin >> num;   // >> OPERADOR DE EXTRAÇÃO
    /*
        cin => CONSOLE.INPUT
        cin >> É o nosso objeto de entrada de fluxo, ou seja,
        capturamos o que é digitado no teclado pelo nosso usuário.
    */
    
     cout << "Voce digitou " << num << endl;

    return 0;
    /*
        A última instrução no programa é a declaração de retorno.
        A linha retorna 0; termina a função principal () e faz com
        que ele retorne o valor 0 ao processo de chamada.
        Um valor não-zero (geralmente de 1) sinaliza uma terminação
        anormal.
    */
   }

Alocando Memória Dinamicamente.

É quando não sabemos a quantidade de dados que deverão ser adicionados quando o programa está em execução.

Abaixo, segue um exemplo simples:

/*

    --Alocando memória dinamicamente(Fora da pilha)--

    O C++ oferece uma área extra na memória

    com o objetivo de alocação de memória.

    conhecido pelo nome de Heap(pilha).

*/

#include <iostream>

using namespace std;

int main(int argc, char *argv[])

{

    char *p = new char[256];

    /*

        'new' é a palavra reservada para a alocação de memoria.

        No caso, a palavra-chave retorna um ponteiro para o array

        recém criado.

        A pilha de memória não é alocada até o momento de execução.

    */

    p[0] = 'a';

    p[1] = 'b';

    p[2] = 'c';

    p[3] = '\0'; // '\0' indica o final.

    cout << *p << endl;

    cout << *(p + 1) << endl;

    cout << *(p + 2) << endl;

    /*

        Quando você aloca memória fora da pilha, precisa retorná-la.

        Você retorna a memória á pilha usando a palavra reservada:

        'delete'.

    */

    delete[] p;

    p = NULL; // Zerando um ponteiro.

    return 0;

}

Simples encadeamento de operadores '<<'

// O operador >> pode ser usado de forma encadeada.

#include <iostream>

using namespace std;

int main(void)

{

  char nome[80];

  cout << "Qual o seu nome?";

  cin >> nome;

  cout << "Ola" << " " << nome << ", tudo bem?"; // encadeamento do operador '<<'

  cout << "Como voce esta?";

  cout << "Desejo-lhe uma excelente semana!";

}

Alocar/desalocar memória e zerar o ponteiro.

#include <iostream>
using namespace std;

int main(int argc, char *argv[])
{
int x = 20;    // Aloca memória
int* px;

px = &x;  // & para acessar o endereço de memória da variável x
cout << *px << endl;
delete px;  // Desaloca memória
px = NULL;  // Zera o ponteiro

return 0;

}

-----------------------------------Com Array--------------------------------------

#include <iostream>
using namespace std;

int main(int argc, char *argv[])
{
    int* ponteiro = new int[10];   // aloca memoria
    cout << "Digite um numero: ";
    cin >> *(ponteiro);
    cout << "Voce digitou: " << *(ponteiro) << endl;
    delete[] ponteiro;     // desaloca memoria
    ponteiro = NULL;   // zerando o ponteiro

    return 0;
}

Ponteiros

É uma variável que contém o endereço de outra variável na memória interna do pc.

#include <iostream> // Entrada e saída de dados
using namespace std; // Declarando espaço de nome std padrão
int main(int argc, char *argv[])
{
   int var = 10;
   int* pvar; // Ponteiro
   // Sempre inicializar um ponteiro antes de utilizá-lo

   pvar = &var; // &var é o endereço da variável var
   cout << *pvar << endl;//acessa o conteúdo da variável através do *pvar
   *pvar = 20; // muda o valor da variável através do ponteiro

   cout << var << endl;
   
   return 0;
}

Funções

São fragmentos de código que executam uma tarefa específica,determinada e que pode ser utilizada
em vários caminhos diferentes. Pode ser chamada diversas vezes em um mesmo programa.
São utilizadas para otimizar o tempo e agregar valores de direção padrão, sem que haja a necessidade de repetir o processo de elaboração.

Definição da função:

<tipo de função> nome da função( declaração dos parâmetros) // cabeçalho da função
{
  // escopo da função
  <declaração das variáveis locais>   
                                       
  Comandos que formam o corpo da função
                                       
return <valor>; // ou return; ou nada   

}

Tipos de funções:

void
int
float
double
char
struct
...

Segue abaixo, um exemplo simples de manipulação com funções:

/*

Function name: main, bool

Objective: Show how to handle functions.

return: 0

*/

#include <iostream>

#include <cstdlib>

using namespace std;

bool even(int num);

void message();

int main()

{

    int n;

    message();

    cout << "Enter number: ";

    cin >> n;

    if(even(n))

    {

        cout << "The number " << n << " is even." << endl;

    }

else

    {

    cout << "The number " << n << " is odd." << endl;

    }

    system("pause");

    return 0;

}

void message()

{

    cout << "learning C++ with fun!" << endl;

}

bool even(int num)

{

    if(num % 2 == 0)

        return true;

    return false;

}

P.S:
1- O Visual Studio Code é o editor que utilizo.  É uma Plataforma aberta, tem ferramentas de  identificação de código e de integração com o Github. Poxa, o esquema de cores é, de fato, encantador. Sem falar que suporta as principais linguagens de programação com a sintaxe e até direito a preenchimento automático! Nhamy!  
2-  O exemplo acima  saiu  muito irreverente, com espaçamentos maiores do que o que parece belo. Eu copiei e colei do meu editor para obter uma representação quase fiel(quase mesmo) dele.