Curso de C

Alocação Dinâmica de Vetores e Matrizes


Alocação Dinâmica de Vetores

A alocação dinâmica de vetores utiliza os conceitos aprendidos na aula sobre ponteiros e as funções de alocação dinâmica apresentados. Um exemplo de implementação para vetor real é fornecido a seguir:

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

float *Alocar_vetor_real (int n)
{
  float *v;        /* ponteiro para o vetor */
  if (n < 1) {  /* verifica parametros recebidos */
     printf ("** Erro: Parametro invalido **\n");
     return (NULL);
     }
  /* aloca o vetor */
  v = (float *) calloc (n, sizeof(float));
  if (v == NULL) {
     printf ("** Erro: Memoria Insuficiente **");
     return (NULL);
     }
  return (v);    /* retorna o ponteiro para o vetor */
}

float *Liberar_vetor_real (float *v)
{
  if (v == NULL) return (NULL);
  free(v);        /* libera o vetor */
  return (NULL);  /* retorna o ponteiro */
}

void main (void)
{
  float *p;
  int a;
  ...    /* outros comandos, inclusive a inicializacao de a */
  p = Alocar_vetor_real (a);
  ...    /* outros comandos, utilizando p[] normalmente */
  p = Liberar_vetor_real (p);
}

Alocação Dinâmica de Matrizes

A alocação dinâmica de memória para matrizes é realizada da mesma forma que para vetores, com a diferença que teremos um ponteiro apontando para outro ponteiro que aponta para o valor final, ou seja é um ponteiro para ponteiro, o que é denominado indireção múltipla. A indireção múltipla pode ser levada a qualquer dimensão desejada, mas raramente é necessário mais de um ponteiro para um ponteiro. Um exemplo de implementação para matriz real bidimensional é fornecido a seguir. A estrutura de dados utilizada neste exemplo é composta por um vetor de ponteiros (correspondendo ao primeiro índice da matriz), sendo que cada ponteiro aponta para o início de uma linha da matriz. Em cada linha existe um vetor alocado dinamicamente, como descrito anteriormente (compondo o segundo índice da matriz).

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

float **Alocar_matriz_real (int m, int n)
{
  float **v;  /* ponteiro para a matriz */
  int   i;    /* variavel auxiliar      */
  if (m < 1 || n < 1) { /* verifica parametros recebidos */
     printf ("** Erro: Parametro invalido **\n");
     return (NULL);
     }
  /* aloca as linhas da matriz */
  v = (float **) calloc (m, sizeof(float *));	/ Um vetor de m ponteiros para float */
  if (v == NULL) {
     printf ("** Erro: Memoria Insuficiente **");
     return (NULL);
     }
  /* aloca as colunas da matriz */
  for ( i = 0; i < m; i++ ) {
      v[i] = (float*) calloc (n, sizeof(float));	/* m vetores de n floats */
      if (v[i] == NULL) {
         printf ("** Erro: Memoria Insuficiente **");
         return (NULL);
         }
      }
  return (v); /* retorna o ponteiro para a matriz */
}

float **Liberar_matriz_real (int m, int n, float **v)
{
  int  i;  /* variavel auxiliar */
  if (v == NULL) return (NULL);
  if (m < 1 || n < 1) {  /* verifica parametros recebidos */
     printf ("** Erro: Parametro invalido **\n");
     return (v);
     }
  for (i=0; i<m; i++) free (v[i]); /* libera as linhas da matriz */
  free (v);      /* libera a matriz (vetor de ponteiros) */
  return (NULL); /* retorna um ponteiro nulo */
}

void main (void)
{
  float **mat;  /* matriz a ser alocada */
  int   l, c;   /* numero de linhas e colunas da matriz */
  int i, j;
  ...           /* outros comandos, inclusive inicializacao para l e c */
  mat = Alocar_matriz_real (l, c);

  for (i = 0; i < l; i++)
     for ( j = 0; j < c; j++)
	mat[i][j] = i+j;
  
  ...           /* outros comandos utilizando mat[][] normalmente */
  mat = Liberar_matriz_real (l, c, mat);
  ...
}

AUTO AVALIAÇÃO

Veja como você está. Faca um programa que multiplique duas matrizes. O programa devera' estar  estruturado de maneira que:
1- o usuario forneca as dimensoes das matrizes (teste se as dimensoes sao compativeis,  isto e', se as matrizes podem ser multiplicadas);
2- as matrizes sejam alocadas dinamicamente (voce pode usar a funcao vista nesta pagina para  isto);
3- as matrizes sejam lidas pelo teclado (faca uma funcao para leitura das matrizes);
4- as matrizes sejam, entao, multiplicadas (faca uma funcao para a multiplicacao);
5- a matriz resultante seja apresentada em tela (faca uma funcao para apresentar a matriz na tela).

OBS:
a) Faca, tambem, alocacao dinamica da matriz resultante.
b) Caso alguém não conheça o procedimento para a multiplicação de matrizes, segue aqui alguma orientação. Suponha as matrizes A(mXn)

    | a11  a12 ... a1n |
A = | a21  a22 ... a2n |
    |  :               |
    | am1  am2 ... amn |

e B(nXt)

    | b11  b12 ... b1t |
B = | b21  b22 ... b2t |
    |  :               |
    | bn1  bn2 ... bnt |

O elemento ij da matriz C é resultante da multiplicação da linha i de A pela coluna j de B. Portanto, a matriz C (mXt) = A*B será da seguinte forma:

C =
| a11*b11 +a12*b21 + ... +a1n*bn1   a11*b12 +a12*b22 + ... + a1n*bn2  ...   a11+b1t +a12*b2t + ... + a1n*bnt |
| a21*b11 +a22*b21 + ... +a2n*bn1   a21*b12 +a22*b22 + ... + a2n*bn2  ...   a21+b1t +a22*b2t + ... + a2n*bnt |
|                                   ...                                                   ...                   ...                                    ...                                    |
| am1*b11 +am2*b21 +...+amn*bn1   am1*b12 +am2*b22 +...+ amn*bn2  ...   am1+b1t +am2*b2t +...+amn*bnt |
 

Página Anterior Índice da Aula


Curso de C do CPDEE/UFMG - 1996 - 1999