Algumas linguagens de programação
dividem um pouco mais os “tipos”, tendo caixas diferentes para uma faixa
determinada de valores, o que na verdade é corresponde ao quando é “gasto” de
memória para guardar o valor (Figura 7).
Figura 7 – Subtipos de variáveis
Para
entender o porquê de todos estes “tipos” precisamos verificar a história da
informática, ir ao início dos processos de programação, por volta da década de
1950 e 1960.
Como vocês sabem o computador trabalha com números binários (0 e
1), os famosos BITs (de BInary DigiT – digito binário), não se preocupe, não
vamos ver a matemática ou conversão de binários, mas precisamos de alguns
conceitos.
Foi
padronizado que a menor forma de guardar e manipular dados seria através de um
conjunto de 8 bits, conhecido com Byte. Esta também é a unidade de medida da
memória do computador, veja a tabela a baixo:
|
Valor
|
Correspondência
|
|
8 Bits
|
1 Byte
|
|
1024 Bytes
|
1 Kilo Byte ou KByte
|
|
1024 KBytes
|
1 Mega Byte ou MByte
|
|
1024 MBytes
|
1 Guga Byte ou GByte
|
Nas
décadas de 1950 e 1960, a memória dos computadores ficavam na casa dos KBytes
(hoje qualquer computador não vem com menos de 1 GByte de memória), logo, o uso
deste recurso, caro e limitado, era primordial.
Mesmo depois com os
microcomputadores na década de 1980, ainda tínhamos estes limites, os primeiros
microcomputadores tinham 32 KBytes de memória. Mesmo posteriormente com o
surgimento dos PCs (Personal Computer
– Computadores Pessoais), iniciamos com 256 KBytes, chegando a 640 KBytes, o
limite até o início da década de 1990.
Logo,
cada variável, cada caixa, ocupava uma quantidade específica de memória,
“gasta” um número determinado de Bytes, e, portanto, eram utilizadas com
economia.
O programador verificava qual o valor máximo possível para os dados
que seriam manipulados, em função do número de Bytes e da forma como os dados
seriam guardados, e com isso definia o “tipo” que o valor cabia, ou seja,
escolhia o tamanho da caixa necessária, para guardar aquele dado, nunca uma
maior, sempre a caixa de tamanho correto.
Por
isso muitas linguagens de programação tinham para os “tipos” numéricos,
“subtipos” com capacidade diferentes, e consequentemente, diferentes gastos de
memória.
Atualmente
não temos estes problemas, mesmo quem programa para dispositivos móveis
(smartphones, tablets e celulares), possui mais memória para trabalhar do que nas
décadas de 1950 a 1980, mas mesmo assim, algumas linguagens ainda possuem
“tipos” e “subtipos”.
Cada “tipo” ou “subtipo”, possui uma forma de ser
colocado na memória, além do gasto diferenciado, isso faz com que a linguagem
de programação, tenha que saber qual o tipo da caixa (ou variável) para poder lidar
com ela.
Vamos entender melhor estas diferenças.
Suponha
que tivéssemos dois “tipos” de caixas: Cestos e Garrafas, de diferentes
tamanhos (capacidades de armazenamento e gastos de memória), onde os Cestos
seriam para guardar o “tipo” bolas azuis, e as Garrafas o “tipo” liquido azul
(Figura 8).
Figura 8 – Cestos e Garrafas –
meus “tipos” de variáveis
Se
tentássemos colocar o “tipo” bolas azuis, que deveriam estar em um Cesto, em uma
Garrafa, ou vice-versa, teríamos problemas, pois nossas caixas não estão
preparadas para receber os “tipos” de dados que estamos tentando colocar nelas
(Figura 09).
Figura 09 – Entre tipos
diferentes – não é possível
Da
mesma forma, os dados que cabem em um “subtipo” de menor tamanho (as variações
dos “tipos”), podem ser guardados em um “subtipo” maior tamanho, ou seja, se
enchermos o Cesto Médio, podemos colocar suas bolas azuis em um Cesto Grande,
sem problemas. O mesmo ocorre com a Garrafa e o líquido azul (Figura 10).
Figura 10 – Do menor para o
maior – é possível
Mas
se tentarmos o inverso, ou seja, encher o Cesto Grande (ou a Garrafa Grande) e
“despejar” seu conteúdo no Cesto Médio (ou a Garrafa Média), eles não vão ter
capacidade para estes dados e irão transbordar (Figura 11).
Figura 11 – Do maior para o
menor – não é possível
Nenhum comentário:
Postar um comentário