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;

}