Alocando espaço para uma matriz dinamicamente

Publicado por Danillo Souza (última atualização em 20/02/2010)

[ Hits: 22.788 ]

Download mataloc.c




Script com comentários detalhados mostrando como alocar dinamicamente espaço para uma matriz de tamanho determinado pelo usuário, e depois como liberar esse valor na memória.

  



Esconder código-fonte

#include <stdio.h>
#include <stdlib.h>
// AlocMat: função que vai alocar a matriz dinâmicamente
// retornando um ponteiro para a matriz(um ponteiro para ponteiros,
// por isso o ** no nome da função).
int **AlocMat(int linhas, int colunas);
// FreeMat: função que vai liberar a memória alocada pela matriz.
int **FreeMat(int linhas, int colunas, int **mat);

int main() {
   // variáveis que guardam o número de linhas e colunas que a matriz terá.
   int linhas, colunas;
   // Variáveis para servirem como contadores.
   int x, y;
   // ponteiro para ponteiros que vai receber a matriz alocada dinamicamente.
   int **matriz;
   // solicita ao usuário que entre com o número de colunase linhas que a
   // matriz terá.
   printf("Rows and columns [rows cols]: ");
   scanf("%d%d", &linhas, &colunas);
   // checa se o usuário digitou números válidos para colunas e linhas.
   if ((linhas < 1) || (colunas < 1)) {
      printf("\nFatal error! (function: main)\n");
      exit(1);
   }
   // aloca memória para a matriz usando a função AlocMat, que retorna um
   // ponteiro para ponteiros de int.
   matriz = AlocMat(linhas, colunas);
   // testa se a matriz foi alocada corretamente, e se nao foi, aborta a
   // execução do programa.
   if (matriz == NULL) {
      printf("\nFatal error! (function: main)\n");
      exit(1);
   }
   // preenche as linhas e colunas da matriz com números inteiros.
   for (x = 0 ; x < linhas ; x++) {
      for (y = 0 ; y < colunas ; y++) {
         matriz[x][y] = y + (x * 10);
      }
   }
   // exibe todos os valores armazenados na matriz em forma de árvore.
   for (x = 0 ; x < linhas ; x++) {
      printf("[%p]\n", &matriz[x]);
      for (y = 0 ; y < colunas ; y++) {
         printf("|----[%p]\t->\t%05d\n", &matriz[x][y], matriz[x][y]);
      }
   }
   // libera o espaço em memória alocado pela matriz
   FreeMat(linhas, colunas, matriz);
   
   return 0;
}

int **AlocMat(int linhas, int colunas) {
   // declara a variável 'x' que servirá como contador, e um ponteiro
   // para ponteiros '**v' que receberá a matriz alocada e será o
   // valor de retorno da função.
   int x, **v;
   // checando se os parâmetros passados são válidos.
   if ((linhas < 1) || (colunas < 1)) return NULL;
   // aloca espaço para as linhas, que será vetores para vetores, por
   // isso é necessário a conversão (int **).
   v = (int **)calloc(linhas, sizeof(int));
   // checa se as linhas foram alocadas corretamente e caso não trenham
   // sido, aborta a execução do programa.
   if (v == NULL) {
      printf("\nFatal Error! (function: AlocMat)\n");
      exit(1);
   }
   // percorre as linhas alocadas na matriz
   for (x = 0 ; x < linhas ; x++) {
      // em cada linha, aloca um vetor/ponteiro para inteiros
      // com tamanho definido pelo usuário
      v[x] = (int *)calloc(colunas, sizeof(int));
      // checa se o vetor/ponteiro foi alocado corretamente, caso não
      // tenha sido, aborta a execução do programa
      if (v[x] == NULL) {
         printf("\nFatal Error! (function: AlocMat)\n");
         exit(1);
      }
   }
   // retorna o ponteiro de ponteiros(matriz).
   return v;
}

int **FreeMat(int linhas, int colunas, int **mat) {
   // variável 'x' que servirá como contador.
   int x;
   // checa se os argumentos passados são válidos e caso não sejam,
   // a execução do programa é abortada.
   if ((linhas < 1) || (colunas < 1)) {
      printf("\nFatal Error! (function: FreeMat)\n");
      exit(1);
   }
   // se a matriz passada como parâmetro for NULL, então a função
   // retorna NULL.
   if (mat == NULL) return NULL;
   // percorre as linhas da matriz, liberando o espaço das 
   // colunas(vetores/ponteiros) em cada linha.
   for (x = 0 ; x < linhas ; x++) free(mat[x]);
   // libera a matriz em si.
   free(mat);
   // retorna NULL.
   return NULL;   
}

Scripts recomendados

Torres de Hanoi

Programa para cálculo vetorial

Consultar informação do fstab via C

Calculadora em shell

Testar o melhor método de organização C (inserção, bolha e shell-sort)


  

Comentários
[1] Comentário enviado por isaque_alves em 23/02/2010 - 02:08h

Cara, não vou negar... bastante comentado, mas do jeito que está, fica meio confuso... põe os comentários do lado direito das variáveis/expressões a que eles se refiram:
int **FreeMat(int linhas, int colunas, int **mat); // FreeMat: função que vai liberar a memória alocada pela matriz.

E sempre que necessário usa /* */ pra comentários de mais de uma linha...

Garanto que até pra você a leitura se tornará mais agradável... só uma sugestão...

[2] Comentário enviado por danltmz em 23/02/2010 - 14:22h

Ok, vou fazer isso.. nesse dia tava meio com pressa xD
mas da próxima vai estar mais agradável de se ler :)

[3] Comentário enviado por fventurajr em 08/11/2019 - 15:39h

Pelo que eu entendi, um vetor(unidimensional) de inteiros são uma sequência de ponteiros(*int) para inteiros e que para se fazer uma matriz(bidimensional) é preciso fazer um vetor de um vetor, onde cada elemento de um vetor aponta para outro vetor(**int). É inteligente, mas muito trabalhoso.


Contribuir com comentário




Patrocínio

Site hospedado pelo provedor RedeHost.
Linux banner

Destaques

Artigos

Dicas

Tópicos

Top 10 do mês

Scripts