PDF - VERSÃO DE IMPRESSÃO

Lição 11 - Ponteiros e alocação dinâmica

objetivo

Olá, estudante! Tudo bem com você? Espero que sim e que você esteja animado(a) para a lição de hoje que dá sequência aos conceitos de back-end depois de conhecer vetores e matrizes. Nosso objetivo é proporcionar a você uma compreensão sólida dos conceitos fundamentais de ponteiros e alocação dinâmica de memória em linguagens de programação.

Diferentemente das outras lições dessa disciplina, desta vez não iremos usar a linguagem Java para aplicar os conceitos e, sim, a linguagem C e C++. Java, foi projetada para oferecer um ambiente de programação de mais alto nível, com um gerenciamento de memória automatizado, o que significa que você, técnico em desenvolvimento de sistemas, geralmente não precisa lidar diretamente com ponteiros e alocação dinâmica de memória.

Irei introduzir o conceito de ponteiros, explicando o que são, como funcionam e por que são importantes na programação. Você aprenderá a declarar, inicializar e usar ponteiros para manipular dados e memória. Quanto à alocação dinâmica de memória, iremos discutir as diferenças entre alocação estática (em que o tamanho da memória é determinado em tempo de compilação) e alocação dinâmica (em que a memória é alocada em tempo de execução). Prepare-se. Encontro-te na problematização.

problematização

Ao longo do desenvolvimento de software, uma das problemáticas frequentes está relacionada à gestão eficiente de recursos de memória. Muitas vezes, os programas precisam alocar e liberar memória conforme a demanda, e isso pode se tornar complexo quando não se tem um controle adequado. Um dos principais cenários em que os ponteiros e a alocação de memória resolvem problemas é quando se lida com estruturas de dados de tamanho variável, como listas encadeadas, árvores binárias ou grafos. Nessas situações, é necessário alocar memória para os elementos da estrutura à medida que são criados, e liberar essa memória quando os elementos são removidos para evitar vazamentos de memória.

Além disso, em sistemas embarcados ou de baixo nível, como sistemas operacionais, drivers de dispositivos ou programas que interagem diretamente com hardware, a alocação e o gerenciamento eficiente de memória são críticos. Nesses casos, os ponteiros desempenham um papel fundamental ao permitir que o programa acesse diretamente a memória ou recursos específicos do sistema.

Portanto, a problematização que ponteiros e alocação de memória resolvem no dia a dia do desenvolvimento de software está relacionada à gestão eficiente e precisa dos recursos de memória, garantindo que a aplicação use apenas a quantidade necessária de memória e libere-a quando não for mais necessária contribuindo para a robustez, eficiência e estabilidade de programas de software em uma variedade de domínios de aplicação.

case

O case fictício de hoje é sobre uma equipe de técnicos em desenvolvimento de sistemas trabalhando em um projeto emocionante: o desenvolvimento de um sistema embarcado para controlar um robô autônomo em um ambiente industrial. O desafio foi criar um software que pudesse lidar com a complexidade das operações do robô, como navegação, reconhecimento de objetos e interação com máquinas de produção, enquanto garantia a eficiência e a confiabilidade em um hardware limitado.

O sistema embarcado tinha recursos de memória limitados, o que significava que a equipe precisava alocar e liberar memória de forma eficiente para evitar desperdício e vazamentos. Eles usaram ponteiros para gerenciar cuidadosamente a memória durante a execução do programa. Ao alocar dinamicamente a memória apenas quando necessário e liberá-la quando não era mais usada, garantiram que o sistema funcionasse de maneira otimizada. Como o hardware era limitado, a equipe precisava também otimizar o desempenho do software. Usando ponteiros, puderam criar algoritmos eficientes que minimizaram a sobrecarga de memória e maximizam a velocidade de processamento permitindo que o robô executasse tarefas complexas em tempo real.

