Implementar a função EXP com as seguintes características:
Retorna 1 se foi bem sucedida e 0 se a exponenciação não pôde ser calculada devido a estouro.

Passo 1

Beleza, o enunciado pede pra gente criar uma função chamada EXP que calcula a exponenciação inteira de um “base” elevado a um “expoente”. Se der tudo certo, a função retorna 1; se ocorrer overflow (estouro do valor inteiro), ela deve retornar 0.
Conteúdo: aritmética inteira e detecção de overflow em C.
O que vamos precisar:
  • Um laço que multiplica repetidamente a base.
  • Saber o valor máximo que um int pode armazenar (INT_MAX em <limits.h>).
  • Uma condição antes de cada multiplicação pra checar se vamos ultrapassar esse limite.

Passo 2

Primeiro, entenda o que é overflow: em C, quando o resultado de uma operação aritmética excede o maior valor que o tipo comporta, o valor “dobra” de forma errada (undefined behavior). Pra evitar isso, a gente faz uma checagem prévia. Se res for o resultado até agora e b for a base, antes de fazer res *= b a gente garante:
|res| <= INTMAX|b|
Assim não corre o risco de res * b ultrapassar INT_MAX.

Passo 3

Vamos montar a função em C:
  1. Incluímos <limits.h> pra usar INT_MAX.
  2. Recebemos três parâmetros: a base, o expoente e um ponteiro int *out onde guardamos o resultado.
  3. Inicializamos res = 1.
  4. Loop de i = 1 até expo:
    • Se base for zero, a gente já sabe que o resultado vai ser zero (a menos de 0^0, que podemos tratar como 1 ou entrar num caso especial; aqui vamos assumir que 0^0 = 1).
    • Antes de res *= base, checamos: |res| > INTMAX|base|
      Se isso for verdade, retornamos 0.
      - Senão, fazemos res *= base.
      5) Fora do loop, guardamos *out = res e retornamos 1.

Passo 4

Código comentado em C:
#include <limits.h>  // para INT_MAX
#include <stdlib.h>  // para abs()

int EXP(int base, int expo, int *out) {
    int res = 1;
    int i;

    // Caso especial: 0^0, vamos definir como 1
    if (base == 0 && expo == 0) {
        *out = 1;
        return 1;
    }

    for (i = 0; i < expo; i++) {
        // Se a base for zero, resultado é 0 (a não ser no caso 0^0 já tratado)
        if (base == 0) {
            res = 0;
            break;
        }
        // Checagem de overflow:
        // |res| > INT_MAX / |base|  =>  overflow se multiplicar
        if ( abs(res) > INT_MAX / abs(base) ) {
            return 0;  // estourou
        }
        res *= base;
    }

    *out = res;
    return 1;  // sucesso
}

Resposta

Função EXP em C que calcula base^expo, retorna 1 se deu tudo certo (resultado em *out) ou 0 ao detectar overflow.

Exercícios relacionados