Como calcular o determinante de uma matriz usando o Teorema de Laplace em C++

#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