No final, a equipe teve sucesso na criação de um sistema altamente eficiente e confiável que permitiu que o robô autônomo operasse com sucesso em ambientes industriais desafiadores. Note que o uso habilidoso de ponteiros e alocação de memória desempenhou um papel fundamental na realização desse projeto, demonstrando como são conceitos valiosos no desenvolvimento de software em sistemas embarcados.

Conceitualização

Ponteiros

Schildt (1996) define um ponteiro como uma variável que contém um endereço de memória, onde esse endereço é normalmente a posição de uma outra variável na memória. Em essência, um ponteiro ‘aponta’ para uma localização específica na memória do computador onde dados podem ser armazenados. Eles desempenham um papel fundamental em linguagens de programação de baixo nível, como C e C++, pois permitem o acesso direto à memória e a manipulação eficiente de dados. Schildt (1996) diz que os ponteiros são um dos aspectos mais fortes e mais perigosos da linguagem de programação C. Isso porque ponteiros não-inicializados, ou ponteiros selvagens podem provocar a quebra do sistema. Além disso, é fácil usar os ponteiros incorretamente, ocasionando erros que são muito difíceis de encontrar.

Para declarar e inicializar ponteiros em C ou C++, você precisa especificar o tipo de dados que o ponteiro irá apontar e, em seguida, atribuir a ele um endereço de memória válido. Sendo assim, você declara um ponteiro especificando o tipo de dados que ele apontará, seguido por um asterisco (*). Por exemplo, para declarar um ponteiro para um inteiro (int), você faria o seguinte: int *ponteiro; o código em amarelo declara um ponteiro chamado ponteiro que pode apontar para um valor do tipo int.

Agora, para inicializar um ponteiro, você pode atribuir a ele o endereço de memória de uma variável existente usando o operador de endereço &. Por exemplo:

int x = 10;

int *ponteiro = &x;

No código acima, o ponteiro é inicializado com o endereço de memória da variável x. Agora, o ponteiro aponta para a localização de memória onde o valor 10 está armazenado. Você também pode inicializar um ponteiro como nulo (null), o que significa que ele não aponta para nenhum endereço de memória válido. Isso é útil quando você deseja criar um ponteiro, mas ainda não tem um endereço de memória para atribuir a ele. Veja um exemplo: int *ponteiro = NULL; Neste caso, o ponteiro é nulo e não aponta para nenhum lugar na memória até que você o inicialize com um endereço de memória válido.

Lembre-se que, ao declarar e inicializar os ponteiros, é fundamental garantir que o tipo de dados do ponteiro corresponda ao tipo de dados da variável ou estrutura que ele apontará. Caso contrário, isso pode levar a erros de tipo e comportamento inesperado em seu programa.

Alocação de memória dinâmica

A alocação de memória é um conceito fundamental em programação, e pode ser dividida em dois tipos principais: alocação estática e alocação dinâmica. Vamos conhecer as diferenças entre elas?

Alocação Estática de Memória:

Momento de Alocação: A alocação estática ocorre em tempo de compilação, durante a fase de compilação do programa.
Tamanho Fixo: A quantidade de memória alocada é fixa e determinada em tempo de compilação. Isso significa que o tamanho da memória alocada não pode ser alterado durante a execução do programa.
Escopo de Variável: Variáveis alocadas estaticamente geralmente têm um escopo global ou local, mas seu tempo de vida é determinado pelo escopo.
Exemplos: Variáveis globais, variáveis locais estáticas e matrizes de tamanho fixo são exemplos de alocação estática de memória.
Vantagens: A alocação estática é simples e eficiente em termos de desempenho, pois não há sobrecarga associada à alocação e liberação de memória durante a execução do programa.
Desvantagens: A principal desvantagem da alocação estática é que ela não é flexível e não permite a criação de estruturas de dados de tamanho variável.

Alocação Dinâmica de Memória:

