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+1, sizeof(float));
if (v == NULL) {
printf ("** Erro: Memoria Insuficiente **");
return (NULL);
}
return (v); /* retorna o ponteiro para o vetor */
}
float *Liberar_vetor_real (int n, float *v)
{
if (v == NULL) return (NULL);
if (n < 1) { /* verifica parametros recebidos */
printf ("** Erro: Parametro invalido **\n");
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 (a, p);
}
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, 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 *));
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));
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 */
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 */
... /* outros comandos, inclusive inicializacao para l e c */
mat = Alocar_matriz_real (l, c);
... /* 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 |
Curso de C do CPDEE/UFMG - 1996 - 1999