Este documento discute os tipos básicos de dados em C, como char, int, float e double. Também aborda modificadores de tipos, constantes, variáveis, operadores e conversão de tipos.

1. Unidade Didática III
Variáveis e Operadores

2. Tipos Básicos de Dados:
 char: Caracter: O valor armazenado é um caractere.
Caracateres geralmente são armazenados em códigos
(normalmente o código ASCII).
int: Número inteiro é o tipo padrão e o tamanho do
conjunto que pode ser representado normalmente depende
da máquina em que o programa está rodando.
float: Número em ponto flutuante de precisão simples.
São conhecidos normalmente como números reais.

3. Tipos Básicos de Dados:
double: Número em ponto flutuante de precisão dupla

 void: Este tipo serve para indicar que um resultado não
tem um tipo definido. Uma das aplicações deste tipo em C é
criar um tipo vazio que pode posteriormente ser modificado
para um dos tipos anteriores.

4. Modificadores dos Tipos Básicos:
Modificadores podem ser aplicados a estes tipos.
Estes modificadores são palavras que alteram o tamanho do
conjunto de valores que o tipo pode representar.
Por exemplo, um modificador permite que possam ser
armazenados números inteiros maiores. Um outro
modificador obriga que só números sem sinal possam ser
armazenados pela variável.
A Tabela a seguir mostra todos os tipos básicos definidos no
padrão ANSI.

6. Constantes:
Constantes são usadas em expressões para representar
vários tipos de valores. Em C existem regras rígidas para
determinar como devem ser escritos estes valores.
Constantes Inteiras
São valores numéricos sem ponto decimal, precedidos ou
não por um sinal. Não é possível separar o sinal do valor
numérico. Exemplo: 1997, -3, +5, 0 e -32000
Exemplos de erros: 1,234 (Não é possível vírgula.)
- 345 (Não é possível separar sinal e o valor numérico.)
23 (Não é possível usar notação de expoentes.)

7. Constantes Caracteres
Uma constante caractere é um único caractere escrito entre ',
como em 'a', podendo participar normalmente de expressões
aritméticas.
O valor que entra na expressão é o do código usado para
representar o caractere.

9. Constantes Inteiras Longas
São constantes armazenadas em um número maior de bits.
Para diferenciá-las de constantes inteiras comuns acrescenta-
se um L ao final do número.
Nos compiladores modernos o número de bytes usados para
armazenar os valores inteiros é o mesmo tanto para tipos
inteiros ( int) quanto para tipos inteiros longos ( long int). Por
esta razão esta diferença entre constantes inteiras perde a
razão de ser. Exemplos de constantes inteira longas, são:
234L
320000L
-120000L

10. Constantes em Ponto Flutuante
São também conhecidos como constantes reais.
Cada constante de ponto flutuante é considerada ser do tipo
double. Uma constante em ponto flutuante é normalmente
representada com ponto decimal, precedidas ou não de um
sinal, podendo ser seguidas por um expoente. São
exemplos de constantes em ponto flutuante.
+23.45e-10
123.45
123.45E+10
123.45F

11. Constantes Hexadecimais
São constantes representadas na base 16. Normalmente são
representadas com um 0x ou 0X antecedendo o número.
Exemplos: 0xF (15), 0x25 (37) e 0XAB (171).
Constantes Octais
São constantes representadas na base 8. Normalmente são
representadas sempre sem sinal e devem iniciar com um
algarismo 0. Exemplos: 025 (21), 077 (63) e 011 (9)

12. Variáveis
Para manipular dados dos mais diversos tipos, é necessário
poder armazená-los na memória e poder referenciá-los
quando for preciso.
É por isso que existem as variáveis, que nada mais são do
que um espaço reservado na memória, e que possuem um
nome para facilitar a referência, onde seu conteúdo pode
ser alterado durante a execução do programa.
As variáveis podem ser de diversos tipos (int, char, float,
double, etc).

13. Variáveis
Nomes das Variáveis
Existem algumas regras básicas que regulam o batismo de
variáveis.
 Todo nome só pode conter letras e dígitos;
 O caractere "_" é contado como uma letra;
 Todo primeiro caractere deve ser sempre uma letra;
 Letras maiúsculas e minúsculas são consideradas
caracteres diferentes.
Palavras reservadas não podem ser usadas como nome de
variáveis.

14. É boa política escolher nomes que significam alguma
coisa e indiquem a função da variável. Por exemplo: valor,
soma, total, nome, raio.
Declaração de variáveis:
Para serem usadas, as variáveis precisam ser declaradas de
modo que o compilador possa reservar espaço na memória
para o valor a ser armazenado. A forma geral de uma
declaração é:
tipo lista_de_variaveis ;
IMPORTANTE: Todas as variáveis em C devem ser
declaradas antes de serem usadas.

