Variáveis

Podemos entender um microcomputador como um sistema de cinco unidades de funcionamento: unidade de entrada (teclado, mouse, drive de CD-ROM, drive de disquetes etc), unidade de saída (impressora, monitor etc), unidade de memória (memória RAM -escrita e leitura-, memória ROM - leitura), e as unidades aritmética e lógica que se encontram agrupadas na CPU (Unidade Central de Processamento, o processador).

O chip responsável pelo controle de todo o computador é o processador. Outro circuito de extrema importância é a memória RAM, que podemos imaginar como um grupo de células usadas para armazenamento temporário das instruções e dos dados que são acessados e processados pelo microprocessador em altíssima velocidade. Trata de uma memória volátil pois seus dados perdem-se no momento em que são desligadas, o que não chega a ser um problema, visto que esses dados, de regra, após salvos, ficam guardados em algum disco de armazenamento permanente, como os discos rígidos ou os disquetes, sendo copiados novamente para a memória na ocasião de seu processamento.

A memória RAM é constituída por uma imensa seqüência de células de armazenamento (localizações) com o tamanho de oito bits (um byte) cada, o que permite que cada uma dessas localizações possa assumir um entre 256 valores diferentes. Ressalte-se, ainda, que cada célula possui um endereço único e inconfundível, expresso por um valor numérico que define a exata localização desse byte, bem como que, apesar do limitado tamanho de cada célula, podemos acessar dois bytes consecutivos (word) ou quatro bytes consecutivos (doubleword) simultaneamente com um único endereçamento.

Disso decorre que durante a execução de um programa, as instruções e os dados processados ficam armazenados na memória do computador. Cada informação é representada por certo grupo de bytes (char - 1 byte, float - 4 bytes, double - 8 bytes etc) e possui um local determinado na memória, um endereço que pode ser expressado por um valor hexadecimal. Não há necessidade de o programador conhecer o endereço absoluto de cada dado, pois o compilador relaciona o nome de cada variável com sua posição na memória, cuidando dessa tarefa da melhor maneira possível.

Para facilitar o entendimento, podemos imaginar a memória do computador como um enorme armário de gavetas. Cada gaveta (célula de armazenamento) é numerada seqüencialmente e possui o tamanho de 1 byte. Esse número seqüencial é o endereço da gaveta. Conforme o tipo de variável declarada (char = 1 byte; int = 4 bytes; float = 4 bytes; etc), o compilador reservará uma ou mais gavetas seqüencialmente para armazenar o valor correspondente, pois cada tipo de dado possui um tamanho próprio.

Imagine um armário imenso, com um milhões de gavetas iguais. Seria demasiadamente complicado localizar determinado objeto numa dessas gavetas se não possuíssemos uma forma de diferenciá-las entre si. Então, o nome da variável funciona como uma inscrição que individualiza a gaveta (endereço na memória).

Por exemplo, a declaração:

long double LgDbl;

informa ao compilador que ele deverá reservar 10 bytes seqüenciais (dez gavetas dispostas em seqüência) para uma variável do tipo long double cujo nome é LgDbl. Observe que as "gavetas" estão reservadas, porém nenhum "objeto" foi colocado nelas.

Um ponto bastante importante sobre o tamanho das variáveis é que seu tamanho pode variar de máquina para máquina, ou sistema operacional para sistema operacional. O tipo int, por exemplo, ocupa 2 bytes no sistema operacional MS-DOS e 4 bytes no Windows.

Com esses conceitos, já temos informações suficientes para entender o que vem a ser uma variável. Podemos definir uma variável como um local na memória do computador que a cada momento pode possuir um valor diferente, porém do mesmo tipo de dados.

Por exemplo, a declaração:

char ch; 

faz com que o compilador reserve espaço suficiente para um caracter. Já a declaração abaixo é um pouco mais completa, pois inicializa a variável, colocando um caracter A no espaço reservado:

char ch = 'A'; 

O conceito de variáveis decorre justamente do fato de que podemos substituir o "conteúdo" dessas "gavetas":

ch = 'b'; // ch agora possui outro valor

O exemplo a seguir usa um SpeedButton no Form. Declararemos uma variável do tipo char num lugar onde ela será visível tanto pelo evento OnMouseDown quanto pelo evento OnMouseUp de SpeedButton1. Quando o botão do mouse for pressionado sobre o botão, o evento OnMouseDown será ativado para atribuir o caracter A à variável ch, exibindo esse valor no Caption de SpeedButton1. Quando o botão do mouse for liberado, o evento OnMouseUp será ativado para alterar o valor da variável para b, exibindo esse valor no Caption de SpeedButton1.

//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
// declara uma variável char visível pelos eventos de SpeedButton1
char ch; 
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::SpeedButton1MouseDown(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y)
{
ch = 'A'; // atribui A para a variável ch
SpeedButton1 -> Caption = ch;
}
//---------------------------------------------------------------------------

void __fastcall TForm1::SpeedButton1MouseUp(TObject *Sender,
TMouseButton Button, TShiftState Shift, int X, int Y)
{
ch = 'b'; // atribui b para a variável ch
SpeedButton1 -> Caption = ch;
}
//---------------------------------------------------------------------------

O C++Builder implementa a função sizeof() que nos permite visualizar o tamanho, em bytes, de uma variável ou de um tipo de dados:

//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)
{

double Dbl;
Edit1 -> Text = AnsiString(sizeof(Dbl)) + " bytes"; // retorna pelo nome da variável

/* retorna o valor pelo tipo de dados*/
Edit2 -> Text = AnsiString(sizeof(bool)) + " byte";

RichEdit1 -> Clear();  // apaga o conteúdo de RichEdit1
for (int linha = 0; linha <= 3; linha ++) // Em breve estudadremos o loop for
RichEdit1 -> Lines -> Insert(linha, "");  // prepara RichEdit1 para receber
                                          // as quatro linhas de strings

RichEdit1 -> Lines-> Strings[0] = "Tamanho de char = " + String(sizeof(char));
RichEdit1 -> Lines-> Strings[1] = "Tamanho de int = " + String(sizeof(int));
RichEdit1 -> Lines-> Strings[2] = "Tamanho de String = " + String(sizeof(String));
RichEdit1 -> Lines-> Strings[3] = "Tamanho de AnsiString = " +
                                                   AnsiString(sizeof(AnsiString));

ShowMessage(sizeof(long double));
  
}
//---------------------------------------------------------------------------