----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

#include <string>
#include <iostream>
#include <iomanip>

// vamos definir a ordem da matriz
#define ORDEM 3 // 3 linhas e 3 colunas

using namespace std;

// protótipo das funções
int calcular_determinante(int matriz[ORDEM][ORDEM], int ordem);
void calcular_cofator(int mat[ORDEM][ORDEM], int temp[ORDEM][ORDEM],
  int p, int q, int ordem);

int main(int argc, char *argv[]){
  // variáveis auxiliares
  int i, j, determinante;
 
  // e agora criamos a matriz. Podemos definir os elementos
  // diretamente ou pedir para o usuário informar os valores
  int matriz[ORDEM][ORDEM] = {{1, 3, 0}, {0, 2, 5}, {2, 4, 4}}; 
 
  // mostramos a matriz completa
  cout << "A matriz e:\n\n";
    
  for (i = 0; i < ORDEM; i++) {
    for (j = 0; j < ORDEM; j++){
      cout << setw(5) << matriz[i][j];
    }
    cout << "\n";
  }
    
  // vamos calcular o determinante usando o Teorema de Laplace
  determinante = calcular_determinante(matriz, ORDEM);
    
  // e mostramos o resultado
  cout << "\nO determinante da matriz e: " << determinante << endl;
  cout << "\n" << endl;
  
  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS; 
}

// função recursiva que encontra e retorna o determinante de uma
// matriz de qualquer ordem
int calcular_determinante(int matriz[ORDEM][ORDEM], int ordem){
  int determinante = 0; // para guardar e retornar o determinante
  // matriz de cofatores
  int cofatores[ORDEM][ORDEM];
  // para guardar o sinal de multiplicação
  int sinal = 1;
    
  // variáveis auxiliares nesta função
  int f;  
    
  // caso base da recursividade:
  // se a matriz possuir apenas um elemento, retorna ele
  if (ordem == 1){
    return matriz[0][0];
  }
 
  // vamos percorrer cada um dos elementos da primeira linha    
  for (f = 0; f < ordem; f++) {
    // vamos obter o cofator de matriz[0][f]
    calcular_cofator(matriz, cofatores, 0, f, ordem);
    determinante = determinante + (sinal * matriz[0][f]
      * calcular_determinante(cofatores, ordem - 1));
 
    // alterna o sinal
    sinal = -sinal;
  }
 
  // retorna o determinante
  return determinante;
} 
  
// função para retornar o cofator de mat[p][q] em temp[][]
// ordem é a ordem atual da matriz mat[][]
void calcular_cofator(int mat[ORDEM][ORDEM], int temp[ORDEM][ORDEM],
  int p, int q, int ordem){
  // nos parâmetros, p indica linha e q indica coluna
    
  // variáveis auxiliares
  int i = 0, j = 0;
 
  // percorre cada um dos elementos da matriz recebida
  for (int linha = 0; linha < ordem; linha++) {
    // percorre as colunas
    for (int coluna = 0; coluna < ordem; coluna++) {
      // copia para a matriz temporária apenas os
      // elementos que não se encaixam na linha
      // e coluna informadas
      if (linha != p && coluna != q) {
        temp[i][j++] = mat[linha][coluna];
        // preenchemos a linha. Hora de aumentar
        // o índice da linha e resetar o índice
        // da coluna
        if (j == ordem - 1) {
          j = 0;
          i++;
        }
      }
    }
  }
}

A matriz é:

    1    3    0
    0    2    5
    2    4    4

O determinante da matriz é: 18

Série:  0  1  1  2  3  5  8  13  21  34  55  89 
Índice: 0  1  2  3  4  5  6   7   8   9  10  11 

int fibonacci(int indice){
  // sua implementação aqui
}

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

#include <string>
#include <iostream>

using namespace std;

// assinatura da função recursiva
int fibonacci(int indice);

int main(int argc, char *argv[]){
  // variáveis usadas na resolução do problema
  int indice;
  
  // vamos solicitar o índice do número de Fibonacci
  cout << "Informe o índice: ";
  // lê o índice
  cin >> indice;
    
  // calcula o número de Fibonacci no índice informado
  cout << "O número de Fibonacci no índice informado é: " <<
    fibonacci(indice) << endl;
  
  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS; 
}

// função recursiva que o número de Fibonacci em um determinado índice
int fibonacci(int indice){
  if(indice == 0){ // caso base; interrompe a recursividade
    return 0;
  }
  else if(indice == 1){ // caso base; interrompe a recursividade
    return 1;
  }
  else{ // efetua uma nova chamada recursiva
    return fibonacci(indice - 1) + fibonacci(indice - 2);
  }
}

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

#include <iostream>

using namespace std;

class Cliente{
public:
  char *nome;
};

int main(int argc, char *argv[])
{
  // Cria uma instância da classe Cliente
  Cliente *cliente = new Cliente();

  // Define o nome do cliente
  cliente->nome = "Osmar J. Silva";

  // Obtém o nome do cliente
  cout << "Nome do cliente: " << cliente->nome << "\n\n";

  system("PAUSE");
  return EXIT_SUCCESS;
}

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

do{
  bloco de instruções
}while(condição);

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

#include <string>
#include <iostream>

using namespace std;

int main(int argc, char *argv[]){
  // um laço do..while que conta de
  // 10 até 0
  int valor = 10;

  do{
    cout << valor << "\n";
    valor--;
  }while(valor >= 0);

  cout << "\n\n";

  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS;
}