Programar em C/Índice/Variáveis

Origem: Wikilivros, livros abertos por um mundo aberto.

Esta página precisa ser reciclada (discuta). Ao melhorá-la, você estará ajudando o Wikilivros.

Tabela de conteúdo 1 Declarando variáveis 2 O nome da variável (identificador) 3 Palavras reservadas 4 Atribuição de valores a variáveis 5 Inicialização 6 Compatibilidade de dados na atribuição de valor 7 O operador de endereço 8 O operador sizeof

[editar] Declarando variáveis

Para utilizarmos informações, é necessário que o computador as receba e as "memorize". Para que seja possível para o computador "memorizar" algo, antes é preciso reservar espaço na memória. Podemos fazer isso declarando uma variável.

Ao declararmos uma variável, não apenas estamos reservando um espaço de memória, como também estamos associando um nome a ele, o identificador. Ao invés de utilizarmos o endereço da variável na memória, que seria geralmente notado na forma hexadecimal, como por exemplo 0x0012FED4, referimo-nos ao endereço apenas pelo seu nome. Apenas para deixar claro, a própria notação em hexadecimal já é uma simplificação, pois computadores na verdade trabalham com binário.

A sintaxe da declaração de variáveis é

tipo_de_variável nome_da_variável;  // Note o ponto e vírgula no final.

Exemplificando, poderíamos declarar:

int a;
// Declaro uma variável com o nome “a” e do tipo int;
// essa variável poderá guardar valores inteiros,
// pelo menos, de -32767 a 32767.

char letra;
// Declaro uma variável chamada de “letra”
// que tem capacidade para guardar um caractere.

Podemos declarar várias variáveis ao mesmo tempo se elas forem do mesmo tipo.

int a, b, c;
// Declaro 3 variáveis do tipo int.

[editar] O nome da variável (identificador)

Existem algumas restrições quanto ao nome que podemos dar:

• Só podemos utilizar as letras do alfabeto de A a Z (maiúsculas ou minúsculas) e o sublinhado "_". Também podemos usar os algarismos arábicos (0-9), mas não como primeiro caractere. Note que maiúsculas e minúsculas são diferenciadas;
• O nome não pode ter espaços;
• O nome pode ser igual ao de outra variável já existente, porém é recomendado fortemente que não se use variáveis iguais sob pena de tornar o código do programa incompreensível ou de difícil análise;
• Não podemos usar as palavras reservadas à sintaxe da linguagem C++;
• Em alguns compiladores, o nome da variável é limitado a 31 bytes (caracteres).

[editar] Palavras reservadas

As palavras reservadas nada mais são que palavras que têm algum significado especial na linguagem: nomes de tipos, instruções, estruturas de controle, declarações, etc.

[editar] Atribuição de valores a variáveis

Nós podemos atribuir um valor a uma variável através do operador de atribuição "=". Por exemplo:

nome_da_variável = valor;
a = 5;

Observação: Apesar de este operador se assemelhar ao igual da matemática, sua função é diferente. Para verificar a igualdade de dois valores, usamos o operador de comparação "==" (dois iguais).

O "=" é o operador de atribuição; sua função é atribuir à variável que está a sua esquerda o valor à sua direita. Note que é necessário declarar uma variável antes de atribuir-lhe um valor.

[editar] Inicialização

Quando declaramos e atribuímos valores a uma variável com uma instrução só, chamamos a isso inicialização de uma variável. Por exemplo:

int testScore = 95;

Não se pode atribuir um valor a uma variável antes que ela seja declarada, pois na hora da compilação o compilador não saberia o tipo da variável ― e, conseqüentemente, as informações sobre como ela deve ser guardada.

testScore = 95;  // erro de compilação
int testScore;

Podemos inicializar várias variáveis ao mesmo tempo:

int a = 95, b = 3;

Ou, se quisermos,

int a, b, c;
a = b = c = 0;

Neste último caso, primeiro vai ser colocado o valor zero na variável c, depois a variável b vai copiar o valor presente na variável c e por fim a variável a vai copiar o valor da variável “b.

Como o próprio nome já diz, o valor existente numa variável pode ser mudado, da mesma maneira que ele é normalmente atribuído. Se tivermos:

