Solucionado (ver solução)

Importante

Você está vendo a versão anterior da nova experiência da Alura que estamos preparando para você. Em breve, ela ganha uma identidade visual novinha totalmente pensada em potencializar seus estudos!

Solucionado
(ver solução)
2
respostas

[Sugestão] Começando o jogo

#include <stdio.h>
#include <stdlib.h>
#include "fogefoge.h"

char **mapa;//declara como ponteiro de ponteiro (matriz) pra depois alocar dinamicamente
int linhas;
int colunas;

void liberaMapa() {
    for (int i=0; i < linhas; i++) { //limpa a memoria a ser alocada
        free(mapa[i]);
    }
    free(mapa);
}

void alocaMapa() {
    mapa = malloc (sizeof(char*) * linhas); //pq linhas sao ponteiros de ponteiros de char, alocando as linhas
    for (int i = 0; i < linhas; i++) {//pra cada linha alocar dinamicamente as colunas
        mapa[i] = malloc (sizeof(char) * colunas+1);
    }
}

void leMapa() {
    FILE* f;
    f = fopen("mapa.txt","r");
    if(f == 0) {
        printf("Erro ao abrir mapa");
        exit(1);
    }

    fscanf(f, "%d %d", &linhas, &colunas); //le as linhas e colunas do arquivo pra poder alterar dinamicamente o mapa depois

    alocaMapa();

    for (int i=0; i < linhas; i++) {
        fscanf(f,"%s",mapa[i]);
    }

    fclose(f);
}

void imprimeMapa() {
    for (int i=0; i < linhas; i++) {
        printf("%s\n",mapa[i]);
    }
}





int main() {
    leMapa();
    imprimeMapa();
    liberaMapa();
}
2 respostas

Olá, Gabriel! Como vai?

Vi que você explorou o alocamento dinâmico de matrizes para representar o mapa do jogo com C, utilizou muito bem o ponteiro de ponteiro para manipular estruturas bidimensionais e ainda compreendeu a importância da liberação de memória para evitar vazamentos no programa.

Uma dica interessante para o futuro é sempre verificar se a alocação de memória foi bem-sucedida antes de usar o espaço alocado. Assim:

mapa = malloc(sizeof(char*) * linhas);
if (mapa == NULL) {
    printf("Erro ao alocar memoria para o mapa\n");
    exit(1);
}

Isso faz com que o programa trate falhas de alocação de forma segura, evitando comportamentos inesperados ou falhas silenciosas.

Se quiser aprofundar ainda mais, algumas boas práticas são:

  • Validação de leitura: sempre conferir o retorno de funções como fscanf para garantir que os dados foram lidos corretamente.
  • Consistência na alocação: usar calloc quando quiser garantir que a memória alocada já comece zerada.
  • Modularização: separar a lógica de manipulação do mapa em funções bem definidas, como você já começou a fazer.

Alguns materiais podem estar em inglês, mas é possível compreendê-los usando o recurso de tradução de páginas do próprio navegador.

Ah, uma pergunta: O que você acha de usar uma verificação de erro logo após cada chamada de malloc, ou prefere concentrar essa validação em uma função separada, para deixar o código de leitura do mapa mais limpo e legível?

Alura Conte com o apoio da comunidade Alura na sua jornada. Abraços e bons estudos!
solução!

É interessante demais separar em uma função especifica pra verificar se o alocamento deu certo, justamente pra ser mais legível