Momento de Alocação: A alocação dinâmica ocorre em tempo de execução, durante a execução do programa, usando funções como malloc() (em C/C++) ou operadores como new (em C++).
Tamanho Variável: A quantidade de memória alocada pode variar dinamicamente durante a execução do programa. Isso permite a criação de estruturas de dados de tamanho variável, como listas encadeadas, árvores, vetores dinâmicos etc.
Escopo de Variável: Variáveis alocadas dinamicamente podem ter escopo global ou local, dependendo de como são usadas no código.
Exemplos: Objetos criados com new em C++, alocação dinâmica de arrays usando malloc() em C/C++, ou a criação dinâmica de objetos em linguagens orientadas a objetos.
Vantagens: A alocação dinâmica é flexível e permite o uso eficiente de memória, especialmente quando o tamanho dos dados não é conhecido antecipadamente.
Desvantagens: A alocação dinâmica requer gerenciamento manual de memória, incluindo a liberação adequada da memória alocada quando não é mais necessária. O uso inadequado pode levar a vazamentos de memória.

Observe que a alocação dinâmica de memória é necessária em situações onde o tamanho da memória necessária para armazenar dados não é conhecido antecipadamente ou pode variar durante a execução de um programa. Schildt (1996) diz que haverá momentos em que um programa precisará usar quantidades de armazenamento variáveis, isso ocorre em uma variedade de cenários, e aqui estão algumas razões pelas quais a alocação dinâmica é fundamental nesses casos: Estruturas de dados de tamanho variável, entrada de dados externa, criação de objetos em tempo de execução, otimização de memória, manipulação de strings e gerenciamento de recursos.

Portanto, a alocação dinâmica de memória desempenha um papel crítico em muitos programas, permitindo que eles sejam flexíveis e eficientes em termos de uso de recursos, mesmo quando o tamanho da memória não pode ser previamente determinado. No entanto, é importante gerenciar cuidadosamente a memória alocada dinamicamente para evitar vazamentos e problemas de desempenho.

Funções de alocação de memória

Na linguagem de programação C e em algumas linguagens relacionadas, como C++, você utiliza funções específicas para realizar a alocação dinâmica de memória e liberá-la posteriormente. A seguir você conhecerá as principais funções relacionadas à alocação dinâmica e desalocação de memória que segundo Schildt (1996) é o coração do sistema de alocação dinâmica de C:

● malloc() - Alocação de Memória:

É usada para alocar uma quantidade específica de memória dinâmica no heap, que é uma região de memória utilizada para alocação dinâmica. A função recebe como argumento o número de bytes a serem alocados e retorna um ponteiro para a primeira posição desse bloco de memória.

Sintaxe: void *malloc(size_t size);
Exemplo: int *arr; arr = (int *)malloc(5 * sizeof(int));

● calloc() - Alocação de Memória Inicializada:

É semelhante à malloc(), mas inicializa a memória alocada com zeros. Ela também recebe o número de elementos e o tamanho de cada elemento como argumentos.

Sintaxe: void *calloc(size_t num_elements, size_t element_size);
Exemplo: int *arr; arr = (int *) calloc(5, sizeof(int));

● realloc() - Realocação de Memória:

É usada para alterar o tamanho de uma área previamente alocada dinamicamente com malloc() ou calloc(). Ela recebe um ponteiro para a área de memória original, o novo tamanho desejado e retorna um novo ponteiro para a área de memória realocada. Esta função é útil quando você precisa aumentar ou diminuir o tamanho de um bloco de memória existente.

Sintaxe: void *realloc(void *ptr, size_t new_size);
Exemplo: int *arr; arr = (int *)realloc(arr, 10 * sizeof(int));

● free() - Liberação de Memória:

É usada para liberar a memória previamente alocada dinamicamente com malloc(), calloc(), ou realloc(). Isso é importante para evitar vazamentos de memória. Depois de liberar a memória, o ponteiro associado a essa memória não é mais válido e não deve ser acessado.

Sintaxe: void free(void *ptr);
Exemplo: free(arr);

É importante notar que a alocação dinâmica de memória requer um gerenciamento cuidadoso para evitar vazamentos de memória (memory leaks) e corrupção de memória. Sempre que você alocar memória dinamicamente, certifique-se de liberá-la com free() quando ela não for mais necessária para evitar desperdício de recursos e problemas de desempenho.

