Olá Natan, td bem? espero que sim!

há um equívoco na função "calcular()", pois ela gera um valor diferente do resultado esperado. Esse bug ocorre na expressão :

for (int i = 0; i < potencia; i ++)
    {
        (*resultado) = base * base; // o bug está nessa linha;
    }

o resultado aq sempre será "base * base", isso não vai iterar, tornando o laço "for()" inutilizado. vamos ver um "debug" de como esse codigo funciona com a base 5 e expoente 3;

base = 5
expoente = 3
resultado = 0

iterar de 0 ate expoente (3x)

resultado =  5 * 5 
//resultado vai ser 25;

//proximo laço
resultado =  5 * 5 
//resultado vai ser 25;

//proximo laço
resultado =  5 * 5 
//resultado vai ser 25;

//fim do laço

O resultado esperado de 5^3 seria 125, mas o código retornou como resultado 25.

isso poderia ser corrigido com o operador "+=", assim o resultado iria incrementando, mas nessa expressão isso ia continuar fora do esperado, pois está sendo calculado a operação matemática:

resultado = expoente * (base * base) 

//se base base = 5 e expoente = 3 resultado = 75;
//mas o resultado da operação deveria retornar 125;

segue o código corrigido e funcional:

#include <stdio.h>

//a função retorna o resultado da operação, assim ela fica mais generiaca
int calcularPotencia(int base, int expoente){
  
  //se expoente == 0, o resultado é 1
  if(expoente == 0) { return 1; }

  //se expoente > 0, já vamos iniciar o resultado como a base 
  int resultado = base;

  //por já ter iniicado o resultado, vamos inicializar o iterador como 1
  for (int i = 1; i < expoente; i ++)
  {
    resultado *= base; //o mesmo que resultado = resultado * base;
  }

  return resultado;
}

int main(){

    int base, potencia;
    printf("Informe o valor da base ");
    scanf("%d", &base);
    printf("Informe o valor da potencia");
    scanf("%d", &potencia); 

    //como a função ficou generica, ela fica mais versátil
    int resultado = calcularPotencia(base, potencia);
    printf("resultado: %d\n", resultado);
    
    return 0;
}

espero ter ajudado :) Bons estudos!

Eu também criei um código em que a base e expoente são passados por argumento de linha de comando. No Linux se executa da seguinte maneira:

./executavel.out [base] [expoente]

um exemplo é:

./potencia.out 5 3
Potencia: 5 ^ 3 = 125

segue o código fonte:

#include<stdio.h> //printf()
#include <stdlib.h> //atoi()
#include <stdbool.h> //"true" e "false"
#include<math.h> //pow()

//declaração das funções
float potencia(int base, int expoente);
void mensagem_arg_invalidos();
int argumentos_validos(int argc); 

int main(int argc, char** argv){ 
  
  //verifica se os argumentos passados são validos
  if(!argumentos_validos(argc)) 
  { 
    mensagem_arg_invalidos(); 
    return 1;
  }
  
  //converte os argumetos (cadeia de char) em inteiros (int)
  // atoi(char c[]) : converte uma cadeia de caracteres em int 
  int base = atoi(argv[1]); 
  int expoente = atoi(argv[2]);

  //print no resultado!
  printf("Potencia: %d ^ %d = %1.f\n", base, expoente, potencia(base,expoente));

    return 0;
}

//implementação das funções

//retorna a potencia
float potencia(int base, int expoente)
{ return pow(base, expoente); }

//mensagem de erro para numero de args invalida
void mensagem_arg_invalidos()
{
  printf("numero de argumentos invalidos!\n");
  printf("o executavel deve receber 2 argumentos! NOTE:\n");
  printf("[programa] [base] [expoente]\n");
}

//confere se numero de args eh valido
//uso de operador ternario
int argumentos_validos(int argc) 
{ return (argc == 3) ? true : false; }

Qualquer coisa estou a total disposição! Bons estudos :)