Desafio Go

Detectando overflow em int8

Enunciado

Escreva uma função somaSegura(a, b int8) (int8, bool) que soma dois int8 e retorna o resultado e um booleano indicando se houve overflow. No main, teste com (100, 50) e (10, 20) e imprima overflow ou o valor. Use conversão explícita para int para detectar o estouro.

Requisitos

  • A função deve ter assinatura somaSegura(a, b int8) (int8, bool).
  • Detectar overflow comparando com os limites de int8 (-128 a 127).
  • Imprimir overflow quando o booleano for true.
  • Testar os pares (100, 50) e (10, 20).

Código inicial

package main

import "fmt"

func somaSegura(a, b int8) (int8, bool) {
	// implemente
	return 0, false
}

func main() {
	// teste os pares
}

Saída esperada

100 + 50 = overflow
10 + 20 = 30
Ver dica

Converta a e b para int antes de somar; o int é largo o bastante para não estourar. Depois compare com 127 e -128.

Mostrar solução 
package main

import "fmt"

// somaSegura soma dois int8 e informa se houve overflow.
func somaSegura(a, b int8) (int8, bool) {
	soma := int(a) + int(b) // converte para int (mais largo) antes de somar
	if soma > 127 || soma < -128 {
		return 0, true // overflow detectado
	}
	return int8(soma), false // conversão de volta é segura
}

func main() {
	pares := [][2]int8{{100, 50}, {10, 20}}
	for _, p := range pares {
		r, overflow := somaSegura(p[0], p[1])
		if overflow {
			fmt.Printf("%d + %d = overflow\n", p[0], p[1])
		} else {
			fmt.Printf("%d + %d = %d\n", p[0], p[1], r)
		}
	}
}

Passo a passo

  1. somaSegura recebe dois int8 e retorna (int8, bool), seguindo o padrão de Go de devolver o valor junto com um indicador de sucesso.
  2. Convertemos a e b para int com int(a) e int(b): int é largo o suficiente para representar a soma sem estourar.
  3. Comparamos soma com os limites de int8: 127 (máximo) e -128 (mínimo).
  4. Se estourou, retornamos 0, true; o valor 0 é ignorado pelo chamador.
  5. Caso contrário, convertemos de volta com int8(soma) — seguro, pois já validamos o intervalo.
  6. No main, iteramos sobre um slice de pares e imprimimos conforme o booleano.

Por que funciona

O overflow em Go é silencioso: int8(127) + int8(1) resulta em -128 sem erro. Ao promover para int, a soma fica no intervalo correto e podemos comparar com os limites de int8. Só depois de validar fazemos a conversão de volta. Esse padrão — promover, validar, reconverter — é comum ao trabalhar com tipos menores.

Erros comuns

  • Somar direto como int8: a + b com (100, 50) retorna -106 sem aviso, e a função nunca detecta overflow.
  • Comparar com math.MaxInt8 sem importar math: erro undefined: math. Nesse caso, use os literais 127 e -128.
  • Esquecer de converter de volta: retornar int onde a assinatura pede int8 gera erro de compilação cannot use soma (variable of type int) as int8 value.

Outra forma de resolver

Usar math.MaxInt8 e math.MinInt8 para deixar os limites explícitos:

import "math"
if soma > math.MaxInt8 || soma < math.MinInt8 { ... }

É preferível quando você quer evitar números mágicos e deixar claro qual tipo está sendo validado.

Saída esperada

100 + 50 = overflow
10 + 20 = 30