int a;
a = 2;
a = 3;

no final o valor da variável a será 3.

[editar] Compatibilidade de dados na atribuição de valor

E se tentarmos colocar um valor diferente do que o tipo da variável está esperando? Temos um problema de compatibilidade de dados:

• Caso 1: declaramos um int e colocamos uma letra

  Aqui não teremos problemas. Os literais de caracteres são, nativamente, do tipo int. O resultado será um inteiro que contém o valor ASCII do caractere dado.

• Caso 2: declaramos um int e colocamos uma string (seqüência de caracteres)

  Aqui teremos um erro de compilação, em que nos diz que não conseguimos converter "const char [5]" em "int". Perceba com isso que o compilador tem alguns sistemas de conversão ― note o caso 3.

• Caso 3: declaramos um int e colocamos um float

  Neste caso, se colocarmos 77.33, irá ser apenas guardado o valor 77, perdendo-se a parte decimal.

• Caso 4: overflow ― declaramos um short e colocamos um valor maior que o máximo

  Lembre-se que o tipo short guarda valores de –32767 a 32767. Se colocarmos 32768 (e o compilador não estender esses limites), não vai acontecer nenhum erro de compilação; o que resulta é que vai ser impresso um número negativo, –32767 (ou, como é comum em vários compiladores, –32768). A lógica disto tem a ver com a maneira como o computador guarda números negativos. Mas também podemos fazer uma analogia com as horas. Imaginemos que vamos somar 6 horas com 7 horas. O resultado seria 13, mas como não existe 13 no relógio, iríamos dar a volta nas horas e chegar ao 1. Assim o resultado será 1.

• Caso 5: underflow ― declaramos um short e colocamos um valor inferior ao mínimo possível.

  Aqui temos exactamente a mesma lógica do caso de overflow, mas desta vez é excedido o limite inferior e não o superior.

• Caso 6: declaramos um unsigned int e colocamos um número negativo

  O que acontece aqui é semelhante a um underflow. Mas o que ocorre é que o número é guardado como seria se fosse um int comum, negativo. O que muda na prática é a interpretação desse número, de acordo com o tipo de dado que lhe está atribuído. Se tentarmos lê-lo como um unsigned int, obteremos um valor positivo obtido pela mesma lógica do overflow/underflow; se o lermos como um (signed) int, obteremos o mesmo valor negativo que lhe atribuímos!

[editar] O operador de endereço

Quando declaramos uma variável, é reservado a ela um espaço na memória, onde será guardado o valor que for atribuído a ela. Esse tamanho depende do tipo da variável, como já foi citado.

Usando o operador de endereço (&), poderemos saber o endereço da memória reservada a uma variável. Esse operador retorna o endereço do primeiro byte dessa memória. Veja o exemplo:

#include <iostream>
using namespace std;
int main(void)
{
  int a = 2;
  cout << "O valor de  a  é:  "  << a << "\n";
  cout << "O valor da variável está guardado no endereço  "  << &a << "\n";
  cout << "Esse valor vai ocupar  " << sizeof(a) << " bytes\n";
  cout << "O endereço da variável ocupa  " << sizeof(&a) << "bytes\n";
  return 0;
}

Vai ser o sistema operativo que vai escolher a localização da variável, logo do endereço da memória

Pergunta: como saber o endereço de onde está guardado o endereço de uma variável?

Pergunta: onde é que está guardado o nome da variável

[editar] O operador sizeof

O operador sizeof pode ter como argumento um tipo de variável ou mesmo a própria variável. Esse operador retorna o tamanho, em bytes, reservados ao tipo ou à variável. No exemplo acima, é retornado (e associado a a) o valor 1 porque é o tamanho de um char, por definição.

Este operador permite determinar a quantidade de memória que é reservada para cada tipo de variável. Note que essa quantidade pode variar de sistema para sistema.

#include <iostream>
using namespace std;
int main(void)
{
  cout << "O tamanho de 'short' é " << sizeof(short) << "\n";
  /* estamos a chamar o operador sizeof e inserimos
     como parâmetro o tipo short */
  return 0;
}