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:




  

Segunda, 01 de Setembro de 2014




Top 5 membros

Últimos membros online

Últimos membros cadastrados



Capa do livro
Dominando Linux Firewall Iptables


Capa do livro
Manual de Marketing em Mídias Sociais


Capa do livro
Padrões de Design para Aplicativos Móveis: Padrões de Interface de Usuário para iOS, Android e Outros





Hostnet

IMD