15. Exemplos:
int i;
unsigned int a, b, c;
unsigned short int dia, mes, ano;
double salario;

16. Atribuição de valores às variáveis
Após ser declarada, a variável pode receber valores. O
operador de atribuição "=" indica que o valor à direita será
atribuído à variável. O valor inicial pode ser atribuído de
duas formas:
Durante a declaração da variável:
int i=0, j=10;
float raio=2.54;
char c='d';

17. Durante execução da função:
int funcao()
{
int i, j;
float raio;
char c;
i = 0;
j = 10;
raio = 2.54;
c = 'd';
...
}

18. Ponto fixo
Denotamos um número de ponto fixo quando
especificamos o número de casas para a parte inteira e
fracionária.
Exemplo: Ponto fixo 1.15 (Um bit para a parte inteira e
quinze para a parte fracionária).
Neste caso sempre teremos números menores que dois,
pois como está reservado somente um bit para a parte
inteira, o maior valor que esse bit pode valer é 1. A parte
fracionária começa do 2^-1 e vai até o 2^-15. Esses valores
são interpretados literalmente.
Exemplo: o binário 1010 0000 0000 0000 corresponde a
2^0 + 2^-2 = 1.25.

19. Ponto flutuante (IEEE 754)
Precisão simples
Possui 32 bits
Uso dos bits:
 Sinal - Um bit que indica se o número é positivo (0) ou se
é negativo (1).
 Expoente - Um byte que contem o expoente. O expoente
