Artigo sobre Desenvolvimento de Sistemas. 4a. Parte
Variáveis
Para carregar as variáveis usamos o comando =.
As variáveis são partes da memória usadas para guarda informações. As variáveis são usadas para guardar valores que serão processados pelos programas.
Programas em C as variáveis devem ser declarada antes de serem usadas. Na declaração é informado o tipo de dado que variável vai guardar, isto é necessário para que o compilador reserve memoria suficiente para guarda a informação.
Programas em C as variáveis devem ser declarada antes de serem usadas. Na declaração é informado o tipo de dado que variável vai guardar, isto é necessário para que o compilador reserve memoria suficiente para guarda a informação.
As variáveis podem guardar valores numéricos do tipo inteiro, em ponto flutuante, códigos de caracteres, endereços de memória e sequência de dados chamados vetores. Cada tipo pode ter um modificador que informa que a variável terá uma característica especifica, como exemplo podemos declarar variáveis do tipo inteiro sem sinal, Isto aumenta consideravelmente o range de valores que a variável pode suportar.
O padrão ANSI C estabelece um range mínimo para as variáveis e os compiladores devem seguir este mínimo, porem não são obrigados a seguir um valor máximo. Isto é necessário pois em tempos em tempos a arquitetura dos computadores mudem, no momento deste artigo a arquitetura mais popular é a de 64 bites e antes desta a mais popular era a de 32 bits.
O padrão ANSI C estabelece um range mínimo para as variáveis e os compiladores devem seguir este mínimo, porem não são obrigados a seguir um valor máximo. Isto é necessário pois em tempos em tempos a arquitetura dos computadores mudem, no momento deste artigo a arquitetura mais popular é a de 64 bites e antes desta a mais popular era a de 32 bits.
A seguir temos uma tabela com os valores padrão.
| Tipo | Tamanho em Bytes | Faixa Mínima |
| char | 1 | -127 a 127 |
| unsigned char | 1 | 0 a 255 |
| signed char | 1 | -127 a 127 |
| int | 4 | -2.147.483.648 a 2.147.483.647 |
| unsigned int | 4 | 0 a 4.294.967.295 |
| signed int | 4 | -2.147.483.648 a 2.147.483.647 |
| short int | 2 | -32.768 a 32.767 |
| unsigned short int | 2 | 0 a 65.535 |
| signed short int | 2 | -32.768 a 32.767 |
| long int | 4 | -2.147.483.648 a 2.147.483.647 |
| signed long int | 4 | -2.147.483.648 a 2.147.483.647 |
| unsigned long int | 4 | 0 a 4.294.967.295 |
| float | 4 | Seis digitos de precisão |
| double | 8 | Dez digitos de precisão |
| long double | 10 | Dez digitos de precisão |
As variáveis podem ser locais ou globais. São locais quando declaradas dentro de funções e apenas a função, onde ela é declara, pode acessar a variável. São globais quando declaradas fora de qualquer função e todas as funções podem acessa-las.
Veja exemplos de declarações de variáveis:
int idade; /*Variavel global do tipo inteiro*/
long ano; /*Variavel global do tipo long */
int main(int argc, int *argv[])
{
double altura; /* Variavel local do tipo ponto flutuante de precisao dupla */
char sexo; /* Variavel local do tipo char */
}
Para carregar as variáveis usamos o comando =.
int idade; /*Variavel global do tipo inteiro*/
long ano; /*Variavel global do tipo long */
int main(int argc, int *argv[])
{
double altura; /* Variavel local do tipo ponto flutuante de precisao dupla */
char sexo; /* Variavel local do tipo char */
idade = 39;
ano = 2012;
altura = 1.80;
sexo = 'M'; /* As aspas simples convertem o caracter no valor ACSII */
}
Podemos fazer operações com variáveis.
int main(int argc, int *argv[])
{
double altura; /* Variavel local do tipo ponto flutuante de precisao dupla */
char sexo; /* Variavel local do tipo char */
idade = 39;
ano = 2012;
altura = 1.80;
sexo = 'M'; /* As aspas simples convertem o caracter no valor ACSII */
idade = 39 + 5;
altura = 1,80 /2;
}
As variáveis que recebem informação tem que ter um tipo que suporte o resultado das operações, se o resultado não for suportado o conteúdo da variável terá um valor indefinido.
Podemos fazer operações com as variáveis, inclusive com ela mesma.
int main(int argc, int *argv[])
{
double altura; /* Variavel local do tipo ponto flutuante de precisao dupla */
char sexo; /* Variavel local do tipo char */
idade = 39;
ano = 2012;
altura = 1.80;
sexo = 'M'; /* As aspas simples convertem o caracter no valor ACSII */
idade = 39 + 5;
altura = 1,80 /2;
idade = idade + 5;
ano = idade + 5;
}
É possível misturar os tipos numa operação, o compilador fará as conversões necessárias, podem a variável, que recebe o resultado, terá que ser de um tipo que suporte o range do resultado.
int idade; /*Variavel global do tipo inteiro*/
int main(int argc, int *argv[])
{
double altura; /* Variavel local do tipo ponto flutuante de precisao dupla */
char sexo; /* Variavel local do tipo char */
idade = 39;
ano = 2012;
altura = 1.80;
sexo = 'M'; /* As aspas simples convertem o caracter no valor ACSII */
idade = 39 + 5;
altura = 1,80 /2;
idade = idade + 5;
ano = idade + 5;
idade = altura + ano; /* Neste caso o resultado e um valor de ponto flutuante e o compilador vai converte-lo para um interior, a parte fracionada e eliminada */
}
Para verificar o conteúdo das variáveis podemos usar o comando printf da biblioteca padrão ANSI C.
#include "stdio.h" /* arquivo contendo o prototipo da função e as estruturas necessarias para os comandos da biblioteca padrão funcionem */
int main(int argc, int *argv[])
{
double altura; /* Variavel local do tipo ponto flutuante de precisao dupla */
char sexo; /* Variavel local do tipo char */
idade = 39;
ano = 2012;
altura = 1.80;
sexo = 'M'; /* As aspas simples convertem o caracter no valor ACSII */
idade = 39 + 5;
altura = 1,80 /2;
idade = idade + 5;
ano = idade + 5;
idade = altura + ano; /* Neste caso o resultado e um valor de ponto flutuante e o compilador vai converte-lo para um interior, a parte fracionada e eliminada */
printf("idade = %d ano = %ld altura = %f sexo = %c\n", idade, ano, altura, sexo);
/*A mensagem que vai aparecer no console é o que está entre aspas duplas, o comando % informa ao printf que os valores das variáveis devem ser usadas neste ponto seguindo a ordem que aparem na listagem fora das aspas. As letras após % indicam o tipo de dado que a variável contem: d é de inteiro, ld é de long, f é de ponto flutuante e c é para caractere. */
}
idade = 39;
ano = 2012;
altura = 1.80;
sexo = 'M'; /* As aspas simples convertem o caracter no valor ACSII */
}
Podemos fazer operações com variáveis.
int idade; /*Variavel global do tipo inteiro*/
long ano; /*Variavel global do tipo long */
int main(int argc, int *argv[])
{
double altura; /* Variavel local do tipo ponto flutuante de precisao dupla */
char sexo; /* Variavel local do tipo char */
idade = 39;
ano = 2012;
altura = 1.80;
sexo = 'M'; /* As aspas simples convertem o caracter no valor ACSII */
idade = 39 + 5;
altura = 1,80 /2;
}
As variáveis que recebem informação tem que ter um tipo que suporte o resultado das operações, se o resultado não for suportado o conteúdo da variável terá um valor indefinido.
Podemos fazer operações com as variáveis, inclusive com ela mesma.
int idade; /*Variavel global do tipo inteiro*/
long ano; /*Variavel global do tipo long */
int main(int argc, int *argv[])
{
double altura; /* Variavel local do tipo ponto flutuante de precisao dupla */
char sexo; /* Variavel local do tipo char */
idade = 39;
ano = 2012;
altura = 1.80;
sexo = 'M'; /* As aspas simples convertem o caracter no valor ACSII */
idade = 39 + 5;
altura = 1,80 /2;
idade = idade + 5;
ano = idade + 5;
}
É possível misturar os tipos numa operação, o compilador fará as conversões necessárias, podem a variável, que recebe o resultado, terá que ser de um tipo que suporte o range do resultado.
int idade; /*Variavel global do tipo inteiro*/
long ano; /*Variavel global do tipo long */
int main(int argc, int *argv[])
{
double altura; /* Variavel local do tipo ponto flutuante de precisao dupla */
char sexo; /* Variavel local do tipo char */
idade = 39;
ano = 2012;
altura = 1.80;
sexo = 'M'; /* As aspas simples convertem o caracter no valor ACSII */
idade = 39 + 5;
altura = 1,80 /2;
idade = idade + 5;
ano = idade + 5;
idade = altura + ano; /* Neste caso o resultado e um valor de ponto flutuante e o compilador vai converte-lo para um interior, a parte fracionada e eliminada */
}
Para verificar o conteúdo das variáveis podemos usar o comando printf da biblioteca padrão ANSI C.
#include "stdio.h" /* arquivo contendo o prototipo da função e as estruturas necessarias para os comandos da biblioteca padrão funcionem */
int idade; /*Variavel global do tipo inteiro*/
long ano; /*Variavel global do tipo long */
int main(int argc, int *argv[])
{
double altura; /* Variavel local do tipo ponto flutuante de precisao dupla */
char sexo; /* Variavel local do tipo char */
idade = 39;
ano = 2012;
altura = 1.80;
sexo = 'M'; /* As aspas simples convertem o caracter no valor ACSII */
idade = 39 + 5;
altura = 1,80 /2;
idade = idade + 5;
ano = idade + 5;
idade = altura + ano; /* Neste caso o resultado e um valor de ponto flutuante e o compilador vai converte-lo para um interior, a parte fracionada e eliminada */
printf("idade = %d ano = %ld altura = %f sexo = %c\n", idade, ano, altura, sexo);
/*A mensagem que vai aparecer no console é o que está entre aspas duplas, o comando % informa ao printf que os valores das variáveis devem ser usadas neste ponto seguindo a ordem que aparem na listagem fora das aspas. As letras após % indicam o tipo de dado que a variável contem: d é de inteiro, ld é de long, f é de ponto flutuante e c é para caractere. */
}

Comentários
Postar um comentário