saiba aplicar

Em muitas linguagens de programação, os ponteiros e a alocação dinâmica de memória desempenham um papel fundamental no desenvolvimento de sistemas back-end eficientes e escaláveis. Os ponteiros permitem que você, técnico em desenvolvimento de sistemas, manipule diretamente a memória do sistema, sendo essenciais para o desenvolvimento de estruturas de dados complexas. Agora que você já conhece os conceitos mais importantes sobre ponteiros e alocação de memória, chegou a hora de implementá-los na prática. Siga o passo a passo a seguir para a implementação:

Abra seu navegador web e acesse o site OnlineGDB (https://www.onlinegdb.com/).
Escolha a linguagem de programação que deseja usar. Selecione “C” na lista suspensa.
No editor de código, você pode escrever o código C com implementação de ponteiros e alocação de memória dinâmica conforme a Figura 01.

Figura 1 - Ponteiros e alocação de memória dinâmica em C /
Fonte: o autor.

#PraCegoVer: a Figura 01 tem em sua linha 01 #include <stdio.h> na sua linha 2 #include <stdlib.h> na linha 4: int main() { na linha 5: int *ptr; na linha 6: int tamanho; na linha 8: printf(“Digite o tamanho do array: “); na linha 9: scanf(“%d”, &tamanho); na linha 11 ptr = (int *)malloc(tamanho * sizeof(int)); na linha 13 temos if (ptr == NULL) { na linha 14 temos printf(“Falha na alocação de memória!\n”); na linha 15 temos return 1; na linha 16 temos } na linha 18 temos for (int i = 0; i < tamanho; i++) { na linha 19 temos ptr[i] = i * 10; na linha 20 temos } na linha 22 temos printf(“Valores do array:\n”); na linha 23 temos for (int i = 0; i < tamanho; i++) { na linha 24 temos printf(“%d”, ptr[i]); na linha 25 temos } na linha 27 temos free(ptr); na linha 29 temos return 0; na linha 30 temos }

Segue algumas explicações sobre o código da Figura 01.

Linhas 1 e 2: inclusão das bibliotecas padrão de entrada/saída (stdio.h) e de alocação de memória dinâmica (stdlib.h).
Linhas 4 a 6: Declaração da função main() e duas variáveis ptr (um ponteiro para inteiros) e tamanho (uma variável para armazenar o tamanho do array).
Linhas 8 e 9: Solicitação ao usuário que insira o tamanho do array e armazenamento do valor em tamanho.
Linha 11: Alocação de memória dinamicamente para o array usando a função malloc(). O tamanho da alocação é calculado como tamanho * sizeof(int) para acomodar tamanho elementos inteiros.
Linhas 13 a 16: Verificação se a alocação de memória foi bem-sucedida. Set ptr for NULL significa que a alocação falhou, imprimimos uma mensagem de erro e encerramos o programa com código de retorno 1.
Linhas 18 a 20: Preenchimento do array ptr com valores. Nesse exemplo, estamos preenchendo o array com valores que são múltiplos de 10, começando de 0 e indo até (tamanho - 1) * 10;
Linhas 22 a 25: Impressão dos valores do array após o preenchimento.
Linha 27: Liberação da memória alocada dinamicamente usando a função free(). Isso é importante para evitar vazamentos de memória.
Linhas 29 e 30: Finalização da função main() e retorno 0 como código de retorno, indicando que o programa foi executado com sucesso.

Este código demonstra como alocar memória dinamicamente para um array de inteiros, preenchê-lo com valores e, em seguida, liberar a memória quando ela não é mais necessária. Isso ilustra o uso de ponteiros e alocação dinâmica de memória em C.

REFERÊNCIAS

SCHILDT, H. C Completo e total. 3. São Paulo: ed. Makron Books, 1996.

Page updated

Google Sites

Report abuse