corresponde a soma do expoente com 127 (ou seja, para
encontrar o verdadeiro valor do expoente, deve-se subtrair
esse byte de 127. Atenção: o expoente com valor zerado
(00h) ou todo ativado (FFh) tem significado especial
expoente.

20. Parte fracionária - Representa a parte fracionária do
número.
E a parte inteira do número?
Resposta: O ponto flutuante proposto pela IEEE 754
sugere que usemos números em notação científica de modo
que (em binário):
101.11 x 2 ^ 15 = 1.0111 x 2 ^ 17
Ou seja: quando trabalhamos com notação científica, se
temos um número que tenha mais de uma casa inteira,
mechemos no expoente de modo que fique com uma.
Assim ganhamos uma casa pro expoente.

21. PRÁTICA:

22. #include <stdio.h>
EXEMPLO:
#include <stdlib.h>
#define PI 3.14159265;
int main (void)
{
float raio;
double area, comprimento;
printf ("Digite o raio do seu circulo:n cmr");
scanf ("%f", &raio);
area = (raio*raio)*PI;
comprimento = raio*2*PI;
system ("cls");
printf ("A area do seu circulo e: %.2f cmn", area);
printf ("O comprimento do seu circulo e: %.2f cm", comprimento);
printf ("nn");
system ("pause");
}

23. Escopo e visibilidade
A visibilidade de um identificador determina as porções do programa no
qual este identificador pode ser referenciado, ou seja, o seu escopo.
Um identificador é visível somente dentro de seu escopo, que pode ser
limitado para o arquivo, função, bloco, ou protótipo de função no qual
ele aparece.
Assim, o escopo de um identificador é a parte do programa no qual o seu
nome pode ser usado.

24. #include <stdio.h>
EXEMPLO:
int i = 1; // definido num nível externo
int main (void)
{
printf(“%dn”, i);
{
int i = 2, j = 3;
printf(“%d %dn”, i, j); // imprime 2 e 3
{
int i = 0;
printf(“%d %dn”, i, j); // imprime 0 e 3
}
printf(“%dn”, i); // imprime 2
}
printf (“%dn“, i); // imprime 1
return 0;
}

25. Modificadores de Tipo de Acesso
Controlam a forma como as variáveis podem ser modificadas ou
acessadas:
 const
 volatile
Obs: Na declaração, esses modificadores devem preceder o tipo das
variáveis.
const:
faz com que a variável possa apenas receber um valor inicial, não
podendo ser alterada durante a execução do programa.
Exemplo:
const int a= 10;

26. Modificadores de Tipo de Acesso
volatile:
é usado quando uma variável precisa ser alterada de forma não
explícita no código do programa. Por exemplo, uma variável que
armazena o tempo real do sistema, sendo alterada pela rotina de relógio
do sistema operacional, e não por um comando de atribuição, precisa ser
declarada como volatile.
Exemplo da declaração:
volatile char *address=0x3b;

27. Especificadores de Classe de Armazenamento
Além dos modificadores vistos acima, que informam ao compilador a
forma de acessar ou alterar uma variável, existe também os
especificadores de classe de armazenamento, que informam ao
compilador a forma como a variável deve ser armazenada.
Há quatro especificadores em C:
 extern
 static
 register
 auto

28. Especificadores de Classe de Armazenamento
O especificador extern diz ao compilador que a variável indicada foi
declarada em outro arquivo que não podemos incluir diretamente, por
exemplo o código de uma biblioteca padrão. Isso é importante pois, se
não colocarmos o modificador extern, o compilador irá declarar uma
nova variável com o nome especificado, "ocultando" a variável que
realmente desejamos usar.
É usado para variáveis globais não estáticas.
extern float sum;
extern int count;
float returnSum (void)
{
count++;
return sum;
}

29. Especificadores de Classe de Armazenamento
As variáveis declaradas como static dependem se são globais ou locais:
 Variáveis globais static funcionam como variáveis globais dentro de um
módulo, ou seja, são variáveis globais que não são (e nem podem ser)
conhecidas em outros módulos (arquivos). Isto é útil se quisermos isolar
pedaços de um programa para evitar mudanças acidentais em variáveis
globais.
 Variáveis locais estáticas são variáveis cujo valor é mantido de uma
chamada da função para a outra.
int count (void)
{
static int num = 0;
num++;
return num;
}

30. Especificadores de Classe de Armazenamento
O especificador register informa ao compilador que a variável deve ser
armazenada em um registrador da CPU, e não na memória. Isto aumenta
consideravelmente a velocidade de acesso.
Inicialmente, somente as variáveis int e char poderiam ser register. O
padrão ANSI então determinou que qualquer tipo pode utilizar o
especificador register. Como alguns tipos de dados não cabem em um
registrador, o compilador trata variáveis register de forma que o acesso
seja o mais rápido possível. (Somente variáveis locais podem ser
register).
O uso do especificador auto é redundante. Todas as variáveis que não
possuem um especificador são auto por default.

31. Operadores:

32. Regras de Precedência

33. Operador sizeof()
O operador sizeof() é um operador unário que retorna o tamanho em
bytes da expressão ou tipo fornecido como parâmetro.
Por exemplo, suponha que o tipo float tenha quatro bytes então a
função sizeof(float) retorna o valor quatro.
Para se calcular o tamanho de bytes de uma expressão não é necessário
o uso de parênteses.

34. Exemplo
#define DIM 10
#include ...
int main()
{
int i=0;
float f=3.0;
char c='a';
int v[DIM];
printf("Tamanho em bytes de alguns tiposn");
printf("Tamanho de int %dn", sizeof i);
printf("Tamanho do float %dn", sizeof f);
printf("Tamanho do double %dn", sizeof (double));
printf("Tamanho do char %dn", sizeof c);
printf("Tamanho do vetor de %d inteiros e %dn", DIM, sizeof v);
}

35. Conversão de Tipos
Quando operandos de tipos diferentes aparecem em expressões eles
são convertidos para um tipo comum, que permita o cálculo da
expressão da forma mais eficientes.
Por exemplo, uma operação que envolva um tipo inteiro e um float,
o valor inteiro é convertido para float.
As conversões ocorrem somente quando necessário. Assim, em uma
divisão de inteiros o resultado é do tipo inteiro.
Ex.: A expressão 1/4*4 tem como resultado o valor inteiro 0. Já que
a primeira expressão executada 1/4 tem como resultado 0.

36. Conversão de Tipos
Operandos do tipo char e int podem ser livremente misturados em
expressões aritméticas. Os tipos char são convertidos para int
(conjunto de caracteres na tabela ASCII).
Exemplo: A conversão de uma letra maiúscula para minúscula pode
ser facilmente implementada com o comando:
c = c - 'A' + 'a'; // A letra armazenada na variável c é subtraída do
código da letra maiúscula 'A', fornecendo a posição desta letra no
alfabeto. Em seguida este valor é somado ao código da letra
minúscula 'a' resultando da conversão para minúscula.
As conversões aritméticas ocorrem de maneira quase que natural.

37. Correspondência entre:
Decimal,
Hexadecimal,
Octal e
Caracter

38. Conversão de Tipos
Em operações binárias as seguintes conversões ocorrem quando
diferentes tipos estão envolvidos:
char é convertido para int
float é convertido para double
Então se algum dos operandos é double o outro é convertido para
double e o resultado é double. Isto vale para os demais tipos.
Assim, o resultado de uma expressão ao ser avaliado é convertido
para o tipo da variável onde o resultado será armazenado. Um
resultado float ao ser carregado em uma variável do tipo int causa o
truncamento da parte fracionária porventura existente.

39. EXEMPLO: