Desafio Go

Struct anônima e comparação de fatias

Enunciado

Defina uma struct anônima para representar um ponto com coordenadas X e Y (int). Crie uma fatia com três pontos, imprima cada um e depois compare dois pontos para verificar se são iguais. Use uma struct anônima dentro de um slice.

Requisitos

  • Declarar uma struct anônima com campos X e Y.
  • Criar uma fatia com três instâncias dessa struct anônima.
  • Imprimir cada ponto e comparar dois deles com ==, mostrando o resultado.

Código inicial

package main

import "fmt"

func main() {
	// Crie a struct anônima, a fatia e faça a comparação
}

Saída esperada

Ponto 0: {1 2}
Ponto 1: {3 4}
Ponto 2: {1 2}
P0 == P2? true
Ver dica

Você pode declarar a struct anônima diretamente na declaração da fatia: pontos := []struct{ X, Y int }{...}. Para comparar, acesse os elementos pelo índice.

Mostrar solução 
package main

import "fmt"

func main() {
	// Struct anônima dentro de uma fatia.
	pontos := []struct {
		X, Y int
	}{
		{1, 2},
		{3, 4},
		{1, 2},
	}

	// Imprime cada ponto com seu índice.
	for i, p := range pontos {
		fmt.Printf("Ponto %d: %v\n", i, p)
	}

	// Compara o primeiro com o terceiro ponto.
	fmt.Println("P0 == P2?", pontos[0] == pontos[2])
}

Passo a passo

  1. Declaramos pontos como uma fatia de struct anônima: []struct { X, Y int }. A struct não tem nome, mas seus campos são X e Y do tipo int.
  2. Inicializamos a fatia com três literais posicionais: {1, 2}, {3, 4} e {1, 2}. Como a struct é anônima, não precisamos repetir o tipo em cada elemento.
  3. Usamos for i, p := range pontos para percorrer a fatia. i é o índice e p é uma cópia do elemento.
  4. fmt.Printf imprime cada ponto no formato {X Y} usando %v.
  5. Comparamos pontos[0] == pontos[2] com ==. Como os campos são int, a comparação é válida e resulta em true.

Por que funciona

Structs anônimas são tipos completos, mesmo sem nome. Elas podem ser usadas em fatias, mapas e funções. A comparação com == funciona porque todos os campos são comparáveis. O resultado true indica que os valores dos campos são iguais, não que são o mesmo objeto (structs são valores).

Erros comuns

  • Esquecer a palavra-chave struct na declaração: []struct{ X, Y int } é correto; []{ X, Y int } não compila.
  • Tentar comparar structs com campos não comparáveis: se adicionar um campo []int, a comparação com == gera erro de compilação.
  • Confundir cópia com referência: p := pontos[0] cria uma cópia; modificar p não altera a fatia. Para modificar, use pontos[0].X = ....

Outra forma de resolver

Você pode definir um tipo nomeado para reutilizar a struct:

type Ponto struct{ X, Y int }
pontos := []Ponto{{1, 2}, {3, 4}, {1, 2}}

Isso é preferível quando a struct é usada em vários lugares, pois melhora a legibilidade e permite métodos.

Saída esperada

Ponto 0: {1 2}
Ponto 1: {3 4}
Ponto 2: {1 2}
P0 == P2? true