Alocação dinâmica de memória em C


Autor/fonte: Carlos Roberto S. Junior
E-mail/Url: http://www.vivaolinux.com.br/artigos/verArtigo.php?codigo=7942
Tags: [ alocação dinâmica de memória ]



Digg del.icio.us

A alocação dinâmica de memória trata-se de pegar um espaço na memória maior do que era esperado, ou simplesmente pegar um espaço quando não é possível prever. Há diversas formas de se fazer isso. Em C usamos uma função malloc(); já em C++ utilizamos uma palavra reservada "new".

A desvantagem da alocação dinâmica está no rompimento da pilha de memória, o que causaria o fechamento do programa e também, com a alocação dinâmica, o programa torna-se mais lento, pois ela requer muito do processamento.

Alocação dinâmica em C

Os compiladores mais antigos (anterior a 1998) não aceitavam este trecho de código:

#include <stdio.h>
/*include*/

int main(void)
{
       unsigned short int valor;

       printf("\nDigite o tamanho da string: ");
       scanf("%d",&valor);

       char string[valor];

       printf("\nDigite a string: ");
       scanf("%s",string);
       printf("%s",string");

       return 0;
}

Este código nos novos compiladores simplesmente gerará uma aviso. Mas o programa será executado normalmente. É um tipo simples do alocação dinâmica, porém há funções que fazem isso um pouco melhor.

Utilizando o malloc(), a função está contida na biblioteca malloc.h e possui a seguinte sintaxe:

tipoDoPonteiro= malloc(valorParaAlocação * tamanhoDoTipo);

Por exemplo:

#include <stdio.h>
#include <malloc.h>
/*includes*/

int main(void)
{
       unsigned short int tamanho;
       char *string;     /*ponteiro para char, é necessário que seja uma ponteiro para ser alocado*/

       printf("\nDigite o tamanho da string: ");
       scanf("%d",&tamanho);

       string= malloc( tamanho * sizeof(char) ); /*o sizeof ajuda a aumentar a portabilidade*/
      
       printf("\nDigite a string: ");
       scanf("%s",string);
       printf("\n%s",string);

       free(string);    /*libera a memória alocada*/

       return 0;
}

A utilização do free() é altamente recomendada, pois ele devolve a memória alocada para o sistema, alguns sistemas operacionais fazem isso automaticamente quando o programa fecha, porém se ocorrer um erro você pode ficar com uma parte da memória sem utilização, tanto pelo sistema quanto pelos programas que você utiliza.

Alocação dinâmica em C - Alocando uma matriz bidimensional

Há duas formas de se alocar uma matriz xd (sendo x uma variável natural e diferente de zero).

1ª forma: Aloca dois vetores, um vetor grande com todas a linhas e colunas da matriz multiplicadas e outro somente com o número de linhas, porém este último deve ser um ponteiro de ponteiros. Depois faz-se a distribuição do vetor maior para o menor:

#include <stdio.h>
#include <malloc.h>

int main(void)
{
       unsigned short int linhas, colunas, i;
       int *vetor, **matriz; /*um vetor grande e um ponteiro para ponteiros que será a matriz*/

       printf("\nDigite o numero de linhas e colunas: ");
       scanf("%d,%d",&linhas,&colunas);

       vetor= malloc( linhas * colunas * sizeof(int) );
       *matriz= malloc( linhas * sizeof(int) );

       for(i=0;i<linhas;i++)
              matriz[ i ]= &vetor[ i * colunas];

                    /*a partir deste ponto pode ser usado matriz[a][ b ] sendo a o número da linha e b o número da coluna para qualquer parte do programa*/

        free(vetor);
        free(matriz);  /*faz a liberação da memória alocada*/

        return 0;
}

2ª forma: Aloca-se uma matriz, sendo esta ponteiro para ponteiro, primeiramente aloca-se o número de linhas e depois aloca-se o número de colunas, utilizando loops para isso. Desta forma:

#include <stdio.h>
#include <malloc.h>
/*includes*/

int main(void)
{
      unsigned short int linhas, colunas, i;
      int **matriz;

      printf("\nDigite o número de linhas e colunas: ");
      scanf("%d,%d",&linhas, &colunas);

      *matriz= malloc( linhas * sizeof( int ) );
      for(i=0;i<linhas;i++)
              matriz[ i ]= malloc( colunas * sizeof( int ) );

      /*a partir deste ponto pode ser usado matriz[a][ b ] sendo a o número da linha e b o número da coluna para qualquer parte do programa*/

        for(i=0; i<linhas; i++)
                É uma free(matriz[ i ]);
        free(matriz);  /*faz a liberação da memória alocada*/

        return 0;
}

Estes são os dois métodos para fazer a locação de uma matriz dinamicamente, para se aumentar o número de dimensões não é difícil, basta aumentar o número de ponteiros, ou seja, para 3d teríamos a seguinte declaração ***matriz (para o segundo método) ou uma matriz intermediária para o primeiro método.




Enviado por xKuRt em 18/04/2008 às 08:47


Avaliação

Esta publicação ainda não foi avaliada!


Avaliar:


A avaliação de publicações é restrita a membros cadastrados e logados no nosso site.



Comentários

Este artigo ainda não foi comentado ou o(s) comentário(s) que foi(ram) enviado(s) a ele ainda não foi(ram) publicado(s).


Envio de comentário:




  

Sexta, 31 de Outubro de 2014




Top 5 membros

Últimos membros online

Últimos membros cadastrados



Capa do livro
Scrum em Ação - Gerenciamento e Desenvolvimento Ágil de Projetos de Software


Capa do livro
Programação Neurolinguística Para Leigos


Capa do livro
Asterisk na Prática





Hostnet

IMD