O objetivo de criar esse documento é servir como orientação ou design para GO que é uma linguagem procedural, algo como SOLID.
É possível fazer uma analogia entre GO com STRUCT, INTERFACES e COMPOSIÇÃO com SOLID, a ideia e pegar o por que de usar STRUCT, INTERFACES e COMPOSIÇÃO, e o que de errado seria não usar, ou o porquê de ser uma melhor forma; então vamos por partes.
Esse documento foi produzido utilizando inteligência artificial
É algo novo em cima do que já existe para uma boa programação em GO, e até em C, pois C não possui interfaces, mas boa parte da ideia é utilizada para melhorar e ter algo mais definido para construção dos projetos e ajudar na codificação, manutenção e legibilidade do código.
Algumas partes do documento exibem partes da conversa com as inteligências virtuais.

Motivos para usar ponteiros em C/C++
O objetivo aqui é mostrar boas práticas em C e o porquê de usar ponteiros, mas a ideia é virar um design em procedural, mais especificamente em GO, e até em C, pois muito do que já é usado possui diversas formas de codificar.
Um exemplo sem ponteiros em algumas questões é quase impossível de resolver ou impossível, aqui é somente um reforço para o que será explicado a seguir em programação orientada a objetos.
Especificamente em UML, existem alguns conceitos que você dificilmente vai aprender na faculdade.
É quase impossível você fazer um bom projeto em POO sem usar injeção de dependências e uma analogia com ponteiros.

Explicação de ponteiros

Os ponteiros são uma das ferramentas mais poderosas da linguagem C e C++. Eles permitem manipular diretamente endereços de memória e trazem várias vantagens:
- Acesso direto à memória: você pode acessar e modificar variáveis em locais específicos da memória.
- Eficiência: passar ponteiros para funções evita cópia de grandes estruturas ou arrays, economizando tempo e memória.
- Manipulação de arrays e strings: ponteiros são essenciais para trabalhar com vetores e cadeias de caracteres.
- Estruturas dinâmicas: permitem criar listas ligadas, árvores e outras estruturas que dependem de alocação dinâmica.
- Interoperabilidade: ponteiros são usados para interagir com hardware, bibliotecas e sistemas operacionais.

Exemplo de erro sem ponteiro
Imagine que você queira escrever uma função que altere o valor de uma variável dentro dela:
C

#include
void alteraValor(int x) {
    x = 20; // altera apenas a cópia
}
int main() {
    int numero = 10;
    alteraValor(numero);
    printf("Numero: %d\n", numero); // continua 10
    return 0;
}

O problema:
Aqui, a função recebe uma cópia da variável numero. Alterar x não afeta o original. Resultado: o valor não muda.

Solução usando ponteiro:
C

#include
void alteraValor(int *x) {
    *x = 20; // altera o valor no endereço original
}
int main() {
    int numero = 10;
    alteraValor(&numero);
    printf("Numero: %d\n", numero); // agora é 20
    return 0;
}

O motivo:
Ao passar um ponteiro (&numero), a função recebe o endereço da variável original. Assim, ao modificar *x, você altera diretamente o valor armazenado na memória, e não apenas uma cópia.

Manipulação de arrays e strings: ponteiros são essenciais para trabalhar com vetores e cadeias de caracteres?
Ótimo ponto! Vamos ver na prática como ponteiros são essenciais para manipular arrays e strings em C.

1. Arrays e Ponteiros

Em C, o nome de um array é, na verdade, um ponteiro para o primeiro elemento. Isso significa que podemos percorrer o array usando ponteiros:
C

#include 
int main() {
    int numeros[] = {10, 20, 30, 40, 50};
    int *ptr = numeros; // ponteiro para o primeiro elemento
    for (int i = 0; i < 5; i++) {
        printf("Elemento %d: %d\n", i, *(ptr + i));
    }
    return 0;
}

O que acontece:
- numeros é equivalente a &numeros[0].
- *(ptr + i) acessa o valor na posição i.
- Isso mostra como ponteiros permitem percorrer arrays sem usar índices diretamente.

2. Strings e Ponteiros

Strings em C são arrays de caracteres terminados em \0. Ponteiros são usados para manipular cada caractere:
C

#include 
int main() {
    char texto[] = "Copilot";
    char *p = texto;
    while (*p != '\0') {
        printf("%c ", *p); // imprime caractere atual
        p++;               // avança para o próximo
    }
    return 0;
}

O que acontece:
- p aponta para o primeiro caractere da string.
- *p acessa o caractere atual.
- p++ move o ponteiro para o próximo caractere.
- Isso permite percorrer a string sem precisar de índices.

3. Exemplo de Função que Manipula String com Ponteiro

C

#include 
void maiuscula(char *s) {
    while (*s != '\0') {
        if (*s >= 'a' && *s <= 'z') {
            *s = *s - 32; // converte para maiúscula
        }
        s++;
    }
}
int main() {

    char palavra[] = "ponteiros";

    maiuscula(palavra);

    printf("Resultado: %s\n", palavra);

    return 0;

}

O motivo:
- A função recebe um ponteiro para a string.
- Alterações feitas em *s afetam diretamente a string original.
- Sem ponteiros, seria impossível modificar a string passada para a função sem retornar uma cópia.

Conversa com Coplilot, sobre o que ele acha da ideia de um desgin para o GO.
O Copilot disse:
"Perfeito, entendi sua ideia: você quer construir uma espécie de guia de orientação/diretrizes de design para Go, inspirado em princípios como o SOLID do mundo orientado a objetos, mas adaptado ao estilo procedural/estrutural de Go.
Go não é orientado a objetos no sentido clássico (não tem herança, classes), mas oferece structs, interfaces e composição como mecanismos para organizar código. Então, sim, dá para traçar uma analogia com SOLID e mostrar porque usar essas construções e o que acontece se NÃO USAR."