Est-D 1. O que são dados na computação?

No universo reduzido da computação, dados são sequências de valores expressos digitalmente, ou seja representados a partir do sistema numérico binário. Números, caracteres e booleanos armazenados na memória RAM são tipos desses dados, que organizamos e que, mediante diferentes convenções humanas, se tornam úteis, ganhando sentido na vida real. Um dado qualquer 0b100011 não possui significado intrínseco - ou por si só - e não representa nada até que lhe seja atribuído algum sentido.

É a partir dessa concepção que iniciaremos o estudo de dados e estruturas de dados.

Dados de programa x Dados persistentes

Antes de partir para a construção das bases, vamos preparar o terreno. Existem duas ideias que podem se confundir ao abordarmos o tema, que são: dados na memória (ou de programa) e dados no armazenamento (ou persistentes). Aqui há uma diferença léxica que parece sutil mas é importantíssima, pois memória e armazenamento são distinções essenciais que devem ser adaptadas ao vocabulário de um desenvolvedor.

Primeiro, vamos definir dados na memória: Dados na memória são aqueles utilizados durante a execução de um programa e só “existem” enquanto são necessários. Eles são armazenados, acessados e modificados mediante a necessidade do programa de assim fazê-lo; eles não persistem após o fim da execução desse mesmo programa.

Agora, quanto a dados no armazenamento: Falamos de armazenamento para nos referir especificamente a tipos de armazenamento persistentes, ou seja, que continuam existindo mesmo após o encerramento de um programa de computador que as leu ou armazenou. As principais operações com dados são manipulação, processamento, análise e gerenciamento, e não têm parte na elaboração do conjunto de regras pelas quais o programa de computador que as lê utiliza.

A partir daqui, utilizaremos o termo “dados” para nos referir especialmente a dados na memória.

Onde ficam os dados?

Os dados ficam armazenados, enquanto forem necessários, na memória RAM. Podemos imaginar a memória RAM como uma tira de células numeradas. Cada célula dessas armazena 1 byte de dados, ou seja um determinado valor expresso em números binários de até 8 bits (um intervalo de valores [0, 255] no sistema decimal). É o compilador que, através da ABI (Application Binary Interface), define quantos bytes cada tipo lógico ocupa na memória RAM. Esses tamanhos são acordos entre compilador, sistema operacional e arquitetura do processador; são convenções que permitem interpretar uma mesma sequência de bits de formas distintas. Aqui encontramos os tipos primitivos, que são, basicamente, acordos sobre como interpretar uma sequência de bits. Com eles são representados conjuntos de valores básicos armazenados diretamente nas células da memória.

Os tipos primitivos

Sua nomenclatura e seus tamanhos em bytes variam de acordo com a linguagem, o Sistema Operacional e o compilador, mas para um exemplo genérico em C é possível encontrá-los, geralmente, na seguinte forma:

