----------------------------------------------------------------------
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

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

#include <iostream>

using namespace std;

int main(int argc, char *argv[]){
  // aloca memória para um objeto do tipo int
  int *ponteiro = new int;

  // vamos definir o valor para o objeto recém-alocado
  *ponteiro = 20;

  // vamos exibir seu valor
  cout << *ponteiro << endl;

  // vamos liberar a memória
  delete ponteiro;

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

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

#include <iostream>
#include <string>

using namespace std;

// declaração da classe Cliente
class Cliente{
  public:
    Cliente();
    string obterNome();
    void definirNome(string);
  private:
    string nome;
};

// implementação dos métodos da classe
Cliente::Cliente(){} // construtor vazio

// obtém o nome do cliente
string Cliente::obterNome(){
  return this->nome;
}

// define o nome do cliente
void Cliente::definirNome(string nome){
  this->nome = nome;
}

int main(int argc, char *argv[]){
  // aloca memória para um objeto da classe Cliente
  Cliente *c = new Cliente();

  // vamos definir o nome do cliente
  c->definirNome("Osmar J. Silva");

  // vamos exibir o nome do cliente
  cout << c->obterNome() << endl;

  // vamos liberar a memória usada
  delete c;

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

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

#include <iostream>
#include <math.h>
#include <cstdlib>
 
using namespace std;
 
int main(int argc, char *argv[]){
  float a = 20; // medida do cateto oposto
  float b = 30; // medida do cateto adjascente
  
  // agora vamos calcular o comprimento da hipotenusa
  float c = sqrt(pow(a, 2) + pow(b, 2));
 
  // e mostramos o resultado
  cout << "O comprimento da hipotenusa é: " << c << "\n\n";
	 
  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS;
}

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

#include <string>
#include <iostream>
#include <math.h>

using namespace std;

int main(int argc, char *argv[]){
  // vamos obter o valor da constante PI
  double pi = M_PI;

  // vamos usar o objeto cout para exibir o resultado
  cout << "O valor de PI é: " << pi << endl;

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

----------------------------------------------------------------------
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[]){
  int a, b, soma;	
	
  // vamos ler dois valores
  cout << "Informe o primeiro valor: ";
  cin >> a;
  cout << "Informe o segundo valor: ";
  cin >> b;
 
  // vamos somar os dois valores
  soma = a + b;
  
  // e agora mostramos o resultado
  cout << "A soma dos valores é: " << soma << endl;

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