• bool: 1 byte ( Utiliza '0 = falso, qualquer outro = verdadeiro')
• char: 1 byte (número mapeado a um caractere (ASCII/Unicode)
• int: 4 bytes (Inteiro em complemento de dois)
• long: 8 bytes (Inteiros de maior intervalo numérico)
• float: 4 bytes (Número real no padrão IEEE 754)
• double: 8 bytes (Número real com mais precisão)
• pointer: 4 ou 8 bytes (Ponteiro: endereço de outra célula de memória)

Aqui seguimos a mesma ideia: o processador não faz ideia do que é cada tipo; os mesmos 4 bytes podem ser lidos como inteiro ou como float, por exemplo, e serem interpretados em números distintos. Os tipos existem apenas para o compilador, não para o hardware.

Ponteiros, um tipo de dado especial

De forma direta, ponteiros são dados em memória — representados por variáveis, em programas — que têm como valor armazenado um endereço da RAM (mais popularmente chamado de endereço de memória).

Ou seja, em vez de guardar um valor bruto, ele armazena o endereço da memória onde o valor (ou bloco alocado, sobre o que falaremos mais no futuro) está. Na linguagem C, isso é facilmente visualizável:

int a = 4;    // `a` armazena um valor bruto.
int* b = &a;  // `b` armazena o endereço de memória onde `a` se encontra.

/*
  Em relação à linguagem, especificamente, note o seguinte:
    - `b` é declarada com o tipo `int*`;
    - `b` recebe `&a`.

  Isso acontece porque o "operador" `*` após o nome de um tipo, no contexto de declaração, indica que aquela variável é um ponteiro para um endereço de memória que armazena um valor daquele tipo. Ou seja, `b` armazena um ponteiro para um número INTEIRO do que se espera estar posicionado naquele endereço. É o operador `&` antes do nome da variável que pede ao programa para ler seu endereço, em vez de seu valor, retornando e salvando-o em `b`, no exemplo acima.
  Este exemplo é deliberadamente simples, porém seu uso real pode variar bastante em dificuldade. Note também que, tecnicamente, `*` em `int*` não é de fato um operador, mas que `int*` em si, nesse caso em específico, já é um tipo; no caso de `int *a, b`, por exemplo, `a` é declarado como ponteiro e `b` como inteiro. Essa explicação será mantida exclusivamente para fins didáticos.
  Além disso, em contexto de expressão (fora da declaração) da variável, `*b` é o operador de derreferência, ou seja, ele acessa o valor no endereço apresentado por `b`. Assim, o trecho `printf("%d", *b);` imprimiria `4` na saída padrão (geralmente o console ou terminal).
*/

E sim, à primeira vista esse conceito pode parecer complicado e talvez até desnecessário, mas é a partir dessa funcionalidade que se torna possível a construção de qualquer estrutura de dados não trivial.

Outra coisa perceptível é que, em linguagens de programação de nível mais alto que C, dificilmente trata-se com ponteiros diretamente. Isso tanto porque linguagens modernas são criadas visando uma curva de aprendizado menor e fácil integração no uso empresarial, quanto por questões de segurança e manutenibilidade de grandes fontes de código; mesmo assim, ponteiros ainda são utilizados de forma subjacente na maioria delas e, sem eles, estruturas como objetos e outros agrupamentos de dados não seriam possíveis. Eles são como o tecido que conecta todas as estruturas que veremos à frente.

Atividade proposta

Por fim, apesar desse material não fazer parte da grade de um curso formal, gostaria de propor um exercício ao fim de cada artigo, tanto a critério de ludicidade quanto para fomentar uma maior fixação do que foi apresentado. É uma atividade simples: Pesquise e responda, com as próprias palavras, os seguintes trechos de código:

Trecho 1

int arr[5] = {2, 3, 5, 8, 13}; // 1. Qual o tipo de `arr`?
int* p = arr;                  // 2. Por que `int* p`?
int* fim = arr + 5;            // 3. Qual o tipo de `fim`?
while (p < fim)                // 4. Por que `p < fim`?
{
    printf("%d\n", *p);        // 5. O que está sendo lido em `*p`?
    p++;                       // 6. Por que `p++`?
}

Trecho 2

int arr[5] = {10, 20, 30, 40, 50}; // 1. Qual o valor de `arr[2]`?
int *p = arr;                      // 2. Qual o tipo de `p`

for (int i = 0; i < 5; i++)        // 3. Por que `i < 5`?
{
    printf("%d\n", *p);            // 4. Por que `"%d\n"`?
    p++;                           // 5. O que aconteceria se essa linha fosse substituída por `*p++`?
}

Pesquisar sobre algo, ler e anotar com as próprias palavras é um dos mecanismos mais eficientes para o aprendizado.

“Ademais, na antiguidade e continuidade do poder se apagam a memória e as demandas por inovações: porque uma mudança sempre lança as bases para a edificação de outra.” Nicolau Maquiavel